Mercurial > hg > CbC > CbC_gcc
annotate gcc/gimple-pretty-print.c @ 132:d34655255c78
update gcc-8.2
| author | mir3636 |
|---|---|
| date | Thu, 25 Oct 2018 10:21:07 +0900 |
| parents | 84e7813d76e9 |
| children | 1830386684a0 |
| rev | line source |
|---|---|
| 0 | 1 /* Pretty formatting of GIMPLE statements and expressions. |
| 131 | 2 Copyright (C) 2001-2018 Free Software Foundation, Inc. |
| 0 | 3 Contributed by Aldy Hernandez <aldyh@redhat.com> and |
| 4 Diego Novillo <dnovillo@google.com> | |
| 5 | |
| 6 This file is part of GCC. | |
| 7 | |
| 8 GCC is free software; you can redistribute it and/or modify it under | |
| 9 the terms of the GNU General Public License as published by the Free | |
| 10 Software Foundation; either version 3, or (at your option) any later | |
| 11 version. | |
| 12 | |
| 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 19 along with GCC; see the file COPYING3. If not see | |
| 20 <http://www.gnu.org/licenses/>. */ | |
| 21 | |
| 22 #include "config.h" | |
| 23 #include "system.h" | |
| 24 #include "coretypes.h" | |
| 111 | 25 #include "dumpfile.h" |
| 26 #include "backend.h" | |
| 0 | 27 #include "tree.h" |
| 111 | 28 #include "gimple.h" |
| 29 #include "gimple-predict.h" | |
| 30 #include "ssa.h" | |
| 31 #include "cgraph.h" | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
32 #include "gimple-pretty-print.h" |
| 111 | 33 #include "internal-fn.h" |
| 34 #include "tree-eh.h" | |
| 35 #include "gimple-iterator.h" | |
| 36 #include "tree-cfg.h" | |
| 37 #include "dumpfile.h" /* for dump_flags */ | |
| 0 | 38 #include "value-prof.h" |
| 111 | 39 #include "trans-mem.h" |
| 40 #include "cfganal.h" | |
| 41 #include "stringpool.h" | |
| 42 #include "attribs.h" | |
| 43 #include "asan.h" | |
| 0 | 44 |
| 45 #define INDENT(SPACE) \ | |
| 46 do { int i; for (i = 0; i < SPACE; i++) pp_space (buffer); } while (0) | |
| 47 | |
| 48 #define GIMPLE_NIY do_niy (buffer,gs) | |
| 49 | |
| 50 /* Try to print on BUFFER a default message for the unrecognized | |
| 51 gimple statement GS. */ | |
| 52 | |
| 53 static void | |
| 111 | 54 do_niy (pretty_printer *buffer, gimple *gs) |
| 0 | 55 { |
| 56 pp_printf (buffer, "<<< Unknown GIMPLE statement: %s >>>\n", | |
| 57 gimple_code_name[(int) gimple_code (gs)]); | |
| 58 } | |
| 59 | |
| 60 | |
| 111 | 61 /* Emit a newline and SPC indentation spaces to BUFFER. */ |
| 0 | 62 |
| 63 static void | |
| 64 newline_and_indent (pretty_printer *buffer, int spc) | |
| 65 { | |
| 66 pp_newline (buffer); | |
| 67 INDENT (spc); | |
| 68 } | |
| 69 | |
| 70 | |
| 71 /* Print the GIMPLE statement GS on stderr. */ | |
| 72 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
73 DEBUG_FUNCTION void |
| 111 | 74 debug_gimple_stmt (gimple *gs) |
| 0 | 75 { |
| 76 print_gimple_stmt (stderr, gs, 0, TDF_VOPS|TDF_MEMSYMS); | |
| 77 } | |
| 78 | |
| 79 | |
| 111 | 80 /* Return formatted string of a VALUE probability |
| 81 (biased by REG_BR_PROB_BASE). Returned string is allocated | |
| 82 by xstrdup_for_dump. */ | |
| 83 | |
| 84 static const char * | |
| 131 | 85 dump_profile (profile_count &count) |
| 111 | 86 { |
| 131 | 87 char *buf = NULL; |
| 88 if (!count.initialized_p ()) | |
| 89 return ""; | |
| 90 if (count.ipa_p ()) | |
| 91 buf = xasprintf ("[count: %" PRId64 "]", | |
| 111 | 92 count.to_gcov_type ()); |
| 131 | 93 else if (count.initialized_p ()) |
| 94 buf = xasprintf ("[local count: %" PRId64 "]", | |
| 95 count.to_gcov_type ()); | |
| 111 | 96 |
| 97 const char *ret = xstrdup_for_dump (buf); | |
| 98 free (buf); | |
| 99 | |
| 100 return ret; | |
| 101 } | |
| 102 | |
| 103 /* Return formatted string of a VALUE probability | |
| 104 (biased by REG_BR_PROB_BASE). Returned string is allocated | |
| 105 by xstrdup_for_dump. */ | |
| 106 | |
| 107 static const char * | |
| 108 dump_probability (profile_probability probability) | |
| 109 { | |
| 110 float minimum = 0.01f; | |
| 111 float fvalue = -1; | |
| 112 | |
| 113 if (probability.initialized_p ()) | |
| 114 { | |
| 115 fvalue = probability.to_reg_br_prob_base () * 100.0f / REG_BR_PROB_BASE; | |
| 116 if (fvalue < minimum && probability.to_reg_br_prob_base ()) | |
| 117 fvalue = minimum; | |
| 118 } | |
| 119 | |
| 120 char *buf; | |
| 121 if (probability.initialized_p ()) | |
| 122 buf = xasprintf ("[%.2f%%]", fvalue); | |
| 123 else | |
| 124 buf = xasprintf ("[INV]"); | |
| 125 | |
| 126 const char *ret = xstrdup_for_dump (buf); | |
| 127 free (buf); | |
| 128 | |
| 129 return ret; | |
| 130 } | |
| 131 | |
| 132 /* Dump E probability to BUFFER. */ | |
| 133 | |
| 134 static void | |
| 135 dump_edge_probability (pretty_printer *buffer, edge e) | |
| 136 { | |
| 137 pp_scalar (buffer, " %s", dump_probability (e->probability)); | |
| 138 } | |
| 139 | |
| 140 /* Print GIMPLE statement G to FILE using SPC indentation spaces and | |
| 141 FLAGS as in pp_gimple_stmt_1. */ | |
| 0 | 142 |
| 143 void | |
| 111 | 144 print_gimple_stmt (FILE *file, gimple *g, int spc, dump_flags_t flags) |
| 145 { | |
| 146 pretty_printer buffer; | |
| 147 pp_needs_newline (&buffer) = true; | |
| 148 buffer.buffer->stream = file; | |
| 149 pp_gimple_stmt_1 (&buffer, g, spc, flags); | |
| 150 pp_newline_and_flush (&buffer); | |
| 151 } | |
| 152 | |
| 153 DEBUG_FUNCTION void | |
| 154 debug (gimple &ref) | |
| 155 { | |
| 131 | 156 print_gimple_stmt (stderr, &ref, 0, TDF_NONE); |
| 111 | 157 } |
| 158 | |
| 159 DEBUG_FUNCTION void | |
| 160 debug (gimple *ptr) | |
| 0 | 161 { |
| 111 | 162 if (ptr) |
| 163 debug (*ptr); | |
| 164 else | |
| 165 fprintf (stderr, "<nil>\n"); | |
| 166 } | |
| 167 | |
| 168 | |
| 169 /* Print GIMPLE statement G to FILE using SPC indentation spaces and | |
| 170 FLAGS as in pp_gimple_stmt_1. Print only the right-hand side | |
| 171 of the statement. */ | |
| 172 | |
| 173 void | |
| 174 print_gimple_expr (FILE *file, gimple *g, int spc, dump_flags_t flags) | |
| 175 { | |
| 176 flags |= TDF_RHS_ONLY; | |
| 177 pretty_printer buffer; | |
| 178 pp_needs_newline (&buffer) = true; | |
| 179 buffer.buffer->stream = file; | |
| 180 pp_gimple_stmt_1 (&buffer, g, spc, flags); | |
| 0 | 181 pp_flush (&buffer); |
| 182 } | |
| 183 | |
| 184 | |
| 111 | 185 /* Print the GIMPLE sequence SEQ on BUFFER using SPC indentation |
| 186 spaces and FLAGS as in pp_gimple_stmt_1. | |
| 187 The caller is responsible for calling pp_flush on BUFFER to finalize | |
| 188 the pretty printer. */ | |
| 0 | 189 |
| 190 static void | |
| 111 | 191 dump_gimple_seq (pretty_printer *buffer, gimple_seq seq, int spc, |
| 192 dump_flags_t flags) | |
| 0 | 193 { |
| 194 gimple_stmt_iterator i; | |
| 195 | |
| 196 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i)) | |
| 197 { | |
| 111 | 198 gimple *gs = gsi_stmt (i); |
| 0 | 199 INDENT (spc); |
| 111 | 200 pp_gimple_stmt_1 (buffer, gs, spc, flags); |
| 0 | 201 if (!gsi_one_before_end_p (i)) |
| 202 pp_newline (buffer); | |
| 203 } | |
| 204 } | |
| 205 | |
| 206 | |
| 111 | 207 /* Print GIMPLE sequence SEQ to FILE using SPC indentation spaces and |
| 208 FLAGS as in pp_gimple_stmt_1. */ | |
| 0 | 209 |
| 210 void | |
| 111 | 211 print_gimple_seq (FILE *file, gimple_seq seq, int spc, dump_flags_t flags) |
| 0 | 212 { |
| 111 | 213 pretty_printer buffer; |
| 214 pp_needs_newline (&buffer) = true; | |
| 215 buffer.buffer->stream = file; | |
| 0 | 216 dump_gimple_seq (&buffer, seq, spc, flags); |
| 111 | 217 pp_newline_and_flush (&buffer); |
| 0 | 218 } |
| 219 | |
| 220 | |
| 221 /* Print the GIMPLE sequence SEQ on stderr. */ | |
| 222 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
223 DEBUG_FUNCTION void |
| 0 | 224 debug_gimple_seq (gimple_seq seq) |
| 225 { | |
| 226 print_gimple_seq (stderr, seq, 0, TDF_VOPS|TDF_MEMSYMS); | |
| 227 } | |
| 228 | |
| 229 | |
| 230 /* A simple helper to pretty-print some of the gimple tuples in the printf | |
| 111 | 231 style. The format modifiers are preceded by '%' and are: |
| 0 | 232 'G' - outputs a string corresponding to the code of the given gimple, |
| 233 'S' - outputs a gimple_seq with indent of spc + 2, | |
| 234 'T' - outputs the tree t, | |
| 235 'd' - outputs an int as a decimal, | |
| 236 's' - outputs a string, | |
| 237 'n' - outputs a newline, | |
| 111 | 238 'x' - outputs an int as hexadecimal, |
| 0 | 239 '+' - increases indent by 2 then outputs a newline, |
| 240 '-' - decreases indent by 2 then outputs a newline. */ | |
| 241 | |
| 242 static void | |
| 111 | 243 dump_gimple_fmt (pretty_printer *buffer, int spc, dump_flags_t flags, |
| 0 | 244 const char *fmt, ...) |
| 245 { | |
| 246 va_list args; | |
| 247 const char *c; | |
| 248 const char *tmp; | |
| 249 | |
| 250 va_start (args, fmt); | |
| 251 for (c = fmt; *c; c++) | |
| 252 { | |
| 253 if (*c == '%') | |
| 254 { | |
| 255 gimple_seq seq; | |
| 256 tree t; | |
| 111 | 257 gimple *g; |
| 0 | 258 switch (*++c) |
| 259 { | |
| 260 case 'G': | |
| 111 | 261 g = va_arg (args, gimple *); |
| 0 | 262 tmp = gimple_code_name[gimple_code (g)]; |
| 263 pp_string (buffer, tmp); | |
| 264 break; | |
| 265 | |
| 266 case 'S': | |
| 267 seq = va_arg (args, gimple_seq); | |
| 268 pp_newline (buffer); | |
| 269 dump_gimple_seq (buffer, seq, spc + 2, flags); | |
| 270 newline_and_indent (buffer, spc); | |
| 271 break; | |
| 272 | |
| 273 case 'T': | |
| 274 t = va_arg (args, tree); | |
| 275 if (t == NULL_TREE) | |
| 276 pp_string (buffer, "NULL"); | |
| 277 else | |
| 278 dump_generic_node (buffer, t, spc, flags, false); | |
| 279 break; | |
| 280 | |
| 281 case 'd': | |
| 282 pp_decimal_int (buffer, va_arg (args, int)); | |
| 283 break; | |
| 284 | |
| 285 case 's': | |
| 286 pp_string (buffer, va_arg (args, char *)); | |
| 287 break; | |
| 288 | |
| 289 case 'n': | |
| 290 newline_and_indent (buffer, spc); | |
| 291 break; | |
| 292 | |
| 111 | 293 case 'x': |
| 294 pp_scalar (buffer, "%x", va_arg (args, int)); | |
| 295 break; | |
| 296 | |
| 0 | 297 case '+': |
| 298 spc += 2; | |
| 299 newline_and_indent (buffer, spc); | |
| 300 break; | |
| 301 | |
| 302 case '-': | |
| 303 spc -= 2; | |
| 304 newline_and_indent (buffer, spc); | |
| 305 break; | |
| 306 | |
| 307 default: | |
| 308 gcc_unreachable (); | |
| 309 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
310 } |
| 0 | 311 else |
| 312 pp_character (buffer, *c); | |
| 313 } | |
| 314 va_end (args); | |
| 315 } | |
| 316 | |
| 317 | |
| 318 /* Helper for dump_gimple_assign. Print the unary RHS of the | |
| 111 | 319 assignment GS. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. */ |
| 0 | 320 |
| 321 static void | |
| 111 | 322 dump_unary_rhs (pretty_printer *buffer, gassign *gs, int spc, |
| 323 dump_flags_t flags) | |
| 0 | 324 { |
| 325 enum tree_code rhs_code = gimple_assign_rhs_code (gs); | |
| 326 tree lhs = gimple_assign_lhs (gs); | |
| 327 tree rhs = gimple_assign_rhs1 (gs); | |
| 328 | |
| 329 switch (rhs_code) | |
| 330 { | |
| 331 case VIEW_CONVERT_EXPR: | |
| 332 case ASSERT_EXPR: | |
| 333 dump_generic_node (buffer, rhs, spc, flags, false); | |
| 334 break; | |
| 335 | |
| 336 case FIXED_CONVERT_EXPR: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
337 case ADDR_SPACE_CONVERT_EXPR: |
| 0 | 338 case FIX_TRUNC_EXPR: |
| 339 case FLOAT_EXPR: | |
| 340 CASE_CONVERT: | |
| 111 | 341 pp_left_paren (buffer); |
| 0 | 342 dump_generic_node (buffer, TREE_TYPE (lhs), spc, flags, false); |
| 343 pp_string (buffer, ") "); | |
| 344 if (op_prio (rhs) < op_code_prio (rhs_code)) | |
| 345 { | |
| 111 | 346 pp_left_paren (buffer); |
| 0 | 347 dump_generic_node (buffer, rhs, spc, flags, false); |
| 111 | 348 pp_right_paren (buffer); |
| 0 | 349 } |
| 350 else | |
| 351 dump_generic_node (buffer, rhs, spc, flags, false); | |
| 352 break; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
353 |
| 0 | 354 case PAREN_EXPR: |
| 355 pp_string (buffer, "(("); | |
| 356 dump_generic_node (buffer, rhs, spc, flags, false); | |
| 357 pp_string (buffer, "))"); | |
| 358 break; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
359 |
| 0 | 360 case ABS_EXPR: |
| 131 | 361 case ABSU_EXPR: |
| 111 | 362 if (flags & TDF_GIMPLE) |
| 363 { | |
| 131 | 364 pp_string (buffer, |
| 365 rhs_code == ABS_EXPR ? "__ABS " : "__ABSU "); | |
| 111 | 366 dump_generic_node (buffer, rhs, spc, flags, false); |
| 367 } | |
| 368 else | |
| 369 { | |
| 131 | 370 pp_string (buffer, |
| 371 rhs_code == ABS_EXPR ? "ABS_EXPR <" : "ABSU_EXPR <"); | |
| 111 | 372 dump_generic_node (buffer, rhs, spc, flags, false); |
| 373 pp_greater (buffer); | |
| 374 } | |
| 0 | 375 break; |
| 376 | |
| 377 default: | |
| 378 if (TREE_CODE_CLASS (rhs_code) == tcc_declaration | |
| 379 || TREE_CODE_CLASS (rhs_code) == tcc_constant | |
| 380 || TREE_CODE_CLASS (rhs_code) == tcc_reference | |
| 381 || rhs_code == SSA_NAME | |
| 382 || rhs_code == ADDR_EXPR | |
| 383 || rhs_code == CONSTRUCTOR) | |
| 384 { | |
| 385 dump_generic_node (buffer, rhs, spc, flags, false); | |
| 386 break; | |
| 387 } | |
| 388 else if (rhs_code == BIT_NOT_EXPR) | |
| 111 | 389 pp_complement (buffer); |
| 0 | 390 else if (rhs_code == TRUTH_NOT_EXPR) |
| 111 | 391 pp_exclamation (buffer); |
| 0 | 392 else if (rhs_code == NEGATE_EXPR) |
| 111 | 393 pp_minus (buffer); |
| 0 | 394 else |
| 395 { | |
| 111 | 396 pp_left_bracket (buffer); |
| 397 pp_string (buffer, get_tree_code_name (rhs_code)); | |
| 0 | 398 pp_string (buffer, "] "); |
| 399 } | |
| 400 | |
| 401 if (op_prio (rhs) < op_code_prio (rhs_code)) | |
| 402 { | |
| 111 | 403 pp_left_paren (buffer); |
| 0 | 404 dump_generic_node (buffer, rhs, spc, flags, false); |
| 111 | 405 pp_right_paren (buffer); |
| 0 | 406 } |
| 407 else | |
| 408 dump_generic_node (buffer, rhs, spc, flags, false); | |
| 409 break; | |
| 410 } | |
| 411 } | |
| 412 | |
| 413 | |
| 414 /* Helper for dump_gimple_assign. Print the binary RHS of the | |
| 111 | 415 assignment GS. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. */ |
| 0 | 416 |
| 417 static void | |
| 111 | 418 dump_binary_rhs (pretty_printer *buffer, gassign *gs, int spc, |
| 419 dump_flags_t flags) | |
| 0 | 420 { |
| 421 const char *p; | |
| 422 enum tree_code code = gimple_assign_rhs_code (gs); | |
| 423 switch (code) | |
| 424 { | |
| 425 case COMPLEX_EXPR: | |
| 426 case MIN_EXPR: | |
| 427 case MAX_EXPR: | |
| 428 case VEC_WIDEN_MULT_HI_EXPR: | |
| 429 case VEC_WIDEN_MULT_LO_EXPR: | |
| 111 | 430 case VEC_WIDEN_MULT_EVEN_EXPR: |
| 431 case VEC_WIDEN_MULT_ODD_EXPR: | |
| 0 | 432 case VEC_PACK_TRUNC_EXPR: |
| 433 case VEC_PACK_SAT_EXPR: | |
| 434 case VEC_PACK_FIX_TRUNC_EXPR: | |
| 131 | 435 case VEC_PACK_FLOAT_EXPR: |
| 111 | 436 case VEC_WIDEN_LSHIFT_HI_EXPR: |
| 437 case VEC_WIDEN_LSHIFT_LO_EXPR: | |
| 131 | 438 case VEC_SERIES_EXPR: |
| 111 | 439 for (p = get_tree_code_name (code); *p; p++) |
| 0 | 440 pp_character (buffer, TOUPPER (*p)); |
| 441 pp_string (buffer, " <"); | |
| 442 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); | |
| 443 pp_string (buffer, ", "); | |
| 444 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); | |
| 111 | 445 pp_greater (buffer); |
| 0 | 446 break; |
| 447 | |
| 448 default: | |
| 449 if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code)) | |
| 450 { | |
| 111 | 451 pp_left_paren (buffer); |
| 0 | 452 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, |
| 453 false); | |
| 111 | 454 pp_right_paren (buffer); |
| 0 | 455 } |
| 456 else | |
| 457 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); | |
| 458 pp_space (buffer); | |
| 459 pp_string (buffer, op_symbol_code (gimple_assign_rhs_code (gs))); | |
| 460 pp_space (buffer); | |
| 461 if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code)) | |
| 462 { | |
| 111 | 463 pp_left_paren (buffer); |
| 0 | 464 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, |
| 465 false); | |
| 111 | 466 pp_right_paren (buffer); |
| 0 | 467 } |
| 468 else | |
| 469 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); | |
| 470 } | |
| 471 } | |
| 472 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
473 /* Helper for dump_gimple_assign. Print the ternary RHS of the |
| 111 | 474 assignment GS. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. */ |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
475 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
476 static void |
| 111 | 477 dump_ternary_rhs (pretty_printer *buffer, gassign *gs, int spc, |
| 478 dump_flags_t flags) | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
479 { |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
480 const char *p; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
481 enum tree_code code = gimple_assign_rhs_code (gs); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
482 switch (code) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
483 { |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
484 case WIDEN_MULT_PLUS_EXPR: |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
485 case WIDEN_MULT_MINUS_EXPR: |
| 111 | 486 for (p = get_tree_code_name (code); *p; p++) |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
487 pp_character (buffer, TOUPPER (*p)); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
488 pp_string (buffer, " <"); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
489 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
490 pp_string (buffer, ", "); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
491 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
492 pp_string (buffer, ", "); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
493 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); |
| 111 | 494 pp_greater (buffer); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
495 break; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
496 |
| 111 | 497 case DOT_PROD_EXPR: |
| 498 pp_string (buffer, "DOT_PROD_EXPR <"); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
499 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); |
| 111 | 500 pp_string (buffer, ", "); |
| 501 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); | |
| 502 pp_string (buffer, ", "); | |
| 503 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); | |
| 504 pp_greater (buffer); | |
| 505 break; | |
| 506 | |
| 507 case SAD_EXPR: | |
| 508 pp_string (buffer, "SAD_EXPR <"); | |
| 509 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); | |
| 510 pp_string (buffer, ", "); | |
| 511 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); | |
| 512 pp_string (buffer, ", "); | |
| 513 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); | |
| 514 pp_greater (buffer); | |
| 515 break; | |
| 516 | |
| 517 case VEC_PERM_EXPR: | |
| 518 pp_string (buffer, "VEC_PERM_EXPR <"); | |
| 519 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); | |
| 520 pp_string (buffer, ", "); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
521 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); |
| 111 | 522 pp_string (buffer, ", "); |
| 523 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); | |
| 524 pp_greater (buffer); | |
| 525 break; | |
| 526 | |
| 527 case REALIGN_LOAD_EXPR: | |
| 528 pp_string (buffer, "REALIGN_LOAD <"); | |
| 529 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); | |
| 530 pp_string (buffer, ", "); | |
| 531 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); | |
| 532 pp_string (buffer, ", "); | |
| 533 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); | |
| 534 pp_greater (buffer); | |
| 535 break; | |
| 536 | |
| 537 case COND_EXPR: | |
| 538 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); | |
| 539 pp_string (buffer, " ? "); | |
| 540 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); | |
| 541 pp_string (buffer, " : "); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
542 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
543 break; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
544 |
| 111 | 545 case VEC_COND_EXPR: |
| 546 pp_string (buffer, "VEC_COND_EXPR <"); | |
| 547 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); | |
| 548 pp_string (buffer, ", "); | |
| 549 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); | |
| 550 pp_string (buffer, ", "); | |
| 551 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); | |
| 552 pp_greater (buffer); | |
| 553 break; | |
| 554 | |
| 555 case BIT_INSERT_EXPR: | |
| 556 pp_string (buffer, "BIT_INSERT_EXPR <"); | |
| 557 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); | |
| 558 pp_string (buffer, ", "); | |
| 559 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); | |
| 560 pp_string (buffer, ", "); | |
| 561 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); | |
| 562 pp_string (buffer, " ("); | |
| 563 if (INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_rhs2 (gs)))) | |
| 564 pp_decimal_int (buffer, | |
| 565 TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs2 (gs)))); | |
| 566 else | |
| 567 dump_generic_node (buffer, | |
| 568 TYPE_SIZE (TREE_TYPE (gimple_assign_rhs2 (gs))), | |
| 569 spc, flags, false); | |
| 570 pp_string (buffer, " bits)>"); | |
| 571 break; | |
| 572 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
573 default: |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
574 gcc_unreachable (); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
575 } |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
576 } |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
577 |
| 0 | 578 |
| 579 /* Dump the gimple assignment GS. BUFFER, SPC and FLAGS are as in | |
| 111 | 580 pp_gimple_stmt_1. */ |
| 0 | 581 |
| 582 static void | |
| 111 | 583 dump_gimple_assign (pretty_printer *buffer, gassign *gs, int spc, |
| 584 dump_flags_t flags) | |
| 0 | 585 { |
| 586 if (flags & TDF_RAW) | |
| 587 { | |
| 111 | 588 tree arg1 = NULL; |
| 589 tree arg2 = NULL; | |
| 590 tree arg3 = NULL; | |
| 591 switch (gimple_num_ops (gs)) | |
| 592 { | |
| 593 case 4: | |
| 594 arg3 = gimple_assign_rhs3 (gs); | |
| 595 /* FALLTHRU */ | |
| 596 case 3: | |
| 597 arg2 = gimple_assign_rhs2 (gs); | |
| 598 /* FALLTHRU */ | |
| 599 case 2: | |
| 600 arg1 = gimple_assign_rhs1 (gs); | |
| 601 break; | |
| 602 default: | |
| 603 gcc_unreachable (); | |
| 604 } | |
| 0 | 605 |
| 111 | 606 dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs, |
| 607 get_tree_code_name (gimple_assign_rhs_code (gs)), | |
| 608 gimple_assign_lhs (gs), arg1, arg2, arg3); | |
| 0 | 609 } |
| 610 else | |
| 611 { | |
| 612 if (!(flags & TDF_RHS_ONLY)) | |
| 613 { | |
| 614 dump_generic_node (buffer, gimple_assign_lhs (gs), spc, flags, false); | |
| 615 pp_space (buffer); | |
| 111 | 616 pp_equal (buffer); |
| 0 | 617 |
| 618 if (gimple_assign_nontemporal_move_p (gs)) | |
| 619 pp_string (buffer, "{nt}"); | |
| 620 | |
| 621 if (gimple_has_volatile_ops (gs)) | |
| 622 pp_string (buffer, "{v}"); | |
| 623 | |
| 624 pp_space (buffer); | |
| 625 } | |
| 626 | |
| 627 if (gimple_num_ops (gs) == 2) | |
| 628 dump_unary_rhs (buffer, gs, spc, flags); | |
| 629 else if (gimple_num_ops (gs) == 3) | |
| 630 dump_binary_rhs (buffer, gs, spc, flags); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
631 else if (gimple_num_ops (gs) == 4) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
632 dump_ternary_rhs (buffer, gs, spc, flags); |
| 0 | 633 else |
| 634 gcc_unreachable (); | |
| 635 if (!(flags & TDF_RHS_ONLY)) | |
| 111 | 636 pp_semicolon (buffer); |
| 0 | 637 } |
| 638 } | |
| 639 | |
| 640 | |
| 641 /* Dump the return statement GS. BUFFER, SPC and FLAGS are as in | |
| 111 | 642 pp_gimple_stmt_1. */ |
| 0 | 643 |
| 644 static void | |
| 111 | 645 dump_gimple_return (pretty_printer *buffer, greturn *gs, int spc, |
| 646 dump_flags_t flags) | |
| 0 | 647 { |
| 131 | 648 tree t; |
| 0 | 649 |
| 650 t = gimple_return_retval (gs); | |
| 651 if (flags & TDF_RAW) | |
| 131 | 652 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, t); |
| 0 | 653 else |
| 654 { | |
| 655 pp_string (buffer, "return"); | |
| 656 if (t) | |
| 657 { | |
| 658 pp_space (buffer); | |
| 659 dump_generic_node (buffer, t, spc, flags, false); | |
| 660 } | |
| 661 pp_semicolon (buffer); | |
| 662 } | |
| 663 } | |
| 664 | |
| 665 | |
| 666 /* Dump the call arguments for a gimple call. BUFFER, FLAGS are as in | |
| 667 dump_gimple_call. */ | |
| 668 | |
| 669 static void | |
| 111 | 670 dump_gimple_call_args (pretty_printer *buffer, gcall *gs, dump_flags_t flags) |
| 0 | 671 { |
| 111 | 672 size_t i = 0; |
| 673 | |
| 674 /* Pretty print first arg to certain internal fns. */ | |
| 675 if (gimple_call_internal_p (gs)) | |
| 676 { | |
| 677 const char *const *enums = NULL; | |
| 678 unsigned limit = 0; | |
| 679 | |
| 680 switch (gimple_call_internal_fn (gs)) | |
| 681 { | |
| 682 case IFN_UNIQUE: | |
| 683 #define DEF(X) #X | |
| 684 static const char *const unique_args[] = {IFN_UNIQUE_CODES}; | |
| 685 #undef DEF | |
| 686 enums = unique_args; | |
| 687 | |
| 688 limit = ARRAY_SIZE (unique_args); | |
| 689 break; | |
| 690 | |
| 691 case IFN_GOACC_LOOP: | |
| 692 #define DEF(X) #X | |
| 693 static const char *const loop_args[] = {IFN_GOACC_LOOP_CODES}; | |
| 694 #undef DEF | |
| 695 enums = loop_args; | |
| 696 limit = ARRAY_SIZE (loop_args); | |
| 697 break; | |
| 0 | 698 |
| 111 | 699 case IFN_GOACC_REDUCTION: |
| 700 #define DEF(X) #X | |
| 701 static const char *const reduction_args[] | |
| 702 = {IFN_GOACC_REDUCTION_CODES}; | |
| 703 #undef DEF | |
| 704 enums = reduction_args; | |
| 705 limit = ARRAY_SIZE (reduction_args); | |
| 706 break; | |
| 707 | |
| 708 case IFN_ASAN_MARK: | |
| 709 #define DEF(X) #X | |
| 710 static const char *const asan_mark_args[] = {IFN_ASAN_MARK_FLAGS}; | |
| 711 #undef DEF | |
| 712 enums = asan_mark_args; | |
| 713 limit = ARRAY_SIZE (asan_mark_args); | |
| 714 break; | |
| 715 | |
| 716 default: | |
| 717 break; | |
| 718 } | |
| 719 if (limit) | |
| 720 { | |
| 721 tree arg0 = gimple_call_arg (gs, 0); | |
| 722 HOST_WIDE_INT v; | |
| 723 | |
| 724 if (TREE_CODE (arg0) == INTEGER_CST | |
| 725 && tree_fits_shwi_p (arg0) | |
| 726 && (v = tree_to_shwi (arg0)) >= 0 && v < limit) | |
| 727 { | |
| 728 i++; | |
| 729 pp_string (buffer, enums[v]); | |
| 730 } | |
| 731 } | |
| 732 } | |
| 733 | |
| 734 for (; i < gimple_call_num_args (gs); i++) | |
| 0 | 735 { |
| 111 | 736 if (i) |
| 737 pp_string (buffer, ", "); | |
| 0 | 738 dump_generic_node (buffer, gimple_call_arg (gs, i), 0, flags, false); |
| 739 } | |
| 740 | |
| 741 if (gimple_call_va_arg_pack_p (gs)) | |
| 742 { | |
| 111 | 743 if (i) |
| 744 pp_string (buffer, ", "); | |
| 0 | 745 |
| 746 pp_string (buffer, "__builtin_va_arg_pack ()"); | |
| 747 } | |
| 748 } | |
| 749 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
750 /* Dump the points-to solution *PT to BUFFER. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
751 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
752 static void |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
753 pp_points_to_solution (pretty_printer *buffer, struct pt_solution *pt) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
754 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
755 if (pt->anything) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
756 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
757 pp_string (buffer, "anything "); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
758 return; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
759 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
760 if (pt->nonlocal) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
761 pp_string (buffer, "nonlocal "); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
762 if (pt->escaped) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
763 pp_string (buffer, "escaped "); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
764 if (pt->ipa_escaped) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
765 pp_string (buffer, "unit-escaped "); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
766 if (pt->null) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
767 pp_string (buffer, "null "); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
768 if (pt->vars |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
769 && !bitmap_empty_p (pt->vars)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
770 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
771 bitmap_iterator bi; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
772 unsigned i; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
773 pp_string (buffer, "{ "); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
774 EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
775 { |
| 111 | 776 pp_string (buffer, "D."); |
| 777 pp_decimal_int (buffer, i); | |
| 778 pp_space (buffer); | |
| 779 } | |
| 780 pp_right_brace (buffer); | |
| 781 if (pt->vars_contains_nonlocal | |
| 782 || pt->vars_contains_escaped | |
| 783 || pt->vars_contains_escaped_heap | |
| 784 || pt->vars_contains_restrict) | |
| 785 { | |
| 786 const char *comma = ""; | |
| 787 pp_string (buffer, " ("); | |
| 788 if (pt->vars_contains_nonlocal) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
789 { |
| 111 | 790 pp_string (buffer, "nonlocal"); |
| 791 comma = ", "; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
792 } |
| 111 | 793 if (pt->vars_contains_escaped) |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
794 { |
| 111 | 795 pp_string (buffer, comma); |
| 796 pp_string (buffer, "escaped"); | |
| 797 comma = ", "; | |
| 798 } | |
| 799 if (pt->vars_contains_escaped_heap) | |
| 800 { | |
| 801 pp_string (buffer, comma); | |
| 802 pp_string (buffer, "escaped heap"); | |
| 803 comma = ", "; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
804 } |
| 111 | 805 if (pt->vars_contains_restrict) |
| 806 { | |
| 807 pp_string (buffer, comma); | |
| 808 pp_string (buffer, "restrict"); | |
| 809 comma = ", "; | |
| 810 } | |
| 811 if (pt->vars_contains_interposable) | |
| 812 { | |
| 813 pp_string (buffer, comma); | |
| 814 pp_string (buffer, "interposable"); | |
| 815 } | |
| 816 pp_string (buffer, ")"); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
817 } |
| 111 | 818 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
819 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
820 } |
| 0 | 821 |
| 822 /* Dump the call statement GS. BUFFER, SPC and FLAGS are as in | |
| 111 | 823 pp_gimple_stmt_1. */ |
| 0 | 824 |
| 825 static void | |
| 111 | 826 dump_gimple_call (pretty_printer *buffer, gcall *gs, int spc, |
| 827 dump_flags_t flags) | |
| 0 | 828 { |
| 829 tree lhs = gimple_call_lhs (gs); | |
| 111 | 830 tree fn = gimple_call_fn (gs); |
| 0 | 831 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
832 if (flags & TDF_ALIAS) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
833 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
834 struct pt_solution *pt; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
835 pt = gimple_call_use_set (gs); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
836 if (!pt_solution_empty_p (pt)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
837 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
838 pp_string (buffer, "# USE = "); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
839 pp_points_to_solution (buffer, pt); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
840 newline_and_indent (buffer, spc); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
841 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
842 pt = gimple_call_clobber_set (gs); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
843 if (!pt_solution_empty_p (pt)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
844 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
845 pp_string (buffer, "# CLB = "); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
846 pp_points_to_solution (buffer, pt); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
847 newline_and_indent (buffer, spc); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
848 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
849 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
850 |
| 0 | 851 if (flags & TDF_RAW) |
| 852 { | |
| 111 | 853 if (gimple_call_internal_p (gs)) |
| 131 | 854 dump_gimple_fmt (buffer, spc, flags, "%G <.%s, %T", gs, |
| 111 | 855 internal_fn_name (gimple_call_internal_fn (gs)), lhs); |
| 856 else | |
| 857 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T", gs, fn, lhs); | |
| 0 | 858 if (gimple_call_num_args (gs) > 0) |
| 859 { | |
| 860 pp_string (buffer, ", "); | |
| 861 dump_gimple_call_args (buffer, gs, flags); | |
| 862 } | |
| 111 | 863 pp_greater (buffer); |
| 0 | 864 } |
| 865 else | |
| 866 { | |
| 867 if (lhs && !(flags & TDF_RHS_ONLY)) | |
| 868 { | |
| 869 dump_generic_node (buffer, lhs, spc, flags, false); | |
| 870 pp_string (buffer, " ="); | |
| 871 | |
| 872 if (gimple_has_volatile_ops (gs)) | |
| 873 pp_string (buffer, "{v}"); | |
| 874 | |
| 875 pp_space (buffer); | |
| 876 } | |
| 111 | 877 if (gimple_call_internal_p (gs)) |
| 131 | 878 { |
| 879 pp_dot (buffer); | |
| 880 pp_string (buffer, internal_fn_name (gimple_call_internal_fn (gs))); | |
| 881 } | |
| 111 | 882 else |
| 883 print_call_name (buffer, fn, flags); | |
| 0 | 884 pp_string (buffer, " ("); |
| 885 dump_gimple_call_args (buffer, gs, flags); | |
| 111 | 886 pp_right_paren (buffer); |
| 0 | 887 if (!(flags & TDF_RHS_ONLY)) |
| 888 pp_semicolon (buffer); | |
| 889 } | |
| 890 | |
| 891 if (gimple_call_chain (gs)) | |
| 892 { | |
| 893 pp_string (buffer, " [static-chain: "); | |
| 894 dump_generic_node (buffer, gimple_call_chain (gs), spc, flags, false); | |
| 111 | 895 pp_right_bracket (buffer); |
| 0 | 896 } |
| 897 | |
| 898 if (gimple_call_return_slot_opt_p (gs)) | |
| 899 pp_string (buffer, " [return slot optimization]"); | |
| 900 if (gimple_call_tail_p (gs)) | |
| 901 pp_string (buffer, " [tail call]"); | |
| 111 | 902 if (gimple_call_must_tail_p (gs)) |
| 903 pp_string (buffer, " [must tail call]"); | |
| 904 | |
| 905 if (fn == NULL) | |
| 906 return; | |
| 907 | |
| 908 /* Dump the arguments of _ITM_beginTransaction sanely. */ | |
| 909 if (TREE_CODE (fn) == ADDR_EXPR) | |
| 910 fn = TREE_OPERAND (fn, 0); | |
| 911 if (TREE_CODE (fn) == FUNCTION_DECL && decl_is_tm_clone (fn)) | |
| 912 pp_string (buffer, " [tm-clone]"); | |
| 913 if (TREE_CODE (fn) == FUNCTION_DECL | |
| 131 | 914 && fndecl_built_in_p (fn, BUILT_IN_TM_START) |
| 111 | 915 && gimple_call_num_args (gs) > 0) |
| 916 { | |
| 917 tree t = gimple_call_arg (gs, 0); | |
| 918 unsigned HOST_WIDE_INT props; | |
| 919 gcc_assert (TREE_CODE (t) == INTEGER_CST); | |
| 920 | |
| 921 pp_string (buffer, " [ "); | |
| 922 | |
| 923 /* Get the transaction code properties. */ | |
| 924 props = TREE_INT_CST_LOW (t); | |
| 925 | |
| 926 if (props & PR_INSTRUMENTEDCODE) | |
| 927 pp_string (buffer, "instrumentedCode "); | |
| 928 if (props & PR_UNINSTRUMENTEDCODE) | |
| 929 pp_string (buffer, "uninstrumentedCode "); | |
| 930 if (props & PR_HASNOXMMUPDATE) | |
| 931 pp_string (buffer, "hasNoXMMUpdate "); | |
| 932 if (props & PR_HASNOABORT) | |
| 933 pp_string (buffer, "hasNoAbort "); | |
| 934 if (props & PR_HASNOIRREVOCABLE) | |
| 935 pp_string (buffer, "hasNoIrrevocable "); | |
| 936 if (props & PR_DOESGOIRREVOCABLE) | |
| 937 pp_string (buffer, "doesGoIrrevocable "); | |
| 938 if (props & PR_HASNOSIMPLEREADS) | |
| 939 pp_string (buffer, "hasNoSimpleReads "); | |
| 940 if (props & PR_AWBARRIERSOMITTED) | |
| 941 pp_string (buffer, "awBarriersOmitted "); | |
| 942 if (props & PR_RARBARRIERSOMITTED) | |
| 943 pp_string (buffer, "RaRBarriersOmitted "); | |
| 944 if (props & PR_UNDOLOGCODE) | |
| 945 pp_string (buffer, "undoLogCode "); | |
| 946 if (props & PR_PREFERUNINSTRUMENTED) | |
| 947 pp_string (buffer, "preferUninstrumented "); | |
| 948 if (props & PR_EXCEPTIONBLOCK) | |
| 949 pp_string (buffer, "exceptionBlock "); | |
| 950 if (props & PR_HASELSE) | |
| 951 pp_string (buffer, "hasElse "); | |
| 952 if (props & PR_READONLY) | |
| 953 pp_string (buffer, "readOnly "); | |
| 954 | |
| 955 pp_right_bracket (buffer); | |
| 956 } | |
| 0 | 957 } |
| 958 | |
| 959 | |
| 960 /* Dump the switch statement GS. BUFFER, SPC and FLAGS are as in | |
| 111 | 961 pp_gimple_stmt_1. */ |
| 0 | 962 |
| 963 static void | |
| 111 | 964 dump_gimple_switch (pretty_printer *buffer, gswitch *gs, int spc, |
| 965 dump_flags_t flags) | |
| 0 | 966 { |
| 967 unsigned int i; | |
| 968 | |
| 969 GIMPLE_CHECK (gs, GIMPLE_SWITCH); | |
| 970 if (flags & TDF_RAW) | |
| 971 dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", gs, | |
| 972 gimple_switch_index (gs)); | |
| 973 else | |
| 974 { | |
| 975 pp_string (buffer, "switch ("); | |
| 976 dump_generic_node (buffer, gimple_switch_index (gs), spc, flags, true); | |
| 111 | 977 if (flags & TDF_GIMPLE) |
| 978 pp_string (buffer, ") {"); | |
| 979 else | |
| 980 pp_string (buffer, ") <"); | |
| 0 | 981 } |
| 982 | |
| 983 for (i = 0; i < gimple_switch_num_labels (gs); i++) | |
| 984 { | |
| 985 tree case_label = gimple_switch_label (gs, i); | |
| 111 | 986 gcc_checking_assert (case_label != NULL_TREE); |
| 0 | 987 dump_generic_node (buffer, case_label, spc, flags, false); |
| 111 | 988 pp_space (buffer); |
| 989 tree label = CASE_LABEL (case_label); | |
| 990 dump_generic_node (buffer, label, spc, flags, false); | |
| 991 | |
| 992 if (cfun && cfun->cfg) | |
| 993 { | |
| 131 | 994 basic_block dest = label_to_block (cfun, label); |
| 111 | 995 if (dest) |
| 996 { | |
| 997 edge label_edge = find_edge (gimple_bb (gs), dest); | |
| 998 if (label_edge && !(flags & TDF_GIMPLE)) | |
| 999 dump_edge_probability (buffer, label_edge); | |
| 1000 } | |
| 1001 } | |
| 1002 | |
| 0 | 1003 if (i < gimple_switch_num_labels (gs) - 1) |
| 111 | 1004 { |
| 1005 if (flags & TDF_GIMPLE) | |
| 1006 pp_string (buffer, "; "); | |
| 1007 else | |
| 1008 pp_string (buffer, ", "); | |
| 1009 } | |
| 0 | 1010 } |
| 111 | 1011 if (flags & TDF_GIMPLE) |
| 1012 pp_string (buffer, "; }"); | |
| 1013 else | |
| 1014 pp_greater (buffer); | |
| 0 | 1015 } |
| 1016 | |
| 1017 | |
| 1018 /* Dump the gimple conditional GS. BUFFER, SPC and FLAGS are as in | |
| 111 | 1019 pp_gimple_stmt_1. */ |
| 0 | 1020 |
| 1021 static void | |
| 111 | 1022 dump_gimple_cond (pretty_printer *buffer, gcond *gs, int spc, |
| 1023 dump_flags_t flags) | |
| 0 | 1024 { |
| 1025 if (flags & TDF_RAW) | |
| 1026 dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs, | |
| 111 | 1027 get_tree_code_name (gimple_cond_code (gs)), |
| 1028 gimple_cond_lhs (gs), gimple_cond_rhs (gs), | |
| 1029 gimple_cond_true_label (gs), gimple_cond_false_label (gs)); | |
| 0 | 1030 else |
| 1031 { | |
| 1032 if (!(flags & TDF_RHS_ONLY)) | |
| 1033 pp_string (buffer, "if ("); | |
| 1034 dump_generic_node (buffer, gimple_cond_lhs (gs), spc, flags, false); | |
| 1035 pp_space (buffer); | |
| 1036 pp_string (buffer, op_symbol_code (gimple_cond_code (gs))); | |
| 1037 pp_space (buffer); | |
| 1038 dump_generic_node (buffer, gimple_cond_rhs (gs), spc, flags, false); | |
| 1039 if (!(flags & TDF_RHS_ONLY)) | |
| 1040 { | |
| 111 | 1041 edge_iterator ei; |
| 1042 edge e, true_edge = NULL, false_edge = NULL; | |
| 1043 basic_block bb = gimple_bb (gs); | |
| 1044 | |
| 1045 if (bb) | |
| 1046 { | |
| 1047 FOR_EACH_EDGE (e, ei, bb->succs) | |
| 1048 { | |
| 1049 if (e->flags & EDGE_TRUE_VALUE) | |
| 1050 true_edge = e; | |
| 1051 else if (e->flags & EDGE_FALSE_VALUE) | |
| 1052 false_edge = e; | |
| 1053 } | |
| 1054 } | |
| 1055 | |
| 1056 bool has_edge_info = true_edge != NULL && false_edge != NULL; | |
| 1057 | |
| 1058 pp_right_paren (buffer); | |
| 0 | 1059 |
| 1060 if (gimple_cond_true_label (gs)) | |
| 1061 { | |
| 1062 pp_string (buffer, " goto "); | |
| 1063 dump_generic_node (buffer, gimple_cond_true_label (gs), | |
| 1064 spc, flags, false); | |
| 111 | 1065 if (has_edge_info && !(flags & TDF_GIMPLE)) |
| 1066 dump_edge_probability (buffer, true_edge); | |
| 0 | 1067 pp_semicolon (buffer); |
| 1068 } | |
| 1069 if (gimple_cond_false_label (gs)) | |
| 1070 { | |
| 1071 pp_string (buffer, " else goto "); | |
| 1072 dump_generic_node (buffer, gimple_cond_false_label (gs), | |
| 1073 spc, flags, false); | |
| 111 | 1074 if (has_edge_info && !(flags & TDF_GIMPLE)) |
| 1075 dump_edge_probability (buffer, false_edge); | |
| 1076 | |
| 0 | 1077 pp_semicolon (buffer); |
| 1078 } | |
| 1079 } | |
| 1080 } | |
| 1081 } | |
| 1082 | |
| 1083 | |
| 1084 /* Dump a GIMPLE_LABEL tuple on the pretty_printer BUFFER, SPC | |
| 1085 spaces of indent. FLAGS specifies details to show in the dump (see | |
| 111 | 1086 TDF_* in dumpfils.h). */ |
| 0 | 1087 |
| 1088 static void | |
| 111 | 1089 dump_gimple_label (pretty_printer *buffer, glabel *gs, int spc, |
| 1090 dump_flags_t flags) | |
| 0 | 1091 { |
| 1092 tree label = gimple_label_label (gs); | |
| 1093 if (flags & TDF_RAW) | |
| 111 | 1094 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label); |
| 0 | 1095 else |
| 1096 { | |
| 1097 dump_generic_node (buffer, label, spc, flags, false); | |
| 111 | 1098 pp_colon (buffer); |
| 0 | 1099 } |
| 111 | 1100 if (flags & TDF_GIMPLE) |
| 1101 return; | |
| 0 | 1102 if (DECL_NONLOCAL (label)) |
| 1103 pp_string (buffer, " [non-local]"); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1104 if ((flags & TDF_EH) && EH_LANDING_PAD_NR (label)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1105 pp_printf (buffer, " [LP %d]", EH_LANDING_PAD_NR (label)); |
| 0 | 1106 } |
| 1107 | |
| 1108 /* Dump a GIMPLE_GOTO tuple on the pretty_printer BUFFER, SPC | |
| 1109 spaces of indent. FLAGS specifies details to show in the dump (see | |
| 111 | 1110 TDF_* in dumpfile.h). */ |
| 0 | 1111 |
| 1112 static void | |
| 111 | 1113 dump_gimple_goto (pretty_printer *buffer, ggoto *gs, int spc, |
| 1114 dump_flags_t flags) | |
| 0 | 1115 { |
| 1116 tree label = gimple_goto_dest (gs); | |
| 1117 if (flags & TDF_RAW) | |
| 1118 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label); | |
| 1119 else | |
| 1120 dump_gimple_fmt (buffer, spc, flags, "goto %T;", label); | |
| 1121 } | |
| 1122 | |
| 1123 | |
| 1124 /* Dump a GIMPLE_BIND tuple on the pretty_printer BUFFER, SPC | |
| 1125 spaces of indent. FLAGS specifies details to show in the dump (see | |
| 111 | 1126 TDF_* in dumpfile.h). */ |
| 0 | 1127 |
| 1128 static void | |
| 111 | 1129 dump_gimple_bind (pretty_printer *buffer, gbind *gs, int spc, |
| 1130 dump_flags_t flags) | |
| 0 | 1131 { |
| 1132 if (flags & TDF_RAW) | |
| 1133 dump_gimple_fmt (buffer, spc, flags, "%G <", gs); | |
| 1134 else | |
| 111 | 1135 pp_left_brace (buffer); |
| 0 | 1136 if (!(flags & TDF_SLIM)) |
| 1137 { | |
| 1138 tree var; | |
| 1139 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1140 for (var = gimple_bind_vars (gs); var; var = DECL_CHAIN (var)) |
| 0 | 1141 { |
| 1142 newline_and_indent (buffer, 2); | |
| 1143 print_declaration (buffer, var, spc, flags); | |
| 1144 } | |
| 1145 if (gimple_bind_vars (gs)) | |
| 1146 pp_newline (buffer); | |
| 1147 } | |
| 1148 pp_newline (buffer); | |
| 1149 dump_gimple_seq (buffer, gimple_bind_body (gs), spc + 2, flags); | |
| 1150 newline_and_indent (buffer, spc); | |
| 1151 if (flags & TDF_RAW) | |
| 111 | 1152 pp_greater (buffer); |
| 0 | 1153 else |
| 111 | 1154 pp_right_brace (buffer); |
| 0 | 1155 } |
| 1156 | |
| 1157 | |
| 1158 /* Dump a GIMPLE_TRY tuple on the pretty_printer BUFFER, SPC spaces of | |
| 1159 indent. FLAGS specifies details to show in the dump (see TDF_* in | |
| 111 | 1160 dumpfile.h). */ |
| 0 | 1161 |
| 1162 static void | |
| 111 | 1163 dump_gimple_try (pretty_printer *buffer, gtry *gs, int spc, |
| 1164 dump_flags_t flags) | |
| 0 | 1165 { |
| 1166 if (flags & TDF_RAW) | |
| 1167 { | |
| 1168 const char *type; | |
| 1169 if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH) | |
| 1170 type = "GIMPLE_TRY_CATCH"; | |
| 1171 else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY) | |
| 1172 type = "GIMPLE_TRY_FINALLY"; | |
| 1173 else | |
| 1174 type = "UNKNOWN GIMPLE_TRY"; | |
| 1175 dump_gimple_fmt (buffer, spc, flags, | |
| 1176 "%G <%s,%+EVAL <%S>%nCLEANUP <%S>%->", gs, type, | |
| 1177 gimple_try_eval (gs), gimple_try_cleanup (gs)); | |
| 1178 } | |
| 1179 else | |
| 1180 { | |
| 1181 pp_string (buffer, "try"); | |
| 1182 newline_and_indent (buffer, spc + 2); | |
| 111 | 1183 pp_left_brace (buffer); |
| 0 | 1184 pp_newline (buffer); |
| 1185 | |
| 1186 dump_gimple_seq (buffer, gimple_try_eval (gs), spc + 4, flags); | |
| 1187 newline_and_indent (buffer, spc + 2); | |
| 111 | 1188 pp_right_brace (buffer); |
| 0 | 1189 |
| 1190 if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH) | |
| 1191 { | |
| 1192 newline_and_indent (buffer, spc); | |
| 1193 pp_string (buffer, "catch"); | |
| 1194 newline_and_indent (buffer, spc + 2); | |
| 111 | 1195 pp_left_brace (buffer); |
| 0 | 1196 } |
| 1197 else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY) | |
| 1198 { | |
| 1199 newline_and_indent (buffer, spc); | |
| 1200 pp_string (buffer, "finally"); | |
| 1201 newline_and_indent (buffer, spc + 2); | |
| 111 | 1202 pp_left_brace (buffer); |
| 0 | 1203 } |
| 1204 else | |
| 1205 pp_string (buffer, " <UNKNOWN GIMPLE_TRY> {"); | |
| 1206 | |
| 1207 pp_newline (buffer); | |
| 1208 dump_gimple_seq (buffer, gimple_try_cleanup (gs), spc + 4, flags); | |
| 1209 newline_and_indent (buffer, spc + 2); | |
| 111 | 1210 pp_right_brace (buffer); |
| 0 | 1211 } |
| 1212 } | |
| 1213 | |
| 1214 | |
| 1215 /* Dump a GIMPLE_CATCH tuple on the pretty_printer BUFFER, SPC spaces of | |
| 1216 indent. FLAGS specifies details to show in the dump (see TDF_* in | |
| 111 | 1217 dumpfile.h). */ |
| 0 | 1218 |
| 1219 static void | |
| 111 | 1220 dump_gimple_catch (pretty_printer *buffer, gcatch *gs, int spc, |
| 1221 dump_flags_t flags) | |
| 0 | 1222 { |
| 1223 if (flags & TDF_RAW) | |
| 1224 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+CATCH <%S>%->", gs, | |
| 1225 gimple_catch_types (gs), gimple_catch_handler (gs)); | |
| 1226 else | |
| 1227 dump_gimple_fmt (buffer, spc, flags, "catch (%T)%+{%S}", | |
| 1228 gimple_catch_types (gs), gimple_catch_handler (gs)); | |
| 1229 } | |
| 1230 | |
| 1231 | |
| 1232 /* Dump a GIMPLE_EH_FILTER tuple on the pretty_printer BUFFER, SPC spaces of | |
| 1233 indent. FLAGS specifies details to show in the dump (see TDF_* in | |
| 111 | 1234 dumpfile.h). */ |
| 0 | 1235 |
| 1236 static void | |
| 111 | 1237 dump_gimple_eh_filter (pretty_printer *buffer, geh_filter *gs, int spc, |
| 1238 dump_flags_t flags) | |
| 0 | 1239 { |
| 1240 if (flags & TDF_RAW) | |
| 1241 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+FAILURE <%S>%->", gs, | |
| 1242 gimple_eh_filter_types (gs), | |
| 1243 gimple_eh_filter_failure (gs)); | |
| 1244 else | |
| 1245 dump_gimple_fmt (buffer, spc, flags, "<<<eh_filter (%T)>>>%+{%+%S%-}", | |
| 1246 gimple_eh_filter_types (gs), | |
| 1247 gimple_eh_filter_failure (gs)); | |
| 1248 } | |
| 1249 | |
| 1250 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1251 /* Dump a GIMPLE_EH_MUST_NOT_THROW tuple. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1252 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1253 static void |
| 111 | 1254 dump_gimple_eh_must_not_throw (pretty_printer *buffer, |
| 1255 geh_mnt *gs, int spc, dump_flags_t flags) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1256 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1257 if (flags & TDF_RAW) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1258 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1259 gimple_eh_must_not_throw_fndecl (gs)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1260 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1261 dump_gimple_fmt (buffer, spc, flags, "<<<eh_must_not_throw (%T)>>>", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1262 gimple_eh_must_not_throw_fndecl (gs)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1263 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1264 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1265 |
| 111 | 1266 /* Dump a GIMPLE_EH_ELSE tuple on the pretty_printer BUFFER, SPC spaces of |
| 1267 indent. FLAGS specifies details to show in the dump (see TDF_* in | |
| 1268 dumpfile.h). */ | |
| 1269 | |
| 1270 static void | |
| 1271 dump_gimple_eh_else (pretty_printer *buffer, geh_else *gs, int spc, | |
| 1272 dump_flags_t flags) | |
| 1273 { | |
| 1274 if (flags & TDF_RAW) | |
| 1275 dump_gimple_fmt (buffer, spc, flags, | |
| 1276 "%G <%+N_BODY <%S>%nE_BODY <%S>%->", gs, | |
| 1277 gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs)); | |
| 1278 else | |
| 1279 dump_gimple_fmt (buffer, spc, flags, | |
| 1280 "<<<if_normal_exit>>>%+{%S}%-<<<else_eh_exit>>>%+{%S}", | |
| 1281 gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs)); | |
| 1282 } | |
| 1283 | |
| 1284 | |
| 0 | 1285 /* Dump a GIMPLE_RESX tuple on the pretty_printer BUFFER, SPC spaces of |
| 1286 indent. FLAGS specifies details to show in the dump (see TDF_* in | |
| 111 | 1287 dumpfile.h). */ |
| 0 | 1288 |
| 1289 static void | |
| 111 | 1290 dump_gimple_resx (pretty_printer *buffer, gresx *gs, int spc, |
| 1291 dump_flags_t flags) | |
| 0 | 1292 { |
| 1293 if (flags & TDF_RAW) | |
| 1294 dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1295 gimple_resx_region (gs)); |
| 0 | 1296 else |
| 1297 dump_gimple_fmt (buffer, spc, flags, "resx %d", gimple_resx_region (gs)); | |
| 1298 } | |
| 1299 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1300 /* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer BUFFER. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1301 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1302 static void |
| 111 | 1303 dump_gimple_eh_dispatch (pretty_printer *buffer, geh_dispatch *gs, int spc, |
| 1304 dump_flags_t flags) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1305 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1306 if (flags & TDF_RAW) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1307 dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1308 gimple_eh_dispatch_region (gs)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1309 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1310 dump_gimple_fmt (buffer, spc, flags, "eh_dispatch %d", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1311 gimple_eh_dispatch_region (gs)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1312 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1313 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1314 /* Dump a GIMPLE_DEBUG tuple on the pretty_printer BUFFER, SPC spaces |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1315 of indent. FLAGS specifies details to show in the dump (see TDF_* |
| 111 | 1316 in dumpfile.h). */ |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1317 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1318 static void |
| 111 | 1319 dump_gimple_debug (pretty_printer *buffer, gdebug *gs, int spc, |
| 1320 dump_flags_t flags) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1321 { |
| 111 | 1322 switch (gs->subcode) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1323 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1324 case GIMPLE_DEBUG_BIND: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1325 if (flags & TDF_RAW) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1326 dump_gimple_fmt (buffer, spc, flags, "%G BIND <%T, %T>", gs, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1327 gimple_debug_bind_get_var (gs), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1328 gimple_debug_bind_get_value (gs)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1329 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1330 dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T => %T", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1331 gimple_debug_bind_get_var (gs), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1332 gimple_debug_bind_get_value (gs)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1333 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1334 |
| 111 | 1335 case GIMPLE_DEBUG_SOURCE_BIND: |
| 1336 if (flags & TDF_RAW) | |
| 1337 dump_gimple_fmt (buffer, spc, flags, "%G SRCBIND <%T, %T>", gs, | |
| 1338 gimple_debug_source_bind_get_var (gs), | |
| 1339 gimple_debug_source_bind_get_value (gs)); | |
| 1340 else | |
| 1341 dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T s=> %T", | |
| 1342 gimple_debug_source_bind_get_var (gs), | |
| 1343 gimple_debug_source_bind_get_value (gs)); | |
| 1344 break; | |
| 1345 | |
| 131 | 1346 case GIMPLE_DEBUG_BEGIN_STMT: |
| 1347 if (flags & TDF_RAW) | |
| 1348 dump_gimple_fmt (buffer, spc, flags, "%G BEGIN_STMT", gs); | |
| 1349 else | |
| 1350 dump_gimple_fmt (buffer, spc, flags, "# DEBUG BEGIN_STMT"); | |
| 1351 break; | |
| 1352 | |
| 1353 case GIMPLE_DEBUG_INLINE_ENTRY: | |
| 1354 if (flags & TDF_RAW) | |
| 1355 dump_gimple_fmt (buffer, spc, flags, "%G INLINE_ENTRY %T", gs, | |
| 1356 gimple_block (gs) | |
| 1357 ? block_ultimate_origin (gimple_block (gs)) | |
| 1358 : NULL_TREE); | |
| 1359 else | |
| 1360 dump_gimple_fmt (buffer, spc, flags, "# DEBUG INLINE_ENTRY %T", | |
| 1361 gimple_block (gs) | |
| 1362 ? block_ultimate_origin (gimple_block (gs)) | |
| 1363 : NULL_TREE); | |
| 1364 break; | |
| 1365 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1366 default: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1367 gcc_unreachable (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1368 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1369 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1370 |
| 0 | 1371 /* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer BUFFER. */ |
| 1372 static void | |
| 111 | 1373 dump_gimple_omp_for (pretty_printer *buffer, gomp_for *gs, int spc, |
| 1374 dump_flags_t flags) | |
| 0 | 1375 { |
| 1376 size_t i; | |
| 1377 | |
| 1378 if (flags & TDF_RAW) | |
| 1379 { | |
| 111 | 1380 const char *kind; |
| 1381 switch (gimple_omp_for_kind (gs)) | |
| 1382 { | |
| 1383 case GF_OMP_FOR_KIND_FOR: | |
| 1384 kind = ""; | |
| 1385 break; | |
| 1386 case GF_OMP_FOR_KIND_DISTRIBUTE: | |
| 1387 kind = " distribute"; | |
| 1388 break; | |
| 1389 case GF_OMP_FOR_KIND_TASKLOOP: | |
| 1390 kind = " taskloop"; | |
| 1391 break; | |
| 1392 case GF_OMP_FOR_KIND_OACC_LOOP: | |
| 1393 kind = " oacc_loop"; | |
| 1394 break; | |
| 1395 case GF_OMP_FOR_KIND_SIMD: | |
| 1396 kind = " simd"; | |
| 1397 break; | |
| 1398 default: | |
| 1399 gcc_unreachable (); | |
| 1400 } | |
| 1401 dump_gimple_fmt (buffer, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs, | |
| 1402 kind, gimple_omp_body (gs)); | |
| 0 | 1403 dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags); |
| 1404 dump_gimple_fmt (buffer, spc, flags, " >,"); | |
| 1405 for (i = 0; i < gimple_omp_for_collapse (gs); i++) | |
| 1406 dump_gimple_fmt (buffer, spc, flags, | |
| 1407 "%+%T, %T, %T, %s, %T,%n", | |
| 1408 gimple_omp_for_index (gs, i), | |
| 1409 gimple_omp_for_initial (gs, i), | |
| 1410 gimple_omp_for_final (gs, i), | |
| 111 | 1411 get_tree_code_name (gimple_omp_for_cond (gs, i)), |
| 0 | 1412 gimple_omp_for_incr (gs, i)); |
| 1413 dump_gimple_fmt (buffer, spc, flags, "PRE_BODY <%S>%->", | |
| 1414 gimple_omp_for_pre_body (gs)); | |
| 1415 } | |
| 1416 else | |
| 1417 { | |
| 111 | 1418 switch (gimple_omp_for_kind (gs)) |
| 1419 { | |
| 1420 case GF_OMP_FOR_KIND_FOR: | |
| 1421 pp_string (buffer, "#pragma omp for"); | |
| 1422 break; | |
| 1423 case GF_OMP_FOR_KIND_DISTRIBUTE: | |
| 1424 pp_string (buffer, "#pragma omp distribute"); | |
| 1425 break; | |
| 1426 case GF_OMP_FOR_KIND_TASKLOOP: | |
| 1427 pp_string (buffer, "#pragma omp taskloop"); | |
| 1428 break; | |
| 1429 case GF_OMP_FOR_KIND_OACC_LOOP: | |
| 1430 pp_string (buffer, "#pragma acc loop"); | |
| 1431 break; | |
| 1432 case GF_OMP_FOR_KIND_SIMD: | |
| 1433 pp_string (buffer, "#pragma omp simd"); | |
| 1434 break; | |
| 1435 case GF_OMP_FOR_KIND_GRID_LOOP: | |
| 1436 pp_string (buffer, "#pragma omp for grid_loop"); | |
| 1437 break; | |
| 1438 default: | |
| 1439 gcc_unreachable (); | |
| 1440 } | |
| 131 | 1441 dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags); |
| 0 | 1442 for (i = 0; i < gimple_omp_for_collapse (gs); i++) |
| 1443 { | |
| 1444 if (i) | |
| 1445 spc += 2; | |
| 131 | 1446 newline_and_indent (buffer, spc); |
| 1447 pp_string (buffer, "for ("); | |
| 0 | 1448 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc, |
| 1449 flags, false); | |
| 1450 pp_string (buffer, " = "); | |
| 1451 dump_generic_node (buffer, gimple_omp_for_initial (gs, i), spc, | |
| 1452 flags, false); | |
| 1453 pp_string (buffer, "; "); | |
| 1454 | |
| 1455 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc, | |
| 1456 flags, false); | |
| 1457 pp_space (buffer); | |
| 1458 switch (gimple_omp_for_cond (gs, i)) | |
| 1459 { | |
| 1460 case LT_EXPR: | |
| 111 | 1461 pp_less (buffer); |
| 0 | 1462 break; |
| 1463 case GT_EXPR: | |
| 111 | 1464 pp_greater (buffer); |
| 0 | 1465 break; |
| 1466 case LE_EXPR: | |
| 111 | 1467 pp_less_equal (buffer); |
| 0 | 1468 break; |
| 1469 case GE_EXPR: | |
| 111 | 1470 pp_greater_equal (buffer); |
| 1471 break; | |
| 1472 case NE_EXPR: | |
| 1473 pp_string (buffer, "!="); | |
| 0 | 1474 break; |
| 1475 default: | |
| 1476 gcc_unreachable (); | |
| 1477 } | |
| 1478 pp_space (buffer); | |
| 1479 dump_generic_node (buffer, gimple_omp_for_final (gs, i), spc, | |
| 1480 flags, false); | |
| 1481 pp_string (buffer, "; "); | |
| 1482 | |
| 1483 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc, | |
| 1484 flags, false); | |
| 1485 pp_string (buffer, " = "); | |
| 1486 dump_generic_node (buffer, gimple_omp_for_incr (gs, i), spc, | |
| 1487 flags, false); | |
| 111 | 1488 pp_right_paren (buffer); |
| 0 | 1489 } |
| 1490 | |
| 1491 if (!gimple_seq_empty_p (gimple_omp_body (gs))) | |
| 1492 { | |
| 1493 newline_and_indent (buffer, spc + 2); | |
| 111 | 1494 pp_left_brace (buffer); |
| 0 | 1495 pp_newline (buffer); |
| 1496 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); | |
| 1497 newline_and_indent (buffer, spc + 2); | |
| 111 | 1498 pp_right_brace (buffer); |
| 0 | 1499 } |
| 1500 } | |
| 1501 } | |
| 1502 | |
| 1503 /* Dump a GIMPLE_OMP_CONTINUE tuple on the pretty_printer BUFFER. */ | |
| 1504 | |
| 1505 static void | |
| 111 | 1506 dump_gimple_omp_continue (pretty_printer *buffer, gomp_continue *gs, |
| 1507 int spc, dump_flags_t flags) | |
| 0 | 1508 { |
| 1509 if (flags & TDF_RAW) | |
| 1510 { | |
| 1511 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs, | |
| 1512 gimple_omp_continue_control_def (gs), | |
| 1513 gimple_omp_continue_control_use (gs)); | |
| 1514 } | |
| 1515 else | |
| 1516 { | |
| 1517 pp_string (buffer, "#pragma omp continue ("); | |
| 1518 dump_generic_node (buffer, gimple_omp_continue_control_def (gs), | |
| 1519 spc, flags, false); | |
| 111 | 1520 pp_comma (buffer); |
| 0 | 1521 pp_space (buffer); |
| 1522 dump_generic_node (buffer, gimple_omp_continue_control_use (gs), | |
| 1523 spc, flags, false); | |
| 111 | 1524 pp_right_paren (buffer); |
| 0 | 1525 } |
| 1526 } | |
| 1527 | |
| 1528 /* Dump a GIMPLE_OMP_SINGLE tuple on the pretty_printer BUFFER. */ | |
| 1529 | |
| 1530 static void | |
| 111 | 1531 dump_gimple_omp_single (pretty_printer *buffer, gomp_single *gs, |
| 1532 int spc, dump_flags_t flags) | |
| 0 | 1533 { |
| 1534 if (flags & TDF_RAW) | |
| 1535 { | |
| 1536 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, | |
| 1537 gimple_omp_body (gs)); | |
| 1538 dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags); | |
| 1539 dump_gimple_fmt (buffer, spc, flags, " >"); | |
| 1540 } | |
| 1541 else | |
| 1542 { | |
| 1543 pp_string (buffer, "#pragma omp single"); | |
| 1544 dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags); | |
| 1545 if (!gimple_seq_empty_p (gimple_omp_body (gs))) | |
| 1546 { | |
| 1547 newline_and_indent (buffer, spc + 2); | |
| 111 | 1548 pp_left_brace (buffer); |
| 1549 pp_newline (buffer); | |
| 1550 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); | |
| 1551 newline_and_indent (buffer, spc + 2); | |
| 1552 pp_right_brace (buffer); | |
| 1553 } | |
| 1554 } | |
| 1555 } | |
| 1556 | |
| 1557 /* Dump a GIMPLE_OMP_TARGET tuple on the pretty_printer BUFFER. */ | |
| 1558 | |
| 1559 static void | |
| 1560 dump_gimple_omp_target (pretty_printer *buffer, gomp_target *gs, | |
| 1561 int spc, dump_flags_t flags) | |
| 1562 { | |
| 1563 const char *kind; | |
| 1564 switch (gimple_omp_target_kind (gs)) | |
| 1565 { | |
| 1566 case GF_OMP_TARGET_KIND_REGION: | |
| 1567 kind = ""; | |
| 1568 break; | |
| 1569 case GF_OMP_TARGET_KIND_DATA: | |
| 1570 kind = " data"; | |
| 1571 break; | |
| 1572 case GF_OMP_TARGET_KIND_UPDATE: | |
| 1573 kind = " update"; | |
| 1574 break; | |
| 1575 case GF_OMP_TARGET_KIND_ENTER_DATA: | |
| 1576 kind = " enter data"; | |
| 1577 break; | |
| 1578 case GF_OMP_TARGET_KIND_EXIT_DATA: | |
| 1579 kind = " exit data"; | |
| 1580 break; | |
| 1581 case GF_OMP_TARGET_KIND_OACC_KERNELS: | |
| 1582 kind = " oacc_kernels"; | |
| 1583 break; | |
| 1584 case GF_OMP_TARGET_KIND_OACC_PARALLEL: | |
| 1585 kind = " oacc_parallel"; | |
| 1586 break; | |
| 1587 case GF_OMP_TARGET_KIND_OACC_DATA: | |
| 1588 kind = " oacc_data"; | |
| 1589 break; | |
| 1590 case GF_OMP_TARGET_KIND_OACC_UPDATE: | |
| 1591 kind = " oacc_update"; | |
| 1592 break; | |
| 1593 case GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA: | |
| 1594 kind = " oacc_enter_exit_data"; | |
| 1595 break; | |
| 1596 case GF_OMP_TARGET_KIND_OACC_DECLARE: | |
| 1597 kind = " oacc_declare"; | |
| 1598 break; | |
| 1599 case GF_OMP_TARGET_KIND_OACC_HOST_DATA: | |
| 1600 kind = " oacc_host_data"; | |
| 1601 break; | |
| 1602 default: | |
| 1603 gcc_unreachable (); | |
| 1604 } | |
| 1605 if (flags & TDF_RAW) | |
| 1606 { | |
| 1607 dump_gimple_fmt (buffer, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs, | |
| 1608 kind, gimple_omp_body (gs)); | |
| 1609 dump_omp_clauses (buffer, gimple_omp_target_clauses (gs), spc, flags); | |
| 1610 dump_gimple_fmt (buffer, spc, flags, " >, %T, %T%n>", | |
| 1611 gimple_omp_target_child_fn (gs), | |
| 1612 gimple_omp_target_data_arg (gs)); | |
| 1613 } | |
| 1614 else | |
| 1615 { | |
| 1616 pp_string (buffer, "#pragma omp target"); | |
| 1617 pp_string (buffer, kind); | |
| 1618 dump_omp_clauses (buffer, gimple_omp_target_clauses (gs), spc, flags); | |
| 1619 if (gimple_omp_target_child_fn (gs)) | |
| 1620 { | |
| 1621 pp_string (buffer, " [child fn: "); | |
| 1622 dump_generic_node (buffer, gimple_omp_target_child_fn (gs), | |
| 1623 spc, flags, false); | |
| 1624 pp_string (buffer, " ("); | |
| 1625 if (gimple_omp_target_data_arg (gs)) | |
| 1626 dump_generic_node (buffer, gimple_omp_target_data_arg (gs), | |
| 1627 spc, flags, false); | |
| 1628 else | |
| 1629 pp_string (buffer, "???"); | |
| 1630 pp_string (buffer, ")]"); | |
| 1631 } | |
| 1632 gimple_seq body = gimple_omp_body (gs); | |
| 1633 if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND) | |
| 1634 { | |
| 1635 newline_and_indent (buffer, spc + 2); | |
| 1636 pp_left_brace (buffer); | |
| 1637 pp_newline (buffer); | |
| 1638 dump_gimple_seq (buffer, body, spc + 4, flags); | |
| 1639 newline_and_indent (buffer, spc + 2); | |
| 1640 pp_right_brace (buffer); | |
| 1641 } | |
| 1642 else if (body) | |
| 1643 { | |
| 1644 pp_newline (buffer); | |
| 1645 dump_gimple_seq (buffer, body, spc + 2, flags); | |
| 1646 } | |
| 1647 } | |
| 1648 } | |
| 1649 | |
| 1650 /* Dump a GIMPLE_OMP_TEAMS tuple on the pretty_printer BUFFER. */ | |
| 1651 | |
| 1652 static void | |
| 1653 dump_gimple_omp_teams (pretty_printer *buffer, gomp_teams *gs, int spc, | |
| 1654 dump_flags_t flags) | |
| 1655 { | |
| 1656 if (flags & TDF_RAW) | |
| 1657 { | |
| 1658 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, | |
| 1659 gimple_omp_body (gs)); | |
| 1660 dump_omp_clauses (buffer, gimple_omp_teams_clauses (gs), spc, flags); | |
| 1661 dump_gimple_fmt (buffer, spc, flags, " >"); | |
| 1662 } | |
| 1663 else | |
| 1664 { | |
| 1665 pp_string (buffer, "#pragma omp teams"); | |
| 1666 dump_omp_clauses (buffer, gimple_omp_teams_clauses (gs), spc, flags); | |
| 1667 if (!gimple_seq_empty_p (gimple_omp_body (gs))) | |
| 1668 { | |
| 1669 newline_and_indent (buffer, spc + 2); | |
| 0 | 1670 pp_character (buffer, '{'); |
| 1671 pp_newline (buffer); | |
| 1672 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); | |
| 1673 newline_and_indent (buffer, spc + 2); | |
| 1674 pp_character (buffer, '}'); | |
| 1675 } | |
| 1676 } | |
| 1677 } | |
| 1678 | |
| 1679 /* Dump a GIMPLE_OMP_SECTIONS tuple on the pretty_printer BUFFER. */ | |
| 1680 | |
| 1681 static void | |
| 111 | 1682 dump_gimple_omp_sections (pretty_printer *buffer, gomp_sections *gs, |
| 1683 int spc, dump_flags_t flags) | |
| 0 | 1684 { |
| 1685 if (flags & TDF_RAW) | |
| 1686 { | |
| 1687 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, | |
| 1688 gimple_omp_body (gs)); | |
| 1689 dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags); | |
| 1690 dump_gimple_fmt (buffer, spc, flags, " >"); | |
| 1691 } | |
| 1692 else | |
| 1693 { | |
| 1694 pp_string (buffer, "#pragma omp sections"); | |
| 1695 if (gimple_omp_sections_control (gs)) | |
| 1696 { | |
| 1697 pp_string (buffer, " <"); | |
| 1698 dump_generic_node (buffer, gimple_omp_sections_control (gs), spc, | |
| 1699 flags, false); | |
| 111 | 1700 pp_greater (buffer); |
| 0 | 1701 } |
| 1702 dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags); | |
| 1703 if (!gimple_seq_empty_p (gimple_omp_body (gs))) | |
| 1704 { | |
| 1705 newline_and_indent (buffer, spc + 2); | |
| 111 | 1706 pp_left_brace (buffer); |
| 0 | 1707 pp_newline (buffer); |
| 1708 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); | |
| 1709 newline_and_indent (buffer, spc + 2); | |
| 111 | 1710 pp_right_brace (buffer); |
| 0 | 1711 } |
| 1712 } | |
| 1713 } | |
| 1714 | |
| 111 | 1715 /* Dump a GIMPLE_OMP_{MASTER,TASKGROUP,ORDERED,SECTION} tuple on the |
| 1716 pretty_printer BUFFER. */ | |
| 0 | 1717 |
| 1718 static void | |
| 111 | 1719 dump_gimple_omp_block (pretty_printer *buffer, gimple *gs, int spc, |
| 1720 dump_flags_t flags) | |
| 0 | 1721 { |
| 1722 if (flags & TDF_RAW) | |
| 1723 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs, | |
| 1724 gimple_omp_body (gs)); | |
| 1725 else | |
| 1726 { | |
| 1727 switch (gimple_code (gs)) | |
| 1728 { | |
| 1729 case GIMPLE_OMP_MASTER: | |
| 1730 pp_string (buffer, "#pragma omp master"); | |
| 1731 break; | |
| 111 | 1732 case GIMPLE_OMP_TASKGROUP: |
| 1733 pp_string (buffer, "#pragma omp taskgroup"); | |
| 0 | 1734 break; |
| 1735 case GIMPLE_OMP_SECTION: | |
| 1736 pp_string (buffer, "#pragma omp section"); | |
| 1737 break; | |
| 111 | 1738 case GIMPLE_OMP_GRID_BODY: |
| 1739 pp_string (buffer, "#pragma omp gridified body"); | |
| 1740 break; | |
| 0 | 1741 default: |
| 1742 gcc_unreachable (); | |
| 1743 } | |
| 1744 if (!gimple_seq_empty_p (gimple_omp_body (gs))) | |
| 1745 { | |
| 1746 newline_and_indent (buffer, spc + 2); | |
| 111 | 1747 pp_left_brace (buffer); |
| 0 | 1748 pp_newline (buffer); |
| 1749 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); | |
| 1750 newline_and_indent (buffer, spc + 2); | |
| 111 | 1751 pp_right_brace (buffer); |
| 0 | 1752 } |
| 1753 } | |
| 1754 } | |
| 1755 | |
| 1756 /* Dump a GIMPLE_OMP_CRITICAL tuple on the pretty_printer BUFFER. */ | |
| 1757 | |
| 1758 static void | |
| 111 | 1759 dump_gimple_omp_critical (pretty_printer *buffer, gomp_critical *gs, |
| 1760 int spc, dump_flags_t flags) | |
| 0 | 1761 { |
| 1762 if (flags & TDF_RAW) | |
| 1763 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs, | |
| 1764 gimple_omp_body (gs)); | |
| 1765 else | |
| 1766 { | |
| 1767 pp_string (buffer, "#pragma omp critical"); | |
| 1768 if (gimple_omp_critical_name (gs)) | |
| 1769 { | |
| 1770 pp_string (buffer, " ("); | |
| 1771 dump_generic_node (buffer, gimple_omp_critical_name (gs), spc, | |
| 1772 flags, false); | |
| 111 | 1773 pp_right_paren (buffer); |
| 0 | 1774 } |
| 111 | 1775 dump_omp_clauses (buffer, gimple_omp_critical_clauses (gs), spc, flags); |
| 0 | 1776 if (!gimple_seq_empty_p (gimple_omp_body (gs))) |
| 1777 { | |
| 1778 newline_and_indent (buffer, spc + 2); | |
| 111 | 1779 pp_left_brace (buffer); |
| 0 | 1780 pp_newline (buffer); |
| 1781 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); | |
| 1782 newline_and_indent (buffer, spc + 2); | |
| 111 | 1783 pp_right_brace (buffer); |
| 1784 } | |
| 1785 } | |
| 1786 } | |
| 1787 | |
| 1788 /* Dump a GIMPLE_OMP_ORDERED tuple on the pretty_printer BUFFER. */ | |
| 1789 | |
| 1790 static void | |
| 1791 dump_gimple_omp_ordered (pretty_printer *buffer, gomp_ordered *gs, | |
| 1792 int spc, dump_flags_t flags) | |
| 1793 { | |
| 1794 if (flags & TDF_RAW) | |
| 1795 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs, | |
| 1796 gimple_omp_body (gs)); | |
| 1797 else | |
| 1798 { | |
| 1799 pp_string (buffer, "#pragma omp ordered"); | |
| 1800 dump_omp_clauses (buffer, gimple_omp_ordered_clauses (gs), spc, flags); | |
| 1801 if (!gimple_seq_empty_p (gimple_omp_body (gs))) | |
| 1802 { | |
| 1803 newline_and_indent (buffer, spc + 2); | |
| 1804 pp_left_brace (buffer); | |
| 1805 pp_newline (buffer); | |
| 1806 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); | |
| 1807 newline_and_indent (buffer, spc + 2); | |
| 1808 pp_right_brace (buffer); | |
| 0 | 1809 } |
| 1810 } | |
| 1811 } | |
| 1812 | |
| 1813 /* Dump a GIMPLE_OMP_RETURN tuple on the pretty_printer BUFFER. */ | |
| 1814 | |
| 1815 static void | |
| 111 | 1816 dump_gimple_omp_return (pretty_printer *buffer, gimple *gs, int spc, |
| 1817 dump_flags_t flags) | |
| 0 | 1818 { |
| 1819 if (flags & TDF_RAW) | |
| 1820 { | |
| 111 | 1821 dump_gimple_fmt (buffer, spc, flags, "%G <nowait=%d", gs, |
| 0 | 1822 (int) gimple_omp_return_nowait_p (gs)); |
| 111 | 1823 if (gimple_omp_return_lhs (gs)) |
| 1824 dump_gimple_fmt (buffer, spc, flags, ", lhs=%T>", | |
| 1825 gimple_omp_return_lhs (gs)); | |
| 1826 else | |
| 1827 dump_gimple_fmt (buffer, spc, flags, ">"); | |
| 0 | 1828 } |
| 1829 else | |
| 1830 { | |
| 1831 pp_string (buffer, "#pragma omp return"); | |
| 1832 if (gimple_omp_return_nowait_p (gs)) | |
| 1833 pp_string (buffer, "(nowait)"); | |
| 111 | 1834 if (gimple_omp_return_lhs (gs)) |
| 1835 { | |
| 1836 pp_string (buffer, " (set "); | |
| 1837 dump_generic_node (buffer, gimple_omp_return_lhs (gs), | |
| 1838 spc, flags, false); | |
| 1839 pp_character (buffer, ')'); | |
| 1840 } | |
| 1841 } | |
| 1842 } | |
| 1843 | |
| 1844 /* Dump a GIMPLE_TRANSACTION tuple on the pretty_printer BUFFER. */ | |
| 1845 | |
| 1846 static void | |
| 1847 dump_gimple_transaction (pretty_printer *buffer, gtransaction *gs, | |
| 1848 int spc, dump_flags_t flags) | |
| 1849 { | |
| 1850 unsigned subcode = gimple_transaction_subcode (gs); | |
| 1851 | |
| 1852 if (flags & TDF_RAW) | |
| 1853 { | |
| 1854 dump_gimple_fmt (buffer, spc, flags, | |
| 1855 "%G [SUBCODE=%x,NORM=%T,UNINST=%T,OVER=%T] " | |
| 1856 "<%+BODY <%S> >", | |
| 1857 gs, subcode, gimple_transaction_label_norm (gs), | |
| 1858 gimple_transaction_label_uninst (gs), | |
| 1859 gimple_transaction_label_over (gs), | |
| 1860 gimple_transaction_body (gs)); | |
| 1861 } | |
| 1862 else | |
| 1863 { | |
| 1864 if (subcode & GTMA_IS_OUTER) | |
| 1865 pp_string (buffer, "__transaction_atomic [[outer]]"); | |
| 1866 else if (subcode & GTMA_IS_RELAXED) | |
| 1867 pp_string (buffer, "__transaction_relaxed"); | |
| 1868 else | |
| 1869 pp_string (buffer, "__transaction_atomic"); | |
| 1870 subcode &= ~GTMA_DECLARATION_MASK; | |
| 1871 | |
| 1872 if (gimple_transaction_body (gs)) | |
| 1873 { | |
| 1874 newline_and_indent (buffer, spc + 2); | |
| 1875 pp_left_brace (buffer); | |
| 1876 pp_newline (buffer); | |
| 1877 dump_gimple_seq (buffer, gimple_transaction_body (gs), | |
| 1878 spc + 4, flags); | |
| 1879 newline_and_indent (buffer, spc + 2); | |
| 1880 pp_right_brace (buffer); | |
| 1881 } | |
| 1882 else | |
| 1883 { | |
| 1884 pp_string (buffer, " //"); | |
| 1885 if (gimple_transaction_label_norm (gs)) | |
| 1886 { | |
| 1887 pp_string (buffer, " NORM="); | |
| 1888 dump_generic_node (buffer, gimple_transaction_label_norm (gs), | |
| 1889 spc, flags, false); | |
| 1890 } | |
| 1891 if (gimple_transaction_label_uninst (gs)) | |
| 1892 { | |
| 1893 pp_string (buffer, " UNINST="); | |
| 1894 dump_generic_node (buffer, gimple_transaction_label_uninst (gs), | |
| 1895 spc, flags, false); | |
| 1896 } | |
| 1897 if (gimple_transaction_label_over (gs)) | |
| 1898 { | |
| 1899 pp_string (buffer, " OVER="); | |
| 1900 dump_generic_node (buffer, gimple_transaction_label_over (gs), | |
| 1901 spc, flags, false); | |
| 1902 } | |
| 1903 if (subcode) | |
| 1904 { | |
| 1905 pp_string (buffer, " SUBCODE=[ "); | |
| 1906 if (subcode & GTMA_HAVE_ABORT) | |
| 1907 { | |
| 1908 pp_string (buffer, "GTMA_HAVE_ABORT "); | |
| 1909 subcode &= ~GTMA_HAVE_ABORT; | |
| 1910 } | |
| 1911 if (subcode & GTMA_HAVE_LOAD) | |
| 1912 { | |
| 1913 pp_string (buffer, "GTMA_HAVE_LOAD "); | |
| 1914 subcode &= ~GTMA_HAVE_LOAD; | |
| 1915 } | |
| 1916 if (subcode & GTMA_HAVE_STORE) | |
| 1917 { | |
| 1918 pp_string (buffer, "GTMA_HAVE_STORE "); | |
| 1919 subcode &= ~GTMA_HAVE_STORE; | |
| 1920 } | |
| 1921 if (subcode & GTMA_MAY_ENTER_IRREVOCABLE) | |
| 1922 { | |
| 1923 pp_string (buffer, "GTMA_MAY_ENTER_IRREVOCABLE "); | |
| 1924 subcode &= ~GTMA_MAY_ENTER_IRREVOCABLE; | |
| 1925 } | |
| 1926 if (subcode & GTMA_DOES_GO_IRREVOCABLE) | |
| 1927 { | |
| 1928 pp_string (buffer, "GTMA_DOES_GO_IRREVOCABLE "); | |
| 1929 subcode &= ~GTMA_DOES_GO_IRREVOCABLE; | |
| 1930 } | |
| 1931 if (subcode & GTMA_HAS_NO_INSTRUMENTATION) | |
| 1932 { | |
| 1933 pp_string (buffer, "GTMA_HAS_NO_INSTRUMENTATION "); | |
| 1934 subcode &= ~GTMA_HAS_NO_INSTRUMENTATION; | |
| 1935 } | |
| 1936 if (subcode) | |
| 1937 pp_printf (buffer, "0x%x ", subcode); | |
| 1938 pp_right_bracket (buffer); | |
| 1939 } | |
| 1940 } | |
| 0 | 1941 } |
| 1942 } | |
| 1943 | |
| 1944 /* Dump a GIMPLE_ASM tuple on the pretty_printer BUFFER, SPC spaces of | |
| 1945 indent. FLAGS specifies details to show in the dump (see TDF_* in | |
| 111 | 1946 dumpfile.h). */ |
| 0 | 1947 |
| 1948 static void | |
| 111 | 1949 dump_gimple_asm (pretty_printer *buffer, gasm *gs, int spc, dump_flags_t flags) |
| 0 | 1950 { |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1951 unsigned int i, n, f, fields; |
| 0 | 1952 |
| 1953 if (flags & TDF_RAW) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1954 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1955 dump_gimple_fmt (buffer, spc, flags, "%G <%+STRING <%n%s%n>", gs, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1956 gimple_asm_string (gs)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1957 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1958 n = gimple_asm_noutputs (gs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1959 if (n) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1960 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1961 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1962 pp_string (buffer, "OUTPUT: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1963 for (i = 0; i < n; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1964 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1965 dump_generic_node (buffer, gimple_asm_output_op (gs, i), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1966 spc, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1967 if (i < n - 1) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1968 pp_string (buffer, ", "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1969 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1970 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1971 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1972 n = gimple_asm_ninputs (gs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1973 if (n) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1974 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1975 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1976 pp_string (buffer, "INPUT: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1977 for (i = 0; i < n; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1978 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1979 dump_generic_node (buffer, gimple_asm_input_op (gs, i), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1980 spc, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1981 if (i < n - 1) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1982 pp_string (buffer, ", "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1983 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1984 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1985 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1986 n = gimple_asm_nclobbers (gs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1987 if (n) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1988 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1989 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1990 pp_string (buffer, "CLOBBER: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1991 for (i = 0; i < n; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1992 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1993 dump_generic_node (buffer, gimple_asm_clobber_op (gs, i), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1994 spc, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1995 if (i < n - 1) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1996 pp_string (buffer, ", "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1997 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1998 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1999 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2000 n = gimple_asm_nlabels (gs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2001 if (n) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2002 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2003 newline_and_indent (buffer, spc + 2); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2004 pp_string (buffer, "LABEL: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2005 for (i = 0; i < n; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2006 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2007 dump_generic_node (buffer, gimple_asm_label_op (gs, i), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2008 spc, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2009 if (i < n - 1) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2010 pp_string (buffer, ", "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2011 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2012 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2013 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2014 newline_and_indent (buffer, spc); |
| 111 | 2015 pp_greater (buffer); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2016 } |
| 0 | 2017 else |
| 2018 { | |
| 2019 pp_string (buffer, "__asm__"); | |
| 2020 if (gimple_asm_volatile_p (gs)) | |
| 2021 pp_string (buffer, " __volatile__"); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2022 if (gimple_asm_nlabels (gs)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2023 pp_string (buffer, " goto"); |
| 0 | 2024 pp_string (buffer, "(\""); |
| 2025 pp_string (buffer, gimple_asm_string (gs)); | |
| 2026 pp_string (buffer, "\""); | |
| 2027 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2028 if (gimple_asm_nlabels (gs)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2029 fields = 4; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2030 else if (gimple_asm_nclobbers (gs)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2031 fields = 3; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2032 else if (gimple_asm_ninputs (gs)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2033 fields = 2; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2034 else if (gimple_asm_noutputs (gs)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2035 fields = 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2036 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2037 fields = 0; |
| 0 | 2038 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2039 for (f = 0; f < fields; ++f) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2040 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2041 pp_string (buffer, " : "); |
| 0 | 2042 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2043 switch (f) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2044 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2045 case 0: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2046 n = gimple_asm_noutputs (gs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2047 for (i = 0; i < n; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2048 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2049 dump_generic_node (buffer, gimple_asm_output_op (gs, i), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2050 spc, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2051 if (i < n - 1) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2052 pp_string (buffer, ", "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2053 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2054 break; |
| 0 | 2055 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2056 case 1: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2057 n = gimple_asm_ninputs (gs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2058 for (i = 0; i < n; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2059 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2060 dump_generic_node (buffer, gimple_asm_input_op (gs, i), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2061 spc, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2062 if (i < n - 1) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2063 pp_string (buffer, ", "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2064 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2065 break; |
| 0 | 2066 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2067 case 2: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2068 n = gimple_asm_nclobbers (gs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2069 for (i = 0; i < n; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2070 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2071 dump_generic_node (buffer, gimple_asm_clobber_op (gs, i), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2072 spc, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2073 if (i < n - 1) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2074 pp_string (buffer, ", "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2075 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2076 break; |
| 0 | 2077 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2078 case 3: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2079 n = gimple_asm_nlabels (gs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2080 for (i = 0; i < n; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2081 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2082 dump_generic_node (buffer, gimple_asm_label_op (gs, i), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2083 spc, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2084 if (i < n - 1) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2085 pp_string (buffer, ", "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2086 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2087 break; |
| 0 | 2088 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2089 default: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2090 gcc_unreachable (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2091 } |
| 0 | 2092 } |
| 2093 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2094 pp_string (buffer, ");"); |
| 0 | 2095 } |
| 2096 } | |
| 2097 | |
| 111 | 2098 /* Dump ptr_info and range_info for NODE on pretty_printer BUFFER with |
| 2099 SPC spaces of indent. */ | |
| 0 | 2100 |
| 2101 static void | |
| 111 | 2102 dump_ssaname_info (pretty_printer *buffer, tree node, int spc) |
| 2103 { | |
| 2104 if (TREE_CODE (node) != SSA_NAME) | |
| 2105 return; | |
| 2106 | |
| 2107 if (POINTER_TYPE_P (TREE_TYPE (node)) | |
| 2108 && SSA_NAME_PTR_INFO (node)) | |
| 2109 { | |
| 2110 unsigned int align, misalign; | |
| 2111 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (node); | |
| 2112 pp_string (buffer, "# PT = "); | |
| 2113 pp_points_to_solution (buffer, &pi->pt); | |
| 2114 newline_and_indent (buffer, spc); | |
| 2115 if (get_ptr_info_alignment (pi, &align, &misalign)) | |
| 2116 { | |
| 2117 pp_printf (buffer, "# ALIGN = %u, MISALIGN = %u", align, misalign); | |
| 2118 newline_and_indent (buffer, spc); | |
| 2119 } | |
| 2120 } | |
| 2121 | |
| 2122 if (!POINTER_TYPE_P (TREE_TYPE (node)) | |
| 2123 && SSA_NAME_RANGE_INFO (node)) | |
| 2124 { | |
| 2125 wide_int min, max, nonzero_bits; | |
| 131 | 2126 value_range_kind range_type = get_range_info (node, &min, &max); |
| 111 | 2127 |
| 2128 if (range_type == VR_VARYING) | |
| 2129 pp_printf (buffer, "# RANGE VR_VARYING"); | |
| 2130 else if (range_type == VR_RANGE || range_type == VR_ANTI_RANGE) | |
| 2131 { | |
| 2132 pp_printf (buffer, "# RANGE "); | |
| 2133 pp_printf (buffer, "%s[", range_type == VR_RANGE ? "" : "~"); | |
| 2134 pp_wide_int (buffer, min, TYPE_SIGN (TREE_TYPE (node))); | |
| 2135 pp_printf (buffer, ", "); | |
| 2136 pp_wide_int (buffer, max, TYPE_SIGN (TREE_TYPE (node))); | |
| 2137 pp_printf (buffer, "]"); | |
| 2138 } | |
| 2139 nonzero_bits = get_nonzero_bits (node); | |
| 2140 if (nonzero_bits != -1) | |
| 2141 { | |
| 2142 pp_string (buffer, " NONZERO "); | |
| 2143 pp_wide_int (buffer, nonzero_bits, UNSIGNED); | |
| 2144 } | |
| 2145 newline_and_indent (buffer, spc); | |
| 2146 } | |
| 2147 } | |
| 2148 | |
| 2149 /* As dump_ssaname_info, but dump to FILE. */ | |
| 2150 | |
| 2151 void | |
| 2152 dump_ssaname_info_to_file (FILE *file, tree node, int spc) | |
| 2153 { | |
| 2154 pretty_printer buffer; | |
| 2155 pp_needs_newline (&buffer) = true; | |
| 2156 buffer.buffer->stream = file; | |
| 2157 dump_ssaname_info (&buffer, node, spc); | |
| 2158 pp_flush (&buffer); | |
| 2159 } | |
| 2160 | |
| 2161 /* Dump a PHI node PHI. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. | |
| 2162 The caller is responsible for calling pp_flush on BUFFER to finalize | |
| 2163 pretty printer. If COMMENT is true, print this after #. */ | |
| 2164 | |
| 2165 static void | |
| 2166 dump_gimple_phi (pretty_printer *buffer, gphi *phi, int spc, bool comment, | |
| 2167 dump_flags_t flags) | |
| 0 | 2168 { |
| 2169 size_t i; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2170 tree lhs = gimple_phi_result (phi); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2171 |
| 111 | 2172 if (flags & TDF_ALIAS) |
| 2173 dump_ssaname_info (buffer, lhs, spc); | |
| 2174 | |
| 2175 if (comment) | |
| 2176 pp_string (buffer, "# "); | |
| 0 | 2177 |
| 2178 if (flags & TDF_RAW) | |
| 111 | 2179 dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", phi, |
| 2180 gimple_phi_result (phi)); | |
| 0 | 2181 else |
| 2182 { | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2183 dump_generic_node (buffer, lhs, spc, flags, false); |
| 111 | 2184 if (flags & TDF_GIMPLE) |
| 2185 pp_string (buffer, " = __PHI ("); | |
| 2186 else | |
| 2187 pp_string (buffer, " = PHI <"); | |
| 0 | 2188 } |
| 2189 for (i = 0; i < gimple_phi_num_args (phi); i++) | |
| 2190 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2191 if ((flags & TDF_LINENO) && gimple_phi_arg_has_location (phi, i)) |
| 111 | 2192 dump_location (buffer, gimple_phi_arg_location (phi, i)); |
| 2193 if (flags & TDF_GIMPLE) | |
| 2194 { | |
| 2195 basic_block src = gimple_phi_arg_edge (phi, i)->src; | |
| 2196 gimple *stmt = first_stmt (src); | |
| 2197 if (!stmt || gimple_code (stmt) != GIMPLE_LABEL) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2198 { |
| 111 | 2199 pp_string (buffer, "bb_"); |
| 2200 pp_decimal_int (buffer, src->index); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2201 } |
| 111 | 2202 else |
| 2203 dump_generic_node (buffer, gimple_label_label (as_a <glabel *> (stmt)), 0, flags, | |
| 2204 false); | |
| 2205 pp_string (buffer, ": "); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2206 } |
| 0 | 2207 dump_generic_node (buffer, gimple_phi_arg_def (phi, i), spc, flags, |
| 2208 false); | |
| 111 | 2209 if (! (flags & TDF_GIMPLE)) |
| 2210 { | |
| 2211 pp_left_paren (buffer); | |
| 2212 pp_decimal_int (buffer, gimple_phi_arg_edge (phi, i)->src->index); | |
| 2213 pp_right_paren (buffer); | |
| 2214 } | |
| 0 | 2215 if (i < gimple_phi_num_args (phi) - 1) |
| 2216 pp_string (buffer, ", "); | |
| 2217 } | |
| 111 | 2218 if (flags & TDF_GIMPLE) |
| 2219 pp_string (buffer, ");"); | |
| 2220 else | |
| 2221 pp_greater (buffer); | |
| 0 | 2222 } |
| 2223 | |
| 2224 | |
| 2225 /* Dump a GIMPLE_OMP_PARALLEL tuple on the pretty_printer BUFFER, SPC spaces | |
| 2226 of indent. FLAGS specifies details to show in the dump (see TDF_* in | |
| 111 | 2227 dumpfile.h). */ |
| 0 | 2228 |
| 2229 static void | |
| 111 | 2230 dump_gimple_omp_parallel (pretty_printer *buffer, gomp_parallel *gs, |
| 2231 int spc, dump_flags_t flags) | |
| 0 | 2232 { |
| 2233 if (flags & TDF_RAW) | |
| 2234 { | |
| 2235 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, | |
| 2236 gimple_omp_body (gs)); | |
| 2237 dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags); | |
| 2238 dump_gimple_fmt (buffer, spc, flags, " >, %T, %T%n>", | |
| 2239 gimple_omp_parallel_child_fn (gs), | |
| 2240 gimple_omp_parallel_data_arg (gs)); | |
| 2241 } | |
| 2242 else | |
| 2243 { | |
| 2244 gimple_seq body; | |
| 2245 pp_string (buffer, "#pragma omp parallel"); | |
| 2246 dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags); | |
| 2247 if (gimple_omp_parallel_child_fn (gs)) | |
| 2248 { | |
| 2249 pp_string (buffer, " [child fn: "); | |
| 2250 dump_generic_node (buffer, gimple_omp_parallel_child_fn (gs), | |
| 2251 spc, flags, false); | |
| 2252 pp_string (buffer, " ("); | |
| 2253 if (gimple_omp_parallel_data_arg (gs)) | |
| 2254 dump_generic_node (buffer, gimple_omp_parallel_data_arg (gs), | |
| 2255 spc, flags, false); | |
| 2256 else | |
| 2257 pp_string (buffer, "???"); | |
| 2258 pp_string (buffer, ")]"); | |
| 2259 } | |
| 2260 body = gimple_omp_body (gs); | |
| 2261 if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND) | |
| 2262 { | |
| 2263 newline_and_indent (buffer, spc + 2); | |
| 111 | 2264 pp_left_brace (buffer); |
| 0 | 2265 pp_newline (buffer); |
| 2266 dump_gimple_seq (buffer, body, spc + 4, flags); | |
| 2267 newline_and_indent (buffer, spc + 2); | |
| 111 | 2268 pp_right_brace (buffer); |
| 0 | 2269 } |
| 2270 else if (body) | |
| 2271 { | |
| 2272 pp_newline (buffer); | |
| 2273 dump_gimple_seq (buffer, body, spc + 2, flags); | |
| 2274 } | |
| 2275 } | |
| 2276 } | |
| 2277 | |
| 2278 | |
| 2279 /* Dump a GIMPLE_OMP_TASK tuple on the pretty_printer BUFFER, SPC spaces | |
| 2280 of indent. FLAGS specifies details to show in the dump (see TDF_* in | |
| 111 | 2281 dumpfile.h). */ |
| 0 | 2282 |
| 2283 static void | |
| 111 | 2284 dump_gimple_omp_task (pretty_printer *buffer, gomp_task *gs, int spc, |
| 2285 dump_flags_t flags) | |
| 0 | 2286 { |
| 2287 if (flags & TDF_RAW) | |
| 2288 { | |
| 2289 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, | |
| 2290 gimple_omp_body (gs)); | |
| 2291 dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags); | |
| 2292 dump_gimple_fmt (buffer, spc, flags, " >, %T, %T, %T, %T, %T%n>", | |
| 2293 gimple_omp_task_child_fn (gs), | |
| 2294 gimple_omp_task_data_arg (gs), | |
| 2295 gimple_omp_task_copy_fn (gs), | |
| 2296 gimple_omp_task_arg_size (gs), | |
| 2297 gimple_omp_task_arg_size (gs)); | |
| 2298 } | |
| 2299 else | |
| 2300 { | |
| 2301 gimple_seq body; | |
| 111 | 2302 if (gimple_omp_task_taskloop_p (gs)) |
| 2303 pp_string (buffer, "#pragma omp taskloop"); | |
| 2304 else | |
| 2305 pp_string (buffer, "#pragma omp task"); | |
| 0 | 2306 dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags); |
| 2307 if (gimple_omp_task_child_fn (gs)) | |
| 2308 { | |
| 2309 pp_string (buffer, " [child fn: "); | |
| 2310 dump_generic_node (buffer, gimple_omp_task_child_fn (gs), | |
| 2311 spc, flags, false); | |
| 2312 pp_string (buffer, " ("); | |
| 2313 if (gimple_omp_task_data_arg (gs)) | |
| 2314 dump_generic_node (buffer, gimple_omp_task_data_arg (gs), | |
| 2315 spc, flags, false); | |
| 2316 else | |
| 2317 pp_string (buffer, "???"); | |
| 2318 pp_string (buffer, ")]"); | |
| 2319 } | |
| 2320 body = gimple_omp_body (gs); | |
| 2321 if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND) | |
| 2322 { | |
| 2323 newline_and_indent (buffer, spc + 2); | |
| 111 | 2324 pp_left_brace (buffer); |
| 0 | 2325 pp_newline (buffer); |
| 2326 dump_gimple_seq (buffer, body, spc + 4, flags); | |
| 2327 newline_and_indent (buffer, spc + 2); | |
| 111 | 2328 pp_right_brace (buffer); |
| 0 | 2329 } |
| 2330 else if (body) | |
| 2331 { | |
| 2332 pp_newline (buffer); | |
| 2333 dump_gimple_seq (buffer, body, spc + 2, flags); | |
| 2334 } | |
| 2335 } | |
| 2336 } | |
| 2337 | |
| 2338 | |
| 2339 /* Dump a GIMPLE_OMP_ATOMIC_LOAD tuple on the pretty_printer BUFFER, SPC | |
| 2340 spaces of indent. FLAGS specifies details to show in the dump (see TDF_* | |
| 111 | 2341 in dumpfile.h). */ |
| 0 | 2342 |
| 2343 static void | |
| 111 | 2344 dump_gimple_omp_atomic_load (pretty_printer *buffer, gomp_atomic_load *gs, |
| 2345 int spc, dump_flags_t flags) | |
| 0 | 2346 { |
| 2347 if (flags & TDF_RAW) | |
| 2348 { | |
| 2349 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs, | |
| 2350 gimple_omp_atomic_load_lhs (gs), | |
| 2351 gimple_omp_atomic_load_rhs (gs)); | |
| 2352 } | |
| 2353 else | |
| 2354 { | |
| 2355 pp_string (buffer, "#pragma omp atomic_load"); | |
| 111 | 2356 if (gimple_omp_atomic_seq_cst_p (gs)) |
| 2357 pp_string (buffer, " seq_cst"); | |
| 2358 if (gimple_omp_atomic_need_value_p (gs)) | |
| 2359 pp_string (buffer, " [needed]"); | |
| 0 | 2360 newline_and_indent (buffer, spc + 2); |
| 2361 dump_generic_node (buffer, gimple_omp_atomic_load_lhs (gs), | |
| 2362 spc, flags, false); | |
| 2363 pp_space (buffer); | |
| 111 | 2364 pp_equal (buffer); |
| 0 | 2365 pp_space (buffer); |
| 111 | 2366 pp_star (buffer); |
| 0 | 2367 dump_generic_node (buffer, gimple_omp_atomic_load_rhs (gs), |
| 2368 spc, flags, false); | |
| 2369 } | |
| 2370 } | |
| 2371 | |
| 2372 /* Dump a GIMPLE_OMP_ATOMIC_STORE tuple on the pretty_printer BUFFER, SPC | |
| 2373 spaces of indent. FLAGS specifies details to show in the dump (see TDF_* | |
| 111 | 2374 in dumpfile.h). */ |
| 0 | 2375 |
| 2376 static void | |
| 111 | 2377 dump_gimple_omp_atomic_store (pretty_printer *buffer, |
| 2378 gomp_atomic_store *gs, int spc, | |
| 2379 dump_flags_t flags) | |
| 0 | 2380 { |
| 2381 if (flags & TDF_RAW) | |
| 2382 { | |
| 2383 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, | |
| 2384 gimple_omp_atomic_store_val (gs)); | |
| 2385 } | |
| 2386 else | |
| 2387 { | |
| 111 | 2388 pp_string (buffer, "#pragma omp atomic_store "); |
| 2389 if (gimple_omp_atomic_seq_cst_p (gs)) | |
| 2390 pp_string (buffer, "seq_cst "); | |
| 2391 if (gimple_omp_atomic_need_value_p (gs)) | |
| 2392 pp_string (buffer, "[needed] "); | |
| 2393 pp_left_paren (buffer); | |
| 0 | 2394 dump_generic_node (buffer, gimple_omp_atomic_store_val (gs), |
| 2395 spc, flags, false); | |
| 111 | 2396 pp_right_paren (buffer); |
| 0 | 2397 } |
| 2398 } | |
| 2399 | |
| 2400 | |
| 2401 /* Dump all the memory operands for statement GS. BUFFER, SPC and | |
| 111 | 2402 FLAGS are as in pp_gimple_stmt_1. */ |
| 0 | 2403 |
| 2404 static void | |
| 111 | 2405 dump_gimple_mem_ops (pretty_printer *buffer, gimple *gs, int spc, |
| 2406 dump_flags_t flags) | |
| 0 | 2407 { |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2408 tree vdef = gimple_vdef (gs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2409 tree vuse = gimple_vuse (gs); |
| 0 | 2410 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2411 if (vdef != NULL_TREE) |
| 0 | 2412 { |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2413 pp_string (buffer, "# "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2414 dump_generic_node (buffer, vdef, spc + 2, flags, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2415 pp_string (buffer, " = VDEF <"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2416 dump_generic_node (buffer, vuse, spc + 2, flags, false); |
| 111 | 2417 pp_greater (buffer); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2418 newline_and_indent (buffer, spc); |
| 0 | 2419 } |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2420 else if (vuse != NULL_TREE) |
| 0 | 2421 { |
| 2422 pp_string (buffer, "# VUSE <"); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2423 dump_generic_node (buffer, vuse, spc + 2, flags, false); |
| 111 | 2424 pp_greater (buffer); |
| 0 | 2425 newline_and_indent (buffer, spc); |
| 2426 } | |
| 2427 } | |
| 2428 | |
| 2429 | |
| 111 | 2430 /* Print the gimple statement GS on the pretty printer BUFFER, SPC |
| 0 | 2431 spaces of indent. FLAGS specifies details to show in the dump (see |
| 111 | 2432 TDF_* in dumpfile.h). The caller is responsible for calling |
| 2433 pp_flush on BUFFER to finalize the pretty printer. */ | |
| 0 | 2434 |
| 2435 void | |
| 111 | 2436 pp_gimple_stmt_1 (pretty_printer *buffer, gimple *gs, int spc, |
| 2437 dump_flags_t flags) | |
| 0 | 2438 { |
| 2439 if (!gs) | |
| 2440 return; | |
| 2441 | |
| 2442 if (flags & TDF_STMTADDR) | |
| 2443 pp_printf (buffer, "<&%p> ", (void *) gs); | |
| 2444 | |
| 2445 if ((flags & TDF_LINENO) && gimple_has_location (gs)) | |
| 111 | 2446 dump_location (buffer, gimple_location (gs)); |
| 0 | 2447 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2448 if (flags & TDF_EH) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2449 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2450 int lp_nr = lookup_stmt_eh_lp (gs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2451 if (lp_nr > 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2452 pp_printf (buffer, "[LP %d] ", lp_nr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2453 else if (lp_nr < 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2454 pp_printf (buffer, "[MNT %d] ", -lp_nr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2455 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2456 |
| 0 | 2457 if ((flags & (TDF_VOPS|TDF_MEMSYMS)) |
| 2458 && gimple_has_mem_ops (gs)) | |
| 2459 dump_gimple_mem_ops (buffer, gs, spc, flags); | |
| 2460 | |
| 111 | 2461 if (gimple_has_lhs (gs) |
| 2462 && (flags & TDF_ALIAS)) | |
| 2463 dump_ssaname_info (buffer, gimple_get_lhs (gs), spc); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2464 |
| 0 | 2465 switch (gimple_code (gs)) |
| 2466 { | |
| 2467 case GIMPLE_ASM: | |
| 111 | 2468 dump_gimple_asm (buffer, as_a <gasm *> (gs), spc, flags); |
| 0 | 2469 break; |
| 2470 | |
| 2471 case GIMPLE_ASSIGN: | |
| 111 | 2472 dump_gimple_assign (buffer, as_a <gassign *> (gs), spc, flags); |
| 0 | 2473 break; |
| 2474 | |
| 2475 case GIMPLE_BIND: | |
| 111 | 2476 dump_gimple_bind (buffer, as_a <gbind *> (gs), spc, flags); |
| 0 | 2477 break; |
| 2478 | |
| 2479 case GIMPLE_CALL: | |
| 111 | 2480 dump_gimple_call (buffer, as_a <gcall *> (gs), spc, flags); |
| 0 | 2481 break; |
| 2482 | |
| 2483 case GIMPLE_COND: | |
| 111 | 2484 dump_gimple_cond (buffer, as_a <gcond *> (gs), spc, flags); |
| 0 | 2485 break; |
| 2486 | |
| 2487 case GIMPLE_LABEL: | |
| 111 | 2488 dump_gimple_label (buffer, as_a <glabel *> (gs), spc, flags); |
| 0 | 2489 break; |
| 2490 | |
| 2491 case GIMPLE_GOTO: | |
| 111 | 2492 dump_gimple_goto (buffer, as_a <ggoto *> (gs), spc, flags); |
| 0 | 2493 break; |
| 2494 | |
| 2495 case GIMPLE_NOP: | |
| 2496 pp_string (buffer, "GIMPLE_NOP"); | |
| 2497 break; | |
| 2498 | |
| 2499 case GIMPLE_RETURN: | |
| 111 | 2500 dump_gimple_return (buffer, as_a <greturn *> (gs), spc, flags); |
| 0 | 2501 break; |
| 2502 | |
| 2503 case GIMPLE_SWITCH: | |
| 111 | 2504 dump_gimple_switch (buffer, as_a <gswitch *> (gs), spc, flags); |
| 0 | 2505 break; |
| 2506 | |
| 2507 case GIMPLE_TRY: | |
| 111 | 2508 dump_gimple_try (buffer, as_a <gtry *> (gs), spc, flags); |
| 0 | 2509 break; |
| 2510 | |
| 2511 case GIMPLE_PHI: | |
| 111 | 2512 dump_gimple_phi (buffer, as_a <gphi *> (gs), spc, false, flags); |
| 0 | 2513 break; |
| 2514 | |
| 2515 case GIMPLE_OMP_PARALLEL: | |
| 111 | 2516 dump_gimple_omp_parallel (buffer, as_a <gomp_parallel *> (gs), spc, |
| 2517 flags); | |
| 0 | 2518 break; |
| 2519 | |
| 2520 case GIMPLE_OMP_TASK: | |
| 111 | 2521 dump_gimple_omp_task (buffer, as_a <gomp_task *> (gs), spc, flags); |
| 0 | 2522 break; |
| 2523 | |
| 2524 case GIMPLE_OMP_ATOMIC_LOAD: | |
| 111 | 2525 dump_gimple_omp_atomic_load (buffer, as_a <gomp_atomic_load *> (gs), |
| 2526 spc, flags); | |
| 0 | 2527 break; |
| 2528 | |
| 2529 case GIMPLE_OMP_ATOMIC_STORE: | |
| 111 | 2530 dump_gimple_omp_atomic_store (buffer, |
| 2531 as_a <gomp_atomic_store *> (gs), | |
| 2532 spc, flags); | |
| 0 | 2533 break; |
| 2534 | |
| 2535 case GIMPLE_OMP_FOR: | |
| 111 | 2536 dump_gimple_omp_for (buffer, as_a <gomp_for *> (gs), spc, flags); |
| 0 | 2537 break; |
| 2538 | |
| 2539 case GIMPLE_OMP_CONTINUE: | |
| 111 | 2540 dump_gimple_omp_continue (buffer, as_a <gomp_continue *> (gs), spc, |
| 2541 flags); | |
| 0 | 2542 break; |
| 2543 | |
| 2544 case GIMPLE_OMP_SINGLE: | |
| 111 | 2545 dump_gimple_omp_single (buffer, as_a <gomp_single *> (gs), spc, |
| 2546 flags); | |
| 2547 break; | |
| 2548 | |
| 2549 case GIMPLE_OMP_TARGET: | |
| 2550 dump_gimple_omp_target (buffer, as_a <gomp_target *> (gs), spc, | |
| 2551 flags); | |
| 2552 break; | |
| 2553 | |
| 2554 case GIMPLE_OMP_TEAMS: | |
| 2555 dump_gimple_omp_teams (buffer, as_a <gomp_teams *> (gs), spc, | |
| 2556 flags); | |
| 0 | 2557 break; |
| 2558 | |
| 2559 case GIMPLE_OMP_RETURN: | |
| 2560 dump_gimple_omp_return (buffer, gs, spc, flags); | |
| 2561 break; | |
| 2562 | |
| 2563 case GIMPLE_OMP_SECTIONS: | |
| 111 | 2564 dump_gimple_omp_sections (buffer, as_a <gomp_sections *> (gs), |
| 2565 spc, flags); | |
| 0 | 2566 break; |
| 2567 | |
| 2568 case GIMPLE_OMP_SECTIONS_SWITCH: | |
| 2569 pp_string (buffer, "GIMPLE_SECTIONS_SWITCH"); | |
| 2570 break; | |
| 2571 | |
| 2572 case GIMPLE_OMP_MASTER: | |
| 111 | 2573 case GIMPLE_OMP_TASKGROUP: |
| 0 | 2574 case GIMPLE_OMP_SECTION: |
| 111 | 2575 case GIMPLE_OMP_GRID_BODY: |
| 0 | 2576 dump_gimple_omp_block (buffer, gs, spc, flags); |
| 2577 break; | |
| 2578 | |
| 111 | 2579 case GIMPLE_OMP_ORDERED: |
| 2580 dump_gimple_omp_ordered (buffer, as_a <gomp_ordered *> (gs), spc, | |
| 2581 flags); | |
| 2582 break; | |
| 2583 | |
| 0 | 2584 case GIMPLE_OMP_CRITICAL: |
| 111 | 2585 dump_gimple_omp_critical (buffer, as_a <gomp_critical *> (gs), spc, |
| 2586 flags); | |
| 0 | 2587 break; |
| 2588 | |
| 2589 case GIMPLE_CATCH: | |
| 111 | 2590 dump_gimple_catch (buffer, as_a <gcatch *> (gs), spc, flags); |
| 0 | 2591 break; |
| 2592 | |
| 2593 case GIMPLE_EH_FILTER: | |
| 111 | 2594 dump_gimple_eh_filter (buffer, as_a <geh_filter *> (gs), spc, flags); |
| 0 | 2595 break; |
| 2596 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2597 case GIMPLE_EH_MUST_NOT_THROW: |
| 111 | 2598 dump_gimple_eh_must_not_throw (buffer, |
| 2599 as_a <geh_mnt *> (gs), | |
| 2600 spc, flags); | |
| 2601 break; | |
| 2602 | |
| 2603 case GIMPLE_EH_ELSE: | |
| 2604 dump_gimple_eh_else (buffer, as_a <geh_else *> (gs), spc, flags); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2605 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2606 |
| 0 | 2607 case GIMPLE_RESX: |
| 111 | 2608 dump_gimple_resx (buffer, as_a <gresx *> (gs), spc, flags); |
| 0 | 2609 break; |
| 2610 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2611 case GIMPLE_EH_DISPATCH: |
| 111 | 2612 dump_gimple_eh_dispatch (buffer, as_a <geh_dispatch *> (gs), spc, |
| 2613 flags); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2614 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2615 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2616 case GIMPLE_DEBUG: |
| 111 | 2617 dump_gimple_debug (buffer, as_a <gdebug *> (gs), spc, flags); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2618 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2619 |
| 0 | 2620 case GIMPLE_PREDICT: |
| 2621 pp_string (buffer, "// predicted "); | |
| 2622 if (gimple_predict_outcome (gs)) | |
| 2623 pp_string (buffer, "likely by "); | |
| 2624 else | |
| 2625 pp_string (buffer, "unlikely by "); | |
| 2626 pp_string (buffer, predictor_name (gimple_predict_predictor (gs))); | |
| 2627 pp_string (buffer, " predictor."); | |
| 2628 break; | |
| 2629 | |
| 111 | 2630 case GIMPLE_TRANSACTION: |
| 2631 dump_gimple_transaction (buffer, as_a <gtransaction *> (gs), spc, | |
| 2632 flags); | |
| 2633 break; | |
| 2634 | |
| 0 | 2635 default: |
| 2636 GIMPLE_NIY; | |
| 2637 } | |
| 2638 } | |
| 2639 | |
| 2640 | |
| 111 | 2641 /* Dumps header of basic block BB to OUTF indented by INDENT |
| 0 | 2642 spaces and details described by flags. */ |
| 2643 | |
| 2644 static void | |
| 111 | 2645 dump_gimple_bb_header (FILE *outf, basic_block bb, int indent, |
| 2646 dump_flags_t flags) | |
| 0 | 2647 { |
| 2648 if (flags & TDF_BLOCKS) | |
| 2649 { | |
| 2650 if (flags & TDF_LINENO) | |
| 2651 { | |
| 2652 gimple_stmt_iterator gsi; | |
| 2653 | |
| 111 | 2654 fputs (";; ", outf); |
| 2655 | |
| 0 | 2656 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2657 if (!is_gimple_debug (gsi_stmt (gsi)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2658 && get_lineno (gsi_stmt (gsi)) != UNKNOWN_LOCATION) |
| 0 | 2659 { |
| 111 | 2660 fprintf (outf, "%*sstarting at line %d", |
| 2661 indent, "", get_lineno (gsi_stmt (gsi))); | |
| 0 | 2662 break; |
| 2663 } | |
| 111 | 2664 if (bb->discriminator) |
| 2665 fprintf (outf, ", discriminator %i", bb->discriminator); | |
| 2666 fputc ('\n', outf); | |
| 0 | 2667 } |
| 2668 } | |
| 2669 else | |
| 2670 { | |
| 111 | 2671 if (flags & TDF_GIMPLE) |
| 2672 fprintf (outf, "%*sbb_%d:\n", indent, "", bb->index); | |
| 2673 else | |
| 2674 fprintf (outf, "%*s<bb %d> %s:\n", | |
| 131 | 2675 indent, "", bb->index, dump_profile (bb->count)); |
| 0 | 2676 } |
| 2677 } | |
| 2678 | |
| 2679 | |
| 2680 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT | |
| 2681 spaces. */ | |
| 2682 | |
| 2683 static void | |
| 111 | 2684 dump_gimple_bb_footer (FILE *outf ATTRIBUTE_UNUSED, |
| 2685 basic_block bb ATTRIBUTE_UNUSED, | |
| 2686 int indent ATTRIBUTE_UNUSED, | |
| 2687 dump_flags_t flags ATTRIBUTE_UNUSED) | |
| 0 | 2688 { |
| 111 | 2689 /* There is currently no GIMPLE-specific basic block info to dump. */ |
| 2690 return; | |
| 0 | 2691 } |
| 2692 | |
| 2693 | |
| 2694 /* Dump PHI nodes of basic block BB to BUFFER with details described | |
| 2695 by FLAGS and indented by INDENT spaces. */ | |
| 2696 | |
| 2697 static void | |
| 111 | 2698 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, |
| 2699 dump_flags_t flags) | |
| 0 | 2700 { |
| 111 | 2701 gphi_iterator i; |
| 0 | 2702 |
| 2703 for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i)) | |
| 2704 { | |
| 111 | 2705 gphi *phi = i.phi (); |
| 2706 if (!virtual_operand_p (gimple_phi_result (phi)) || (flags & TDF_VOPS)) | |
| 0 | 2707 { |
| 2708 INDENT (indent); | |
| 111 | 2709 dump_gimple_phi (buffer, phi, indent, |
| 2710 (flags & TDF_GIMPLE) ? false : true, flags); | |
| 0 | 2711 pp_newline (buffer); |
| 2712 } | |
| 2713 } | |
| 2714 } | |
| 2715 | |
| 2716 | |
| 2717 /* Dump jump to basic block BB that is represented implicitly in the cfg | |
| 2718 to BUFFER. */ | |
| 2719 | |
| 2720 static void | |
| 111 | 2721 pp_cfg_jump (pretty_printer *buffer, edge e, dump_flags_t flags) |
| 0 | 2722 { |
| 111 | 2723 if (flags & TDF_GIMPLE) |
| 0 | 2724 { |
| 111 | 2725 pp_string (buffer, "goto bb_"); |
| 2726 pp_decimal_int (buffer, e->dest->index); | |
| 0 | 2727 pp_semicolon (buffer); |
| 2728 } | |
| 2729 else | |
| 111 | 2730 { |
| 2731 pp_string (buffer, "goto <bb "); | |
| 2732 pp_decimal_int (buffer, e->dest->index); | |
| 2733 pp_greater (buffer); | |
| 2734 pp_semicolon (buffer); | |
| 2735 | |
| 2736 dump_edge_probability (buffer, e); | |
| 2737 } | |
| 0 | 2738 } |
| 2739 | |
| 2740 | |
| 2741 /* Dump edges represented implicitly in basic block BB to BUFFER, indented | |
| 2742 by INDENT spaces, with details given by FLAGS. */ | |
| 2743 | |
| 2744 static void | |
| 2745 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent, | |
| 111 | 2746 dump_flags_t flags) |
| 0 | 2747 { |
| 2748 edge e; | |
| 111 | 2749 gimple *stmt; |
| 0 | 2750 |
| 2751 stmt = last_stmt (bb); | |
| 2752 | |
| 2753 if (stmt && gimple_code (stmt) == GIMPLE_COND) | |
| 2754 { | |
| 2755 edge true_edge, false_edge; | |
| 2756 | |
| 2757 /* When we are emitting the code or changing CFG, it is possible that | |
| 2758 the edges are not yet created. When we are using debug_bb in such | |
| 2759 a situation, we do not want it to crash. */ | |
| 2760 if (EDGE_COUNT (bb->succs) != 2) | |
| 2761 return; | |
| 2762 extract_true_false_edges_from_block (bb, &true_edge, &false_edge); | |
| 2763 | |
| 2764 INDENT (indent + 2); | |
| 111 | 2765 pp_cfg_jump (buffer, true_edge, flags); |
| 0 | 2766 newline_and_indent (buffer, indent); |
| 2767 pp_string (buffer, "else"); | |
| 2768 newline_and_indent (buffer, indent + 2); | |
| 111 | 2769 pp_cfg_jump (buffer, false_edge, flags); |
| 0 | 2770 pp_newline (buffer); |
| 2771 return; | |
| 2772 } | |
| 2773 | |
| 2774 /* If there is a fallthru edge, we may need to add an artificial | |
| 2775 goto to the dump. */ | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2776 e = find_fallthru_edge (bb->succs); |
| 0 | 2777 |
| 2778 if (e && e->dest != bb->next_bb) | |
| 2779 { | |
| 2780 INDENT (indent); | |
| 2781 | |
| 2782 if ((flags & TDF_LINENO) | |
| 111 | 2783 && e->goto_locus != UNKNOWN_LOCATION) |
| 2784 dump_location (buffer, e->goto_locus); | |
| 0 | 2785 |
| 111 | 2786 pp_cfg_jump (buffer, e, flags); |
| 0 | 2787 pp_newline (buffer); |
| 2788 } | |
| 2789 } | |
| 2790 | |
| 2791 | |
| 2792 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and | |
| 2793 indented by INDENT spaces. */ | |
| 2794 | |
| 2795 static void | |
| 2796 gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent, | |
| 111 | 2797 dump_flags_t flags) |
| 0 | 2798 { |
| 2799 gimple_stmt_iterator gsi; | |
| 111 | 2800 gimple *stmt; |
| 0 | 2801 int label_indent = indent - 2; |
| 2802 | |
| 2803 if (label_indent < 0) | |
| 2804 label_indent = 0; | |
| 2805 | |
| 2806 dump_phi_nodes (buffer, bb, indent, flags); | |
| 2807 | |
| 2808 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) | |
| 2809 { | |
| 2810 int curr_indent; | |
| 2811 | |
| 2812 stmt = gsi_stmt (gsi); | |
| 2813 | |
| 2814 curr_indent = gimple_code (stmt) == GIMPLE_LABEL ? label_indent : indent; | |
| 2815 | |
| 2816 INDENT (curr_indent); | |
| 111 | 2817 pp_gimple_stmt_1 (buffer, stmt, curr_indent, flags); |
| 2818 pp_newline_and_flush (buffer); | |
| 2819 gcc_checking_assert (DECL_STRUCT_FUNCTION (current_function_decl)); | |
| 2820 dump_histograms_for_stmt (DECL_STRUCT_FUNCTION (current_function_decl), | |
| 2821 pp_buffer (buffer)->stream, stmt); | |
| 0 | 2822 } |
| 2823 | |
| 2824 dump_implicit_edges (buffer, bb, indent, flags); | |
| 111 | 2825 pp_flush (buffer); |
| 0 | 2826 } |
| 2827 | |
| 2828 | |
| 2829 /* Dumps basic block BB to FILE with details described by FLAGS and | |
| 2830 indented by INDENT spaces. */ | |
| 2831 | |
| 2832 void | |
| 111 | 2833 gimple_dump_bb (FILE *file, basic_block bb, int indent, dump_flags_t flags) |
| 2834 { | |
| 2835 dump_gimple_bb_header (file, bb, indent, flags); | |
| 2836 if (bb->index >= NUM_FIXED_BLOCKS) | |
| 2837 { | |
| 2838 pretty_printer buffer; | |
| 2839 pp_needs_newline (&buffer) = true; | |
| 2840 buffer.buffer->stream = file; | |
| 2841 gimple_dump_bb_buff (&buffer, bb, indent, flags); | |
| 2842 } | |
| 2843 dump_gimple_bb_footer (file, bb, indent, flags); | |
| 2844 } | |
| 2845 | |
| 2846 /* Dumps basic block BB to pretty-printer PP with default dump flags and | |
| 2847 no indentation, for use as a label of a DOT graph record-node. | |
| 2848 ??? Should just use gimple_dump_bb_buff here, except that value profiling | |
| 2849 histogram dumping doesn't know about pretty-printers. */ | |
| 2850 | |
| 2851 void | |
| 2852 gimple_dump_bb_for_graph (pretty_printer *pp, basic_block bb) | |
| 0 | 2853 { |
| 111 | 2854 pp_printf (pp, "<bb %d>:\n", bb->index); |
| 2855 pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true); | |
| 2856 | |
| 2857 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); | |
| 2858 gsi_next (&gsi)) | |
| 2859 { | |
| 2860 gphi *phi = gsi.phi (); | |
| 2861 if (!virtual_operand_p (gimple_phi_result (phi)) | |
| 2862 || (dump_flags & TDF_VOPS)) | |
| 2863 { | |
| 2864 pp_bar (pp); | |
| 2865 pp_write_text_to_stream (pp); | |
| 2866 pp_string (pp, "# "); | |
| 2867 pp_gimple_stmt_1 (pp, phi, 0, dump_flags); | |
| 2868 pp_newline (pp); | |
| 2869 pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true); | |
| 2870 } | |
| 2871 } | |
| 2872 | |
| 2873 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi); | |
| 2874 gsi_next (&gsi)) | |
| 2875 { | |
| 2876 gimple *stmt = gsi_stmt (gsi); | |
| 2877 pp_bar (pp); | |
| 2878 pp_write_text_to_stream (pp); | |
| 2879 pp_gimple_stmt_1 (pp, stmt, 0, dump_flags); | |
| 2880 pp_newline (pp); | |
| 2881 pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true); | |
| 2882 } | |
| 2883 dump_implicit_edges (pp, bb, 0, dump_flags); | |
| 2884 pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true); | |
| 0 | 2885 } |
| 111 | 2886 |
| 2887 | |
| 2888 /* Handle the %G format for TEXT. Same as %K in handle_K_format in | |
| 131 | 2889 tree-pretty-print.c but with a Gimple statement as an argument. */ |
| 111 | 2890 |
| 2891 void | |
| 2892 percent_G_format (text_info *text) | |
| 2893 { | |
| 131 | 2894 gimple *stmt = va_arg (*text->args_ptr, gimple*); |
| 111 | 2895 |
| 131 | 2896 tree block = gimple_block (stmt); |
| 2897 percent_K_format (text, gimple_location (stmt), block); | |
| 111 | 2898 } |