1 /* Pretty formatting of GIMPLE statements and expressions. 2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 3 2011 Free Software Foundation, Inc. 4 Contributed by Aldy Hernandez <aldyh@redhat.com> and 5 Diego Novillo <dnovillo@google.com> 6 7 This file is part of GCC. 8 9 GCC is free software; you can redistribute it and/or modify it under 10 the terms of the GNU General Public License as published by the Free 11 Software Foundation; either version 3, or (at your option) any later 12 version. 13 14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 15 WARRANTY; without even the implied warranty of MERCHANTABILITY or 16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 17 for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with GCC; see the file COPYING3. If not see 21 <http://www.gnu.org/licenses/>. */ 22 23 #include "config.h" 24 #include "system.h" 25 #include "coretypes.h" 26 #include "tm.h" 27 #include "tree.h" 28 #include "diagnostic.h" 29 #include "tree-pretty-print.h" 30 #include "gimple-pretty-print.h" 31 #include "hashtab.h" 32 #include "tree-flow.h" 33 #include "tree-pass.h" 34 #include "gimple.h" 35 #include "value-prof.h" 36 #include "trans-mem.h" 37 38 #define INDENT(SPACE) \ 39 do { int i; for (i = 0; i < SPACE; i++) pp_space (buffer); } while (0) 40 41 static pretty_printer buffer; 42 static bool initialized = false; 43 44 #define GIMPLE_NIY do_niy (buffer,gs) 45 46 /* Try to print on BUFFER a default message for the unrecognized 47 gimple statement GS. */ 48 49 static void 50 do_niy (pretty_printer *buffer, gimple gs) 51 { 52 pp_printf (buffer, "<<< Unknown GIMPLE statement: %s >>>\n", 53 gimple_code_name[(int) gimple_code (gs)]); 54 } 55 56 57 /* Initialize the pretty printer on FILE if needed. */ 58 59 static void 60 maybe_init_pretty_print (FILE *file) 61 { 62 if (!initialized) 63 { 64 pp_construct (&buffer, NULL, 0); 65 pp_needs_newline (&buffer) = true; 66 initialized = true; 67 } 68 69 buffer.buffer->stream = file; 70 } 71 72 73 /* Emit a newline and SPC indentantion spaces to BUFFER. */ 74 75 static void 76 newline_and_indent (pretty_printer *buffer, int spc) 77 { 78 pp_newline (buffer); 79 INDENT (spc); 80 } 81 82 83 /* Print the GIMPLE statement GS on stderr. */ 84 85 DEBUG_FUNCTION void 86 debug_gimple_stmt (gimple gs) 87 { 88 print_gimple_stmt (stderr, gs, 0, TDF_VOPS|TDF_MEMSYMS); 89 fprintf (stderr, "\n"); 90 } 91 92 93 /* Dump GIMPLE statement G to FILE using SPC indentantion spaces and 94 FLAGS as in dump_gimple_stmt. */ 95 96 void 97 print_gimple_stmt (FILE *file, gimple g, int spc, int flags) 98 { 99 maybe_init_pretty_print (file); 100 dump_gimple_stmt (&buffer, g, spc, flags); 101 pp_flush (&buffer); 102 } 103 104 105 /* Dump GIMPLE statement G to FILE using SPC indentantion spaces and 106 FLAGS as in dump_gimple_stmt. Print only the right-hand side 107 of the statement. */ 108 109 void 110 print_gimple_expr (FILE *file, gimple g, int spc, int flags) 111 { 112 flags |= TDF_RHS_ONLY; 113 maybe_init_pretty_print (file); 114 dump_gimple_stmt (&buffer, g, spc, flags); 115 } 116 117 118 /* Print the GIMPLE sequence SEQ on BUFFER using SPC indentantion 119 spaces and FLAGS as in dump_gimple_stmt. */ 120 121 static void 122 dump_gimple_seq (pretty_printer *buffer, gimple_seq seq, int spc, int flags) 123 { 124 gimple_stmt_iterator i; 125 126 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i)) 127 { 128 gimple gs = gsi_stmt (i); 129 INDENT (spc); 130 dump_gimple_stmt (buffer, gs, spc, flags); 131 if (!gsi_one_before_end_p (i)) 132 pp_newline (buffer); 133 } 134 } 135 136 137 /* Dump GIMPLE sequence SEQ to FILE using SPC indentantion spaces and 138 FLAGS as in dump_gimple_stmt. */ 139 140 void 141 print_gimple_seq (FILE *file, gimple_seq seq, int spc, int flags) 142 { 143 maybe_init_pretty_print (file); 144 dump_gimple_seq (&buffer, seq, spc, flags); 145 pp_flush (&buffer); 146 } 147 148 149 /* Print the GIMPLE sequence SEQ on stderr. */ 150 151 DEBUG_FUNCTION void 152 debug_gimple_seq (gimple_seq seq) 153 { 154 print_gimple_seq (stderr, seq, 0, TDF_VOPS|TDF_MEMSYMS); 155 } 156 157 158 /* A simple helper to pretty-print some of the gimple tuples in the printf 159 style. The format modifiers are preceeded by '%' and are: 160 'G' - outputs a string corresponding to the code of the given gimple, 161 'S' - outputs a gimple_seq with indent of spc + 2, 162 'T' - outputs the tree t, 163 'd' - outputs an int as a decimal, 164 's' - outputs a string, 165 'n' - outputs a newline, 166 'x' - outputs an int as hexadecimal, 167 '+' - increases indent by 2 then outputs a newline, 168 '-' - decreases indent by 2 then outputs a newline. */ 169 170 static void 171 dump_gimple_fmt (pretty_printer *buffer, int spc, int flags, 172 const char *fmt, ...) 173 { 174 va_list args; 175 const char *c; 176 const char *tmp; 177 178 va_start (args, fmt); 179 for (c = fmt; *c; c++) 180 { 181 if (*c == '%') 182 { 183 gimple_seq seq; 184 tree t; 185 gimple g; 186 switch (*++c) 187 { 188 case 'G': 189 g = va_arg (args, gimple); 190 tmp = gimple_code_name[gimple_code (g)]; 191 pp_string (buffer, tmp); 192 break; 193 194 case 'S': 195 seq = va_arg (args, gimple_seq); 196 pp_newline (buffer); 197 dump_gimple_seq (buffer, seq, spc + 2, flags); 198 newline_and_indent (buffer, spc); 199 break; 200 201 case 'T': 202 t = va_arg (args, tree); 203 if (t == NULL_TREE) 204 pp_string (buffer, "NULL"); 205 else 206 dump_generic_node (buffer, t, spc, flags, false); 207 break; 208 209 case 'd': 210 pp_decimal_int (buffer, va_arg (args, int)); 211 break; 212 213 case 's': 214 pp_string (buffer, va_arg (args, char *)); 215 break; 216 217 case 'n': 218 newline_and_indent (buffer, spc); 219 break; 220 221 case 'x': 222 pp_scalar (buffer, "%x", va_arg (args, int)); 223 break; 224 225 case '+': 226 spc += 2; 227 newline_and_indent (buffer, spc); 228 break; 229 230 case '-': 231 spc -= 2; 232 newline_and_indent (buffer, spc); 233 break; 234 235 default: 236 gcc_unreachable (); 237 } 238 } 239 else 240 pp_character (buffer, *c); 241 } 242 va_end (args); 243 } 244 245 246 /* Helper for dump_gimple_assign. Print the unary RHS of the 247 assignment GS. BUFFER, SPC and FLAGS are as in dump_gimple_stmt. */ 248 249 static void 250 dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags) 251 { 252 enum tree_code rhs_code = gimple_assign_rhs_code (gs); 253 tree lhs = gimple_assign_lhs (gs); 254 tree rhs = gimple_assign_rhs1 (gs); 255 256 switch (rhs_code) 257 { 258 case VIEW_CONVERT_EXPR: 259 case ASSERT_EXPR: 260 dump_generic_node (buffer, rhs, spc, flags, false); 261 break; 262 263 case FIXED_CONVERT_EXPR: 264 case ADDR_SPACE_CONVERT_EXPR: 265 case FIX_TRUNC_EXPR: 266 case FLOAT_EXPR: 267 CASE_CONVERT: 268 pp_character (buffer, '('); 269 dump_generic_node (buffer, TREE_TYPE (lhs), spc, flags, false); 270 pp_string (buffer, ") "); 271 if (op_prio (rhs) < op_code_prio (rhs_code)) 272 { 273 pp_character (buffer, '('); 274 dump_generic_node (buffer, rhs, spc, flags, false); 275 pp_character (buffer, ')'); 276 } 277 else 278 dump_generic_node (buffer, rhs, spc, flags, false); 279 break; 280 281 case PAREN_EXPR: 282 pp_string (buffer, "(("); 283 dump_generic_node (buffer, rhs, spc, flags, false); 284 pp_string (buffer, "))"); 285 break; 286 287 case ABS_EXPR: 288 pp_string (buffer, "ABS_EXPR <"); 289 dump_generic_node (buffer, rhs, spc, flags, false); 290 pp_character (buffer, '>'); 291 break; 292 293 default: 294 if (TREE_CODE_CLASS (rhs_code) == tcc_declaration 295 || TREE_CODE_CLASS (rhs_code) == tcc_constant 296 || TREE_CODE_CLASS (rhs_code) == tcc_reference 297 || rhs_code == SSA_NAME 298 || rhs_code == ADDR_EXPR 299 || rhs_code == CONSTRUCTOR) 300 { 301 dump_generic_node (buffer, rhs, spc, flags, false); 302 break; 303 } 304 else if (rhs_code == BIT_NOT_EXPR) 305 pp_character (buffer, '~'); 306 else if (rhs_code == TRUTH_NOT_EXPR) 307 pp_character (buffer, '!'); 308 else if (rhs_code == NEGATE_EXPR) 309 pp_character (buffer, '-'); 310 else 311 { 312 pp_character (buffer, '['); 313 pp_string (buffer, tree_code_name [rhs_code]); 314 pp_string (buffer, "] "); 315 } 316 317 if (op_prio (rhs) < op_code_prio (rhs_code)) 318 { 319 pp_character (buffer, '('); 320 dump_generic_node (buffer, rhs, spc, flags, false); 321 pp_character (buffer, ')'); 322 } 323 else 324 dump_generic_node (buffer, rhs, spc, flags, false); 325 break; 326 } 327 } 328 329 330 /* Helper for dump_gimple_assign. Print the binary RHS of the 331 assignment GS. BUFFER, SPC and FLAGS are as in dump_gimple_stmt. */ 332 333 static void 334 dump_binary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags) 335 { 336 const char *p; 337 enum tree_code code = gimple_assign_rhs_code (gs); 338 switch (code) 339 { 340 case COMPLEX_EXPR: 341 case MIN_EXPR: 342 case MAX_EXPR: 343 case VEC_WIDEN_MULT_HI_EXPR: 344 case VEC_WIDEN_MULT_LO_EXPR: 345 case VEC_PACK_TRUNC_EXPR: 346 case VEC_PACK_SAT_EXPR: 347 case VEC_PACK_FIX_TRUNC_EXPR: 348 case VEC_WIDEN_LSHIFT_HI_EXPR: 349 case VEC_WIDEN_LSHIFT_LO_EXPR: 350 for (p = tree_code_name [(int) code]; *p; p++) 351 pp_character (buffer, TOUPPER (*p)); 352 pp_string (buffer, " <"); 353 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); 354 pp_string (buffer, ", "); 355 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); 356 pp_character (buffer, '>'); 357 break; 358 359 default: 360 if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code)) 361 { 362 pp_character (buffer, '('); 363 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, 364 false); 365 pp_character (buffer, ')'); 366 } 367 else 368 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); 369 pp_space (buffer); 370 pp_string (buffer, op_symbol_code (gimple_assign_rhs_code (gs))); 371 pp_space (buffer); 372 if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code)) 373 { 374 pp_character (buffer, '('); 375 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, 376 false); 377 pp_character (buffer, ')'); 378 } 379 else 380 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); 381 } 382 } 383 384 /* Helper for dump_gimple_assign. Print the ternary RHS of the 385 assignment GS. BUFFER, SPC and FLAGS are as in dump_gimple_stmt. */ 386 387 static void 388 dump_ternary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags) 389 { 390 const char *p; 391 enum tree_code code = gimple_assign_rhs_code (gs); 392 switch (code) 393 { 394 case WIDEN_MULT_PLUS_EXPR: 395 case WIDEN_MULT_MINUS_EXPR: 396 for (p = tree_code_name [(int) code]; *p; p++) 397 pp_character (buffer, TOUPPER (*p)); 398 pp_string (buffer, " <"); 399 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); 400 pp_string (buffer, ", "); 401 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); 402 pp_string (buffer, ", "); 403 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); 404 pp_character (buffer, '>'); 405 break; 406 407 case FMA_EXPR: 408 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); 409 pp_string (buffer, " * "); 410 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); 411 pp_string (buffer, " + "); 412 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); 413 break; 414 415 case DOT_PROD_EXPR: 416 pp_string (buffer, "DOT_PROD_EXPR <"); 417 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); 418 pp_string (buffer, ", "); 419 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); 420 pp_string (buffer, ", "); 421 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); 422 pp_string (buffer, ">"); 423 break; 424 425 case VEC_PERM_EXPR: 426 pp_string (buffer, "VEC_PERM_EXPR <"); 427 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); 428 pp_string (buffer, ", "); 429 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); 430 pp_string (buffer, ", "); 431 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); 432 pp_string (buffer, ">"); 433 break; 434 435 case REALIGN_LOAD_EXPR: 436 pp_string (buffer, "REALIGN_LOAD <"); 437 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); 438 pp_string (buffer, ", "); 439 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); 440 pp_string (buffer, ", "); 441 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); 442 pp_string (buffer, ">"); 443 break; 444 445 case COND_EXPR: 446 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); 447 pp_string (buffer, " ? "); 448 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); 449 pp_string (buffer, " : "); 450 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); 451 break; 452 453 case VEC_COND_EXPR: 454 pp_string (buffer, "VEC_COND_EXPR <"); 455 dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); 456 pp_string (buffer, ", "); 457 dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); 458 pp_string (buffer, ", "); 459 dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); 460 pp_string (buffer, ">"); 461 break; 462 463 default: 464 gcc_unreachable (); 465 } 466 } 467 468 469 /* Dump the gimple assignment GS. BUFFER, SPC and FLAGS are as in 470 dump_gimple_stmt. */ 471 472 static void 473 dump_gimple_assign (pretty_printer *buffer, gimple gs, int spc, int flags) 474 { 475 if (flags & TDF_RAW) 476 { 477 tree last; 478 if (gimple_num_ops (gs) == 2) 479 last = NULL_TREE; 480 else if (gimple_num_ops (gs) == 3) 481 last = gimple_assign_rhs2 (gs); 482 else 483 gcc_unreachable (); 484 485 dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T>", gs, 486 tree_code_name[gimple_assign_rhs_code (gs)], 487 gimple_assign_lhs (gs), gimple_assign_rhs1 (gs), last); 488 } 489 else 490 { 491 if (!(flags & TDF_RHS_ONLY)) 492 { 493 dump_generic_node (buffer, gimple_assign_lhs (gs), spc, flags, false); 494 pp_space (buffer); 495 pp_character (buffer, '='); 496 497 if (gimple_assign_nontemporal_move_p (gs)) 498 pp_string (buffer, "{nt}"); 499 500 if (gimple_has_volatile_ops (gs)) 501 pp_string (buffer, "{v}"); 502 503 pp_space (buffer); 504 } 505 506 if (gimple_num_ops (gs) == 2) 507 dump_unary_rhs (buffer, gs, spc, flags); 508 else if (gimple_num_ops (gs) == 3) 509 dump_binary_rhs (buffer, gs, spc, flags); 510 else if (gimple_num_ops (gs) == 4) 511 dump_ternary_rhs (buffer, gs, spc, flags); 512 else 513 gcc_unreachable (); 514 if (!(flags & TDF_RHS_ONLY)) 515 pp_semicolon(buffer); 516 } 517 } 518 519 520 /* Dump the return statement GS. BUFFER, SPC and FLAGS are as in 521 dump_gimple_stmt. */ 522 523 static void 524 dump_gimple_return (pretty_printer *buffer, gimple gs, int spc, int flags) 525 { 526 tree t; 527 528 t = gimple_return_retval (gs); 529 if (flags & TDF_RAW) 530 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, t); 531 else 532 { 533 pp_string (buffer, "return"); 534 if (t) 535 { 536 pp_space (buffer); 537 dump_generic_node (buffer, t, spc, flags, false); 538 } 539 pp_semicolon (buffer); 540 } 541 } 542 543 544 /* Dump the call arguments for a gimple call. BUFFER, FLAGS are as in 545 dump_gimple_call. */ 546 547 static void 548 dump_gimple_call_args (pretty_printer *buffer, gimple gs, int flags) 549 { 550 size_t i; 551 552 for (i = 0; i < gimple_call_num_args (gs); i++) 553 { 554 dump_generic_node (buffer, gimple_call_arg (gs, i), 0, flags, false); 555 if (i < gimple_call_num_args (gs) - 1) 556 pp_string (buffer, ", "); 557 } 558 559 if (gimple_call_va_arg_pack_p (gs)) 560 { 561 if (gimple_call_num_args (gs) > 0) 562 { 563 pp_character (buffer, ','); 564 pp_space (buffer); 565 } 566 567 pp_string (buffer, "__builtin_va_arg_pack ()"); 568 } 569 } 570 571 /* Dump the points-to solution *PT to BUFFER. */ 572 573 static void 574 pp_points_to_solution (pretty_printer *buffer, struct pt_solution *pt) 575 { 576 if (pt->anything) 577 { 578 pp_string (buffer, "anything "); 579 return; 580 } 581 if (pt->nonlocal) 582 pp_string (buffer, "nonlocal "); 583 if (pt->escaped) 584 pp_string (buffer, "escaped "); 585 if (pt->ipa_escaped) 586 pp_string (buffer, "unit-escaped "); 587 if (pt->null) 588 pp_string (buffer, "null "); 589 if (pt->vars 590 && !bitmap_empty_p (pt->vars)) 591 { 592 bitmap_iterator bi; 593 unsigned i; 594 pp_string (buffer, "{ "); 595 EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi) 596 { 597 tree var = referenced_var_lookup (cfun, i); 598 if (var) 599 { 600 dump_generic_node (buffer, var, 0, dump_flags, false); 601 if (DECL_PT_UID (var) != DECL_UID (var)) 602 { 603 pp_string (buffer, "ptD."); 604 pp_decimal_int (buffer, DECL_PT_UID (var)); 605 } 606 } 607 else 608 { 609 pp_string (buffer, "D."); 610 pp_decimal_int (buffer, i); 611 } 612 pp_character (buffer, ' '); 613 } 614 pp_character (buffer, '}'); 615 if (pt->vars_contains_global) 616 pp_string (buffer, " (glob)"); 617 } 618 } 619 620 /* Dump the call statement GS. BUFFER, SPC and FLAGS are as in 621 dump_gimple_stmt. */ 622 623 static void 624 dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags) 625 { 626 tree lhs = gimple_call_lhs (gs); 627 tree fn = gimple_call_fn (gs); 628 629 if (flags & TDF_ALIAS) 630 { 631 struct pt_solution *pt; 632 pt = gimple_call_use_set (gs); 633 if (!pt_solution_empty_p (pt)) 634 { 635 pp_string (buffer, "# USE = "); 636 pp_points_to_solution (buffer, pt); 637 newline_and_indent (buffer, spc); 638 } 639 pt = gimple_call_clobber_set (gs); 640 if (!pt_solution_empty_p (pt)) 641 { 642 pp_string (buffer, "# CLB = "); 643 pp_points_to_solution (buffer, pt); 644 newline_and_indent (buffer, spc); 645 } 646 } 647 648 if (flags & TDF_RAW) 649 { 650 if (gimple_call_internal_p (gs)) 651 dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T", gs, 652 internal_fn_name (gimple_call_internal_fn (gs)), lhs); 653 else 654 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T", gs, fn, lhs); 655 if (gimple_call_num_args (gs) > 0) 656 { 657 pp_string (buffer, ", "); 658 dump_gimple_call_args (buffer, gs, flags); 659 } 660 pp_character (buffer, '>'); 661 } 662 else 663 { 664 if (lhs && !(flags & TDF_RHS_ONLY)) 665 { 666 dump_generic_node (buffer, lhs, spc, flags, false); 667 pp_string (buffer, " ="); 668 669 if (gimple_has_volatile_ops (gs)) 670 pp_string (buffer, "{v}"); 671 672 pp_space (buffer); 673 } 674 if (gimple_call_internal_p (gs)) 675 pp_string (buffer, internal_fn_name (gimple_call_internal_fn (gs))); 676 else 677 print_call_name (buffer, fn, flags); 678 pp_string (buffer, " ("); 679 dump_gimple_call_args (buffer, gs, flags); 680 pp_character (buffer, ')'); 681 if (!(flags & TDF_RHS_ONLY)) 682 pp_semicolon (buffer); 683 } 684 685 if (gimple_call_chain (gs)) 686 { 687 pp_string (buffer, " [static-chain: "); 688 dump_generic_node (buffer, gimple_call_chain (gs), spc, flags, false); 689 pp_character (buffer, ']'); 690 } 691 692 if (gimple_call_return_slot_opt_p (gs)) 693 pp_string (buffer, " [return slot optimization]"); 694 if (gimple_call_tail_p (gs)) 695 pp_string (buffer, " [tail call]"); 696 697 if (fn == NULL) 698 return; 699 700 /* Dump the arguments of _ITM_beginTransaction sanely. */ 701 if (TREE_CODE (fn) == ADDR_EXPR) 702 fn = TREE_OPERAND (fn, 0); 703 if (TREE_CODE (fn) == FUNCTION_DECL && decl_is_tm_clone (fn)) 704 pp_string (buffer, " [tm-clone]"); 705 if (TREE_CODE (fn) == FUNCTION_DECL 706 && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL 707 && DECL_FUNCTION_CODE (fn) == BUILT_IN_TM_START 708 && gimple_call_num_args (gs) > 0) 709 { 710 tree t = gimple_call_arg (gs, 0); 711 unsigned HOST_WIDE_INT props; 712 gcc_assert (TREE_CODE (t) == INTEGER_CST); 713 714 pp_string (buffer, " [ "); 715 716 /* Get the transaction code properties. */ 717 props = TREE_INT_CST_LOW (t); 718 719 if (props & PR_INSTRUMENTEDCODE) 720 pp_string (buffer, "instrumentedCode "); 721 if (props & PR_UNINSTRUMENTEDCODE) 722 pp_string (buffer, "uninstrumentedCode "); 723 if (props & PR_HASNOXMMUPDATE) 724 pp_string (buffer, "hasNoXMMUpdate "); 725 if (props & PR_HASNOABORT) 726 pp_string (buffer, "hasNoAbort "); 727 if (props & PR_HASNOIRREVOCABLE) 728 pp_string (buffer, "hasNoIrrevocable "); 729 if (props & PR_DOESGOIRREVOCABLE) 730 pp_string (buffer, "doesGoIrrevocable "); 731 if (props & PR_HASNOSIMPLEREADS) 732 pp_string (buffer, "hasNoSimpleReads "); 733 if (props & PR_AWBARRIERSOMITTED) 734 pp_string (buffer, "awBarriersOmitted "); 735 if (props & PR_RARBARRIERSOMITTED) 736 pp_string (buffer, "RaRBarriersOmitted "); 737 if (props & PR_UNDOLOGCODE) 738 pp_string (buffer, "undoLogCode "); 739 if (props & PR_PREFERUNINSTRUMENTED) 740 pp_string (buffer, "preferUninstrumented "); 741 if (props & PR_EXCEPTIONBLOCK) 742 pp_string (buffer, "exceptionBlock "); 743 if (props & PR_HASELSE) 744 pp_string (buffer, "hasElse "); 745 if (props & PR_READONLY) 746 pp_string (buffer, "readOnly "); 747 748 pp_string (buffer, "]"); 749 } 750 } 751 752 753 /* Dump the switch statement GS. BUFFER, SPC and FLAGS are as in 754 dump_gimple_stmt. */ 755 756 static void 757 dump_gimple_switch (pretty_printer *buffer, gimple gs, int spc, int flags) 758 { 759 unsigned int i; 760 761 GIMPLE_CHECK (gs, GIMPLE_SWITCH); 762 if (flags & TDF_RAW) 763 dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", gs, 764 gimple_switch_index (gs)); 765 else 766 { 767 pp_string (buffer, "switch ("); 768 dump_generic_node (buffer, gimple_switch_index (gs), spc, flags, true); 769 pp_string (buffer, ") <"); 770 } 771 772 for (i = 0; i < gimple_switch_num_labels (gs); i++) 773 { 774 tree case_label = gimple_switch_label (gs, i); 775 if (case_label == NULL_TREE) 776 continue; 777 778 dump_generic_node (buffer, case_label, spc, flags, false); 779 pp_character (buffer, ' '); 780 dump_generic_node (buffer, CASE_LABEL (case_label), spc, flags, false); 781 if (i < gimple_switch_num_labels (gs) - 1) 782 pp_string (buffer, ", "); 783 } 784 pp_character (buffer, '>'); 785 } 786 787 788 /* Dump the gimple conditional GS. BUFFER, SPC and FLAGS are as in 789 dump_gimple_stmt. */ 790 791 static void 792 dump_gimple_cond (pretty_printer *buffer, gimple gs, int spc, int flags) 793 { 794 if (flags & TDF_RAW) 795 dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs, 796 tree_code_name [gimple_cond_code (gs)], 797 gimple_cond_lhs (gs), gimple_cond_rhs (gs), 798 gimple_cond_true_label (gs), gimple_cond_false_label (gs)); 799 else 800 { 801 if (!(flags & TDF_RHS_ONLY)) 802 pp_string (buffer, "if ("); 803 dump_generic_node (buffer, gimple_cond_lhs (gs), spc, flags, false); 804 pp_space (buffer); 805 pp_string (buffer, op_symbol_code (gimple_cond_code (gs))); 806 pp_space (buffer); 807 dump_generic_node (buffer, gimple_cond_rhs (gs), spc, flags, false); 808 if (!(flags & TDF_RHS_ONLY)) 809 { 810 pp_character (buffer, ')'); 811 812 if (gimple_cond_true_label (gs)) 813 { 814 pp_string (buffer, " goto "); 815 dump_generic_node (buffer, gimple_cond_true_label (gs), 816 spc, flags, false); 817 pp_semicolon (buffer); 818 } 819 if (gimple_cond_false_label (gs)) 820 { 821 pp_string (buffer, " else goto "); 822 dump_generic_node (buffer, gimple_cond_false_label (gs), 823 spc, flags, false); 824 pp_semicolon (buffer); 825 } 826 } 827 } 828 } 829 830 831 /* Dump a GIMPLE_LABEL tuple on the pretty_printer BUFFER, SPC 832 spaces of indent. FLAGS specifies details to show in the dump (see 833 TDF_* in tree-pass.h). */ 834 835 static void 836 dump_gimple_label (pretty_printer *buffer, gimple gs, int spc, int flags) 837 { 838 tree label = gimple_label_label (gs); 839 if (flags & TDF_RAW) 840 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label); 841 else 842 { 843 dump_generic_node (buffer, label, spc, flags, false); 844 pp_character (buffer, ':'); 845 } 846 if (DECL_NONLOCAL (label)) 847 pp_string (buffer, " [non-local]"); 848 if ((flags & TDF_EH) && EH_LANDING_PAD_NR (label)) 849 pp_printf (buffer, " [LP %d]", EH_LANDING_PAD_NR (label)); 850 } 851 852 /* Dump a GIMPLE_GOTO tuple on the pretty_printer BUFFER, SPC 853 spaces of indent. FLAGS specifies details to show in the dump (see 854 TDF_* in tree-pass.h). */ 855 856 static void 857 dump_gimple_goto (pretty_printer *buffer, gimple gs, int spc, int flags) 858 { 859 tree label = gimple_goto_dest (gs); 860 if (flags & TDF_RAW) 861 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label); 862 else 863 dump_gimple_fmt (buffer, spc, flags, "goto %T;", label); 864 } 865 866 867 /* Dump a GIMPLE_BIND tuple on the pretty_printer BUFFER, SPC 868 spaces of indent. FLAGS specifies details to show in the dump (see 869 TDF_* in tree-pass.h). */ 870 871 static void 872 dump_gimple_bind (pretty_printer *buffer, gimple gs, int spc, int flags) 873 { 874 if (flags & TDF_RAW) 875 dump_gimple_fmt (buffer, spc, flags, "%G <", gs); 876 else 877 pp_character (buffer, '{'); 878 if (!(flags & TDF_SLIM)) 879 { 880 tree var; 881 882 for (var = gimple_bind_vars (gs); var; var = DECL_CHAIN (var)) 883 { 884 newline_and_indent (buffer, 2); 885 print_declaration (buffer, var, spc, flags); 886 } 887 if (gimple_bind_vars (gs)) 888 pp_newline (buffer); 889 } 890 pp_newline (buffer); 891 dump_gimple_seq (buffer, gimple_bind_body (gs), spc + 2, flags); 892 newline_and_indent (buffer, spc); 893 if (flags & TDF_RAW) 894 pp_character (buffer, '>'); 895 else 896 pp_character (buffer, '}'); 897 } 898 899 900 /* Dump a GIMPLE_TRY tuple on the pretty_printer BUFFER, SPC spaces of 901 indent. FLAGS specifies details to show in the dump (see TDF_* in 902 tree-pass.h). */ 903 904 static void 905 dump_gimple_try (pretty_printer *buffer, gimple gs, int spc, int flags) 906 { 907 if (flags & TDF_RAW) 908 { 909 const char *type; 910 if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH) 911 type = "GIMPLE_TRY_CATCH"; 912 else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY) 913 type = "GIMPLE_TRY_FINALLY"; 914 else 915 type = "UNKNOWN GIMPLE_TRY"; 916 dump_gimple_fmt (buffer, spc, flags, 917 "%G <%s,%+EVAL <%S>%nCLEANUP <%S>%->", gs, type, 918 gimple_try_eval (gs), gimple_try_cleanup (gs)); 919 } 920 else 921 { 922 pp_string (buffer, "try"); 923 newline_and_indent (buffer, spc + 2); 924 pp_character (buffer, '{'); 925 pp_newline (buffer); 926 927 dump_gimple_seq (buffer, gimple_try_eval (gs), spc + 4, flags); 928 newline_and_indent (buffer, spc + 2); 929 pp_character (buffer, '}'); 930 931 if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH) 932 { 933 newline_and_indent (buffer, spc); 934 pp_string (buffer, "catch"); 935 newline_and_indent (buffer, spc + 2); 936 pp_character (buffer, '{'); 937 } 938 else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY) 939 { 940 newline_and_indent (buffer, spc); 941 pp_string (buffer, "finally"); 942 newline_and_indent (buffer, spc + 2); 943 pp_character (buffer, '{'); 944 } 945 else 946 pp_string (buffer, " <UNKNOWN GIMPLE_TRY> {"); 947 948 pp_newline (buffer); 949 dump_gimple_seq (buffer, gimple_try_cleanup (gs), spc + 4, flags); 950 newline_and_indent (buffer, spc + 2); 951 pp_character (buffer, '}'); 952 } 953 } 954 955 956 /* Dump a GIMPLE_CATCH tuple on the pretty_printer BUFFER, SPC spaces of 957 indent. FLAGS specifies details to show in the dump (see TDF_* in 958 tree-pass.h). */ 959 960 static void 961 dump_gimple_catch (pretty_printer *buffer, gimple gs, int spc, int flags) 962 { 963 if (flags & TDF_RAW) 964 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+CATCH <%S>%->", gs, 965 gimple_catch_types (gs), gimple_catch_handler (gs)); 966 else 967 dump_gimple_fmt (buffer, spc, flags, "catch (%T)%+{%S}", 968 gimple_catch_types (gs), gimple_catch_handler (gs)); 969 } 970 971 972 /* Dump a GIMPLE_EH_FILTER tuple on the pretty_printer BUFFER, SPC spaces of 973 indent. FLAGS specifies details to show in the dump (see TDF_* in 974 tree-pass.h). */ 975 976 static void 977 dump_gimple_eh_filter (pretty_printer *buffer, gimple gs, int spc, int flags) 978 { 979 if (flags & TDF_RAW) 980 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+FAILURE <%S>%->", gs, 981 gimple_eh_filter_types (gs), 982 gimple_eh_filter_failure (gs)); 983 else 984 dump_gimple_fmt (buffer, spc, flags, "<<<eh_filter (%T)>>>%+{%+%S%-}", 985 gimple_eh_filter_types (gs), 986 gimple_eh_filter_failure (gs)); 987 } 988 989 990 /* Dump a GIMPLE_EH_MUST_NOT_THROW tuple. */ 991 992 static void 993 dump_gimple_eh_must_not_throw (pretty_printer *buffer, gimple gs, 994 int spc, int flags) 995 { 996 if (flags & TDF_RAW) 997 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, 998 gimple_eh_must_not_throw_fndecl (gs)); 999 else 1000 dump_gimple_fmt (buffer, spc, flags, "<<<eh_must_not_throw (%T)>>>", 1001 gimple_eh_must_not_throw_fndecl (gs)); 1002 } 1003 1004 1005 /* Dump a GIMPLE_EH_ELSE tuple on the pretty_printer BUFFER, SPC spaces of 1006 indent. FLAGS specifies details to show in the dump (see TDF_* in 1007 tree-pass.h). */ 1008 1009 static void 1010 dump_gimple_eh_else (pretty_printer *buffer, gimple gs, int spc, int flags) 1011 { 1012 if (flags & TDF_RAW) 1013 dump_gimple_fmt (buffer, spc, flags, 1014 "%G <%+N_BODY <%S>%nE_BODY <%S>%->", gs, 1015 gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs)); 1016 else 1017 dump_gimple_fmt (buffer, spc, flags, 1018 "<<<if_normal_exit>>>%+{%S}%-<<<else_eh_exit>>>%+{%S}", 1019 gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs)); 1020 } 1021 1022 1023 /* Dump a GIMPLE_RESX tuple on the pretty_printer BUFFER, SPC spaces of 1024 indent. FLAGS specifies details to show in the dump (see TDF_* in 1025 tree-pass.h). */ 1026 1027 static void 1028 dump_gimple_resx (pretty_printer *buffer, gimple gs, int spc, int flags) 1029 { 1030 if (flags & TDF_RAW) 1031 dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs, 1032 gimple_resx_region (gs)); 1033 else 1034 dump_gimple_fmt (buffer, spc, flags, "resx %d", gimple_resx_region (gs)); 1035 } 1036 1037 /* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer BUFFER. */ 1038 1039 static void 1040 dump_gimple_eh_dispatch (pretty_printer *buffer, gimple gs, int spc, int flags) 1041 { 1042 if (flags & TDF_RAW) 1043 dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs, 1044 gimple_eh_dispatch_region (gs)); 1045 else 1046 dump_gimple_fmt (buffer, spc, flags, "eh_dispatch %d", 1047 gimple_eh_dispatch_region (gs)); 1048 } 1049 1050 /* Dump a GIMPLE_DEBUG tuple on the pretty_printer BUFFER, SPC spaces 1051 of indent. FLAGS specifies details to show in the dump (see TDF_* 1052 in tree-pass.h). */ 1053 1054 static void 1055 dump_gimple_debug (pretty_printer *buffer, gimple gs, int spc, int flags) 1056 { 1057 switch (gs->gsbase.subcode) 1058 { 1059 case GIMPLE_DEBUG_BIND: 1060 if (flags & TDF_RAW) 1061 dump_gimple_fmt (buffer, spc, flags, "%G BIND <%T, %T>", gs, 1062 gimple_debug_bind_get_var (gs), 1063 gimple_debug_bind_get_value (gs)); 1064 else 1065 dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T => %T", 1066 gimple_debug_bind_get_var (gs), 1067 gimple_debug_bind_get_value (gs)); 1068 break; 1069 1070 case GIMPLE_DEBUG_SOURCE_BIND: 1071 if (flags & TDF_RAW) 1072 dump_gimple_fmt (buffer, spc, flags, "%G SRCBIND <%T, %T>", gs, 1073 gimple_debug_source_bind_get_var (gs), 1074 gimple_debug_source_bind_get_value (gs)); 1075 else 1076 dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T s=> %T", 1077 gimple_debug_source_bind_get_var (gs), 1078 gimple_debug_source_bind_get_value (gs)); 1079 break; 1080 1081 default: 1082 gcc_unreachable (); 1083 } 1084 } 1085 1086 /* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer BUFFER. */ 1087 static void 1088 dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags) 1089 { 1090 size_t i; 1091 1092 if (flags & TDF_RAW) 1093 { 1094 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, 1095 gimple_omp_body (gs)); 1096 dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags); 1097 dump_gimple_fmt (buffer, spc, flags, " >,"); 1098 for (i = 0; i < gimple_omp_for_collapse (gs); i++) 1099 dump_gimple_fmt (buffer, spc, flags, 1100 "%+%T, %T, %T, %s, %T,%n", 1101 gimple_omp_for_index (gs, i), 1102 gimple_omp_for_initial (gs, i), 1103 gimple_omp_for_final (gs, i), 1104 tree_code_name[gimple_omp_for_cond (gs, i)], 1105 gimple_omp_for_incr (gs, i)); 1106 dump_gimple_fmt (buffer, spc, flags, "PRE_BODY <%S>%->", 1107 gimple_omp_for_pre_body (gs)); 1108 } 1109 else 1110 { 1111 pp_string (buffer, "#pragma omp for"); 1112 dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags); 1113 for (i = 0; i < gimple_omp_for_collapse (gs); i++) 1114 { 1115 if (i) 1116 spc += 2; 1117 newline_and_indent (buffer, spc); 1118 pp_string (buffer, "for ("); 1119 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc, 1120 flags, false); 1121 pp_string (buffer, " = "); 1122 dump_generic_node (buffer, gimple_omp_for_initial (gs, i), spc, 1123 flags, false); 1124 pp_string (buffer, "; "); 1125 1126 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc, 1127 flags, false); 1128 pp_space (buffer); 1129 switch (gimple_omp_for_cond (gs, i)) 1130 { 1131 case LT_EXPR: 1132 pp_character (buffer, '<'); 1133 break; 1134 case GT_EXPR: 1135 pp_character (buffer, '>'); 1136 break; 1137 case LE_EXPR: 1138 pp_string (buffer, "<="); 1139 break; 1140 case GE_EXPR: 1141 pp_string (buffer, ">="); 1142 break; 1143 default: 1144 gcc_unreachable (); 1145 } 1146 pp_space (buffer); 1147 dump_generic_node (buffer, gimple_omp_for_final (gs, i), spc, 1148 flags, false); 1149 pp_string (buffer, "; "); 1150 1151 dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc, 1152 flags, false); 1153 pp_string (buffer, " = "); 1154 dump_generic_node (buffer, gimple_omp_for_incr (gs, i), spc, 1155 flags, false); 1156 pp_character (buffer, ')'); 1157 } 1158 1159 if (!gimple_seq_empty_p (gimple_omp_body (gs))) 1160 { 1161 newline_and_indent (buffer, spc + 2); 1162 pp_character (buffer, '{'); 1163 pp_newline (buffer); 1164 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); 1165 newline_and_indent (buffer, spc + 2); 1166 pp_character (buffer, '}'); 1167 } 1168 } 1169 } 1170 1171 /* Dump a GIMPLE_OMP_CONTINUE tuple on the pretty_printer BUFFER. */ 1172 1173 static void 1174 dump_gimple_omp_continue (pretty_printer *buffer, gimple gs, int spc, int flags) 1175 { 1176 if (flags & TDF_RAW) 1177 { 1178 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs, 1179 gimple_omp_continue_control_def (gs), 1180 gimple_omp_continue_control_use (gs)); 1181 } 1182 else 1183 { 1184 pp_string (buffer, "#pragma omp continue ("); 1185 dump_generic_node (buffer, gimple_omp_continue_control_def (gs), 1186 spc, flags, false); 1187 pp_character (buffer, ','); 1188 pp_space (buffer); 1189 dump_generic_node (buffer, gimple_omp_continue_control_use (gs), 1190 spc, flags, false); 1191 pp_character (buffer, ')'); 1192 } 1193 } 1194 1195 /* Dump a GIMPLE_OMP_SINGLE tuple on the pretty_printer BUFFER. */ 1196 1197 static void 1198 dump_gimple_omp_single (pretty_printer *buffer, gimple gs, int spc, int flags) 1199 { 1200 if (flags & TDF_RAW) 1201 { 1202 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, 1203 gimple_omp_body (gs)); 1204 dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags); 1205 dump_gimple_fmt (buffer, spc, flags, " >"); 1206 } 1207 else 1208 { 1209 pp_string (buffer, "#pragma omp single"); 1210 dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags); 1211 if (!gimple_seq_empty_p (gimple_omp_body (gs))) 1212 { 1213 newline_and_indent (buffer, spc + 2); 1214 pp_character (buffer, '{'); 1215 pp_newline (buffer); 1216 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); 1217 newline_and_indent (buffer, spc + 2); 1218 pp_character (buffer, '}'); 1219 } 1220 } 1221 } 1222 1223 /* Dump a GIMPLE_OMP_SECTIONS tuple on the pretty_printer BUFFER. */ 1224 1225 static void 1226 dump_gimple_omp_sections (pretty_printer *buffer, gimple gs, int spc, 1227 int flags) 1228 { 1229 if (flags & TDF_RAW) 1230 { 1231 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, 1232 gimple_omp_body (gs)); 1233 dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags); 1234 dump_gimple_fmt (buffer, spc, flags, " >"); 1235 } 1236 else 1237 { 1238 pp_string (buffer, "#pragma omp sections"); 1239 if (gimple_omp_sections_control (gs)) 1240 { 1241 pp_string (buffer, " <"); 1242 dump_generic_node (buffer, gimple_omp_sections_control (gs), spc, 1243 flags, false); 1244 pp_character (buffer, '>'); 1245 } 1246 dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags); 1247 if (!gimple_seq_empty_p (gimple_omp_body (gs))) 1248 { 1249 newline_and_indent (buffer, spc + 2); 1250 pp_character (buffer, '{'); 1251 pp_newline (buffer); 1252 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); 1253 newline_and_indent (buffer, spc + 2); 1254 pp_character (buffer, '}'); 1255 } 1256 } 1257 } 1258 1259 /* Dump a GIMPLE_OMP_{MASTER,ORDERED,SECTION} tuple on the pretty_printer 1260 BUFFER. */ 1261 1262 static void 1263 dump_gimple_omp_block (pretty_printer *buffer, gimple gs, int spc, int flags) 1264 { 1265 if (flags & TDF_RAW) 1266 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs, 1267 gimple_omp_body (gs)); 1268 else 1269 { 1270 switch (gimple_code (gs)) 1271 { 1272 case GIMPLE_OMP_MASTER: 1273 pp_string (buffer, "#pragma omp master"); 1274 break; 1275 case GIMPLE_OMP_ORDERED: 1276 pp_string (buffer, "#pragma omp ordered"); 1277 break; 1278 case GIMPLE_OMP_SECTION: 1279 pp_string (buffer, "#pragma omp section"); 1280 break; 1281 default: 1282 gcc_unreachable (); 1283 } 1284 if (!gimple_seq_empty_p (gimple_omp_body (gs))) 1285 { 1286 newline_and_indent (buffer, spc + 2); 1287 pp_character (buffer, '{'); 1288 pp_newline (buffer); 1289 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); 1290 newline_and_indent (buffer, spc + 2); 1291 pp_character (buffer, '}'); 1292 } 1293 } 1294 } 1295 1296 /* Dump a GIMPLE_OMP_CRITICAL tuple on the pretty_printer BUFFER. */ 1297 1298 static void 1299 dump_gimple_omp_critical (pretty_printer *buffer, gimple gs, int spc, 1300 int flags) 1301 { 1302 if (flags & TDF_RAW) 1303 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs, 1304 gimple_omp_body (gs)); 1305 else 1306 { 1307 pp_string (buffer, "#pragma omp critical"); 1308 if (gimple_omp_critical_name (gs)) 1309 { 1310 pp_string (buffer, " ("); 1311 dump_generic_node (buffer, gimple_omp_critical_name (gs), spc, 1312 flags, false); 1313 pp_character (buffer, ')'); 1314 } 1315 if (!gimple_seq_empty_p (gimple_omp_body (gs))) 1316 { 1317 newline_and_indent (buffer, spc + 2); 1318 pp_character (buffer, '{'); 1319 pp_newline (buffer); 1320 dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); 1321 newline_and_indent (buffer, spc + 2); 1322 pp_character (buffer, '}'); 1323 } 1324 } 1325 } 1326 1327 /* Dump a GIMPLE_OMP_RETURN tuple on the pretty_printer BUFFER. */ 1328 1329 static void 1330 dump_gimple_omp_return (pretty_printer *buffer, gimple gs, int spc, int flags) 1331 { 1332 if (flags & TDF_RAW) 1333 { 1334 dump_gimple_fmt (buffer, spc, flags, "%G <nowait=%d>", gs, 1335 (int) gimple_omp_return_nowait_p (gs)); 1336 } 1337 else 1338 { 1339 pp_string (buffer, "#pragma omp return"); 1340 if (gimple_omp_return_nowait_p (gs)) 1341 pp_string (buffer, "(nowait)"); 1342 } 1343 } 1344 1345 /* Dump a GIMPLE_TRANSACTION tuple on the pretty_printer BUFFER. */ 1346 1347 static void 1348 dump_gimple_transaction (pretty_printer *buffer, gimple gs, int spc, int flags) 1349 { 1350 unsigned subcode = gimple_transaction_subcode (gs); 1351 1352 if (flags & TDF_RAW) 1353 { 1354 dump_gimple_fmt (buffer, spc, flags, 1355 "%G [SUBCODE=%x,LABEL=%T] <%+BODY <%S> >", 1356 gs, subcode, gimple_transaction_label (gs), 1357 gimple_transaction_body (gs)); 1358 } 1359 else 1360 { 1361 if (subcode & GTMA_IS_OUTER) 1362 pp_string (buffer, "__transaction_atomic [[outer]]"); 1363 else if (subcode & GTMA_IS_RELAXED) 1364 pp_string (buffer, "__transaction_relaxed"); 1365 else 1366 pp_string (buffer, "__transaction_atomic"); 1367 subcode &= ~GTMA_DECLARATION_MASK; 1368 1369 if (subcode || gimple_transaction_label (gs)) 1370 { 1371 pp_string (buffer, " //"); 1372 if (gimple_transaction_label (gs)) 1373 { 1374 pp_string (buffer, " LABEL="); 1375 dump_generic_node (buffer, gimple_transaction_label (gs), 1376 spc, flags, false); 1377 } 1378 if (subcode) 1379 { 1380 pp_string (buffer, " SUBCODE=[ "); 1381 if (subcode & GTMA_HAVE_ABORT) 1382 { 1383 pp_string (buffer, "GTMA_HAVE_ABORT "); 1384 subcode &= ~GTMA_HAVE_ABORT; 1385 } 1386 if (subcode & GTMA_HAVE_LOAD) 1387 { 1388 pp_string (buffer, "GTMA_HAVE_LOAD "); 1389 subcode &= ~GTMA_HAVE_LOAD; 1390 } 1391 if (subcode & GTMA_HAVE_STORE) 1392 { 1393 pp_string (buffer, "GTMA_HAVE_STORE "); 1394 subcode &= ~GTMA_HAVE_STORE; 1395 } 1396 if (subcode & GTMA_MAY_ENTER_IRREVOCABLE) 1397 { 1398 pp_string (buffer, "GTMA_MAY_ENTER_IRREVOCABLE "); 1399 subcode &= ~GTMA_MAY_ENTER_IRREVOCABLE; 1400 } 1401 if (subcode & GTMA_DOES_GO_IRREVOCABLE) 1402 { 1403 pp_string (buffer, "GTMA_DOES_GO_IRREVOCABLE "); 1404 subcode &= ~GTMA_DOES_GO_IRREVOCABLE; 1405 } 1406 if (subcode) 1407 pp_printf (buffer, "0x%x ", subcode); 1408 pp_string (buffer, "]"); 1409 } 1410 } 1411 1412 if (!gimple_seq_empty_p (gimple_transaction_body (gs))) 1413 { 1414 newline_and_indent (buffer, spc + 2); 1415 pp_character (buffer, '{'); 1416 pp_newline (buffer); 1417 dump_gimple_seq (buffer, gimple_transaction_body (gs), 1418 spc + 4, flags); 1419 newline_and_indent (buffer, spc + 2); 1420 pp_character (buffer, '}'); 1421 } 1422 } 1423 } 1424 1425 /* Dump a GIMPLE_ASM tuple on the pretty_printer BUFFER, SPC spaces of 1426 indent. FLAGS specifies details to show in the dump (see TDF_* in 1427 tree-pass.h). */ 1428 1429 static void 1430 dump_gimple_asm (pretty_printer *buffer, gimple gs, int spc, int flags) 1431 { 1432 unsigned int i, n, f, fields; 1433 1434 if (flags & TDF_RAW) 1435 { 1436 dump_gimple_fmt (buffer, spc, flags, "%G <%+STRING <%n%s%n>", gs, 1437 gimple_asm_string (gs)); 1438 1439 n = gimple_asm_noutputs (gs); 1440 if (n) 1441 { 1442 newline_and_indent (buffer, spc + 2); 1443 pp_string (buffer, "OUTPUT: "); 1444 for (i = 0; i < n; i++) 1445 { 1446 dump_generic_node (buffer, gimple_asm_output_op (gs, i), 1447 spc, flags, false); 1448 if (i < n - 1) 1449 pp_string (buffer, ", "); 1450 } 1451 } 1452 1453 n = gimple_asm_ninputs (gs); 1454 if (n) 1455 { 1456 newline_and_indent (buffer, spc + 2); 1457 pp_string (buffer, "INPUT: "); 1458 for (i = 0; i < n; i++) 1459 { 1460 dump_generic_node (buffer, gimple_asm_input_op (gs, i), 1461 spc, flags, false); 1462 if (i < n - 1) 1463 pp_string (buffer, ", "); 1464 } 1465 } 1466 1467 n = gimple_asm_nclobbers (gs); 1468 if (n) 1469 { 1470 newline_and_indent (buffer, spc + 2); 1471 pp_string (buffer, "CLOBBER: "); 1472 for (i = 0; i < n; i++) 1473 { 1474 dump_generic_node (buffer, gimple_asm_clobber_op (gs, i), 1475 spc, flags, false); 1476 if (i < n - 1) 1477 pp_string (buffer, ", "); 1478 } 1479 } 1480 1481 n = gimple_asm_nlabels (gs); 1482 if (n) 1483 { 1484 newline_and_indent (buffer, spc + 2); 1485 pp_string (buffer, "LABEL: "); 1486 for (i = 0; i < n; i++) 1487 { 1488 dump_generic_node (buffer, gimple_asm_label_op (gs, i), 1489 spc, flags, false); 1490 if (i < n - 1) 1491 pp_string (buffer, ", "); 1492 } 1493 } 1494 1495 newline_and_indent (buffer, spc); 1496 pp_character (buffer, '>'); 1497 } 1498 else 1499 { 1500 pp_string (buffer, "__asm__"); 1501 if (gimple_asm_volatile_p (gs)) 1502 pp_string (buffer, " __volatile__"); 1503 if (gimple_asm_nlabels (gs)) 1504 pp_string (buffer, " goto"); 1505 pp_string (buffer, "(\""); 1506 pp_string (buffer, gimple_asm_string (gs)); 1507 pp_string (buffer, "\""); 1508 1509 if (gimple_asm_nlabels (gs)) 1510 fields = 4; 1511 else if (gimple_asm_nclobbers (gs)) 1512 fields = 3; 1513 else if (gimple_asm_ninputs (gs)) 1514 fields = 2; 1515 else if (gimple_asm_noutputs (gs)) 1516 fields = 1; 1517 else 1518 fields = 0; 1519 1520 for (f = 0; f < fields; ++f) 1521 { 1522 pp_string (buffer, " : "); 1523 1524 switch (f) 1525 { 1526 case 0: 1527 n = gimple_asm_noutputs (gs); 1528 for (i = 0; i < n; i++) 1529 { 1530 dump_generic_node (buffer, gimple_asm_output_op (gs, i), 1531 spc, flags, false); 1532 if (i < n - 1) 1533 pp_string (buffer, ", "); 1534 } 1535 break; 1536 1537 case 1: 1538 n = gimple_asm_ninputs (gs); 1539 for (i = 0; i < n; i++) 1540 { 1541 dump_generic_node (buffer, gimple_asm_input_op (gs, i), 1542 spc, flags, false); 1543 if (i < n - 1) 1544 pp_string (buffer, ", "); 1545 } 1546 break; 1547 1548 case 2: 1549 n = gimple_asm_nclobbers (gs); 1550 for (i = 0; i < n; i++) 1551 { 1552 dump_generic_node (buffer, gimple_asm_clobber_op (gs, i), 1553 spc, flags, false); 1554 if (i < n - 1) 1555 pp_string (buffer, ", "); 1556 } 1557 break; 1558 1559 case 3: 1560 n = gimple_asm_nlabels (gs); 1561 for (i = 0; i < n; i++) 1562 { 1563 dump_generic_node (buffer, gimple_asm_label_op (gs, i), 1564 spc, flags, false); 1565 if (i < n - 1) 1566 pp_string (buffer, ", "); 1567 } 1568 break; 1569 1570 default: 1571 gcc_unreachable (); 1572 } 1573 } 1574 1575 pp_string (buffer, ");"); 1576 } 1577 } 1578 1579 1580 /* Dump a PHI node PHI. BUFFER, SPC and FLAGS are as in 1581 dump_gimple_stmt. */ 1582 1583 static void 1584 dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, int flags) 1585 { 1586 size_t i; 1587 tree lhs = gimple_phi_result (phi); 1588 1589 if (flags & TDF_ALIAS 1590 && POINTER_TYPE_P (TREE_TYPE (lhs)) 1591 && SSA_NAME_PTR_INFO (lhs)) 1592 { 1593 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (lhs); 1594 pp_string (buffer, "PT = "); 1595 pp_points_to_solution (buffer, &pi->pt); 1596 newline_and_indent (buffer, spc); 1597 if (pi->align != 1) 1598 { 1599 pp_printf (buffer, "# ALIGN = %u, MISALIGN = %u", 1600 pi->align, pi->misalign); 1601 newline_and_indent (buffer, spc); 1602 } 1603 pp_string (buffer, "# "); 1604 } 1605 1606 if (flags & TDF_RAW) 1607 dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", phi, 1608 gimple_phi_result (phi)); 1609 else 1610 { 1611 dump_generic_node (buffer, lhs, spc, flags, false); 1612 pp_string (buffer, " = PHI <"); 1613 } 1614 for (i = 0; i < gimple_phi_num_args (phi); i++) 1615 { 1616 if ((flags & TDF_LINENO) && gimple_phi_arg_has_location (phi, i)) 1617 { 1618 expanded_location xloc; 1619 1620 xloc = expand_location (gimple_phi_arg_location (phi, i)); 1621 pp_character (buffer, '['); 1622 if (xloc.file) 1623 { 1624 pp_string (buffer, xloc.file); 1625 pp_string (buffer, " : "); 1626 } 1627 pp_decimal_int (buffer, xloc.line); 1628 pp_string (buffer, ":"); 1629 pp_decimal_int (buffer, xloc.column); 1630 pp_string (buffer, "] "); 1631 } 1632 dump_generic_node (buffer, gimple_phi_arg_def (phi, i), spc, flags, 1633 false); 1634 pp_character (buffer, '('); 1635 pp_decimal_int (buffer, gimple_phi_arg_edge (phi, i)->src->index); 1636 pp_character (buffer, ')'); 1637 if (i < gimple_phi_num_args (phi) - 1) 1638 pp_string (buffer, ", "); 1639 } 1640 pp_character (buffer, '>'); 1641 } 1642 1643 1644 /* Dump a GIMPLE_OMP_PARALLEL tuple on the pretty_printer BUFFER, SPC spaces 1645 of indent. FLAGS specifies details to show in the dump (see TDF_* in 1646 tree-pass.h). */ 1647 1648 static void 1649 dump_gimple_omp_parallel (pretty_printer *buffer, gimple gs, int spc, 1650 int flags) 1651 { 1652 if (flags & TDF_RAW) 1653 { 1654 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, 1655 gimple_omp_body (gs)); 1656 dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags); 1657 dump_gimple_fmt (buffer, spc, flags, " >, %T, %T%n>", 1658 gimple_omp_parallel_child_fn (gs), 1659 gimple_omp_parallel_data_arg (gs)); 1660 } 1661 else 1662 { 1663 gimple_seq body; 1664 pp_string (buffer, "#pragma omp parallel"); 1665 dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags); 1666 if (gimple_omp_parallel_child_fn (gs)) 1667 { 1668 pp_string (buffer, " [child fn: "); 1669 dump_generic_node (buffer, gimple_omp_parallel_child_fn (gs), 1670 spc, flags, false); 1671 pp_string (buffer, " ("); 1672 if (gimple_omp_parallel_data_arg (gs)) 1673 dump_generic_node (buffer, gimple_omp_parallel_data_arg (gs), 1674 spc, flags, false); 1675 else 1676 pp_string (buffer, "???"); 1677 pp_string (buffer, ")]"); 1678 } 1679 body = gimple_omp_body (gs); 1680 if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND) 1681 { 1682 newline_and_indent (buffer, spc + 2); 1683 pp_character (buffer, '{'); 1684 pp_newline (buffer); 1685 dump_gimple_seq (buffer, body, spc + 4, flags); 1686 newline_and_indent (buffer, spc + 2); 1687 pp_character (buffer, '}'); 1688 } 1689 else if (body) 1690 { 1691 pp_newline (buffer); 1692 dump_gimple_seq (buffer, body, spc + 2, flags); 1693 } 1694 } 1695 } 1696 1697 1698 /* Dump a GIMPLE_OMP_TASK tuple on the pretty_printer BUFFER, SPC spaces 1699 of indent. FLAGS specifies details to show in the dump (see TDF_* in 1700 tree-pass.h). */ 1701 1702 static void 1703 dump_gimple_omp_task (pretty_printer *buffer, gimple gs, int spc, 1704 int flags) 1705 { 1706 if (flags & TDF_RAW) 1707 { 1708 dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, 1709 gimple_omp_body (gs)); 1710 dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags); 1711 dump_gimple_fmt (buffer, spc, flags, " >, %T, %T, %T, %T, %T%n>", 1712 gimple_omp_task_child_fn (gs), 1713 gimple_omp_task_data_arg (gs), 1714 gimple_omp_task_copy_fn (gs), 1715 gimple_omp_task_arg_size (gs), 1716 gimple_omp_task_arg_size (gs)); 1717 } 1718 else 1719 { 1720 gimple_seq body; 1721 pp_string (buffer, "#pragma omp task"); 1722 dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags); 1723 if (gimple_omp_task_child_fn (gs)) 1724 { 1725 pp_string (buffer, " [child fn: "); 1726 dump_generic_node (buffer, gimple_omp_task_child_fn (gs), 1727 spc, flags, false); 1728 pp_string (buffer, " ("); 1729 if (gimple_omp_task_data_arg (gs)) 1730 dump_generic_node (buffer, gimple_omp_task_data_arg (gs), 1731 spc, flags, false); 1732 else 1733 pp_string (buffer, "???"); 1734 pp_string (buffer, ")]"); 1735 } 1736 body = gimple_omp_body (gs); 1737 if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND) 1738 { 1739 newline_and_indent (buffer, spc + 2); 1740 pp_character (buffer, '{'); 1741 pp_newline (buffer); 1742 dump_gimple_seq (buffer, body, spc + 4, flags); 1743 newline_and_indent (buffer, spc + 2); 1744 pp_character (buffer, '}'); 1745 } 1746 else if (body) 1747 { 1748 pp_newline (buffer); 1749 dump_gimple_seq (buffer, body, spc + 2, flags); 1750 } 1751 } 1752 } 1753 1754 1755 /* Dump a GIMPLE_OMP_ATOMIC_LOAD tuple on the pretty_printer BUFFER, SPC 1756 spaces of indent. FLAGS specifies details to show in the dump (see TDF_* 1757 in tree-pass.h). */ 1758 1759 static void 1760 dump_gimple_omp_atomic_load (pretty_printer *buffer, gimple gs, int spc, 1761 int flags) 1762 { 1763 if (flags & TDF_RAW) 1764 { 1765 dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs, 1766 gimple_omp_atomic_load_lhs (gs), 1767 gimple_omp_atomic_load_rhs (gs)); 1768 } 1769 else 1770 { 1771 pp_string (buffer, "#pragma omp atomic_load"); 1772 if (gimple_omp_atomic_need_value_p (gs)) 1773 pp_string (buffer, " [needed]"); 1774 newline_and_indent (buffer, spc + 2); 1775 dump_generic_node (buffer, gimple_omp_atomic_load_lhs (gs), 1776 spc, flags, false); 1777 pp_space (buffer); 1778 pp_character (buffer, '='); 1779 pp_space (buffer); 1780 pp_character (buffer, '*'); 1781 dump_generic_node (buffer, gimple_omp_atomic_load_rhs (gs), 1782 spc, flags, false); 1783 } 1784 } 1785 1786 /* Dump a GIMPLE_OMP_ATOMIC_STORE tuple on the pretty_printer BUFFER, SPC 1787 spaces of indent. FLAGS specifies details to show in the dump (see TDF_* 1788 in tree-pass.h). */ 1789 1790 static void 1791 dump_gimple_omp_atomic_store (pretty_printer *buffer, gimple gs, int spc, 1792 int flags) 1793 { 1794 if (flags & TDF_RAW) 1795 { 1796 dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, 1797 gimple_omp_atomic_store_val (gs)); 1798 } 1799 else 1800 { 1801 pp_string (buffer, "#pragma omp atomic_store "); 1802 if (gimple_omp_atomic_need_value_p (gs)) 1803 pp_string (buffer, "[needed] "); 1804 pp_character (buffer, '('); 1805 dump_generic_node (buffer, gimple_omp_atomic_store_val (gs), 1806 spc, flags, false); 1807 pp_character (buffer, ')'); 1808 } 1809 } 1810 1811 1812 /* Dump all the memory operands for statement GS. BUFFER, SPC and 1813 FLAGS are as in dump_gimple_stmt. */ 1814 1815 static void 1816 dump_gimple_mem_ops (pretty_printer *buffer, gimple gs, int spc, int flags) 1817 { 1818 tree vdef = gimple_vdef (gs); 1819 tree vuse = gimple_vuse (gs); 1820 1821 if (!ssa_operands_active () || !gimple_references_memory_p (gs)) 1822 return; 1823 1824 if (vdef != NULL_TREE) 1825 { 1826 pp_string (buffer, "# "); 1827 dump_generic_node (buffer, vdef, spc + 2, flags, false); 1828 pp_string (buffer, " = VDEF <"); 1829 dump_generic_node (buffer, vuse, spc + 2, flags, false); 1830 pp_character (buffer, '>'); 1831 newline_and_indent (buffer, spc); 1832 } 1833 else if (vuse != NULL_TREE) 1834 { 1835 pp_string (buffer, "# VUSE <"); 1836 dump_generic_node (buffer, vuse, spc + 2, flags, false); 1837 pp_character (buffer, '>'); 1838 newline_and_indent (buffer, spc); 1839 } 1840 } 1841 1842 1843 /* Dump the gimple statement GS on the pretty printer BUFFER, SPC 1844 spaces of indent. FLAGS specifies details to show in the dump (see 1845 TDF_* in tree-pass.h). */ 1846 1847 void 1848 dump_gimple_stmt (pretty_printer *buffer, gimple gs, int spc, int flags) 1849 { 1850 if (!gs) 1851 return; 1852 1853 if (flags & TDF_STMTADDR) 1854 pp_printf (buffer, "<&%p> ", (void *) gs); 1855 1856 if ((flags & TDF_LINENO) && gimple_has_location (gs)) 1857 { 1858 expanded_location xloc = expand_location (gimple_location (gs)); 1859 pp_character (buffer, '['); 1860 if (xloc.file) 1861 { 1862 pp_string (buffer, xloc.file); 1863 pp_string (buffer, " : "); 1864 } 1865 pp_decimal_int (buffer, xloc.line); 1866 pp_string (buffer, ":"); 1867 pp_decimal_int (buffer, xloc.column); 1868 pp_string (buffer, "] "); 1869 } 1870 1871 if (flags & TDF_EH) 1872 { 1873 int lp_nr = lookup_stmt_eh_lp (gs); 1874 if (lp_nr > 0) 1875 pp_printf (buffer, "[LP %d] ", lp_nr); 1876 else if (lp_nr < 0) 1877 pp_printf (buffer, "[MNT %d] ", -lp_nr); 1878 } 1879 1880 if ((flags & (TDF_VOPS|TDF_MEMSYMS)) 1881 && gimple_has_mem_ops (gs)) 1882 dump_gimple_mem_ops (buffer, gs, spc, flags); 1883 1884 if ((flags & TDF_ALIAS) 1885 && gimple_has_lhs (gs)) 1886 { 1887 tree lhs = gimple_get_lhs (gs); 1888 if (TREE_CODE (lhs) == SSA_NAME 1889 && POINTER_TYPE_P (TREE_TYPE (lhs)) 1890 && SSA_NAME_PTR_INFO (lhs)) 1891 { 1892 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (lhs); 1893 pp_string (buffer, "# PT = "); 1894 pp_points_to_solution (buffer, &pi->pt); 1895 newline_and_indent (buffer, spc); 1896 if (pi->align != 1) 1897 { 1898 pp_printf (buffer, "# ALIGN = %u, MISALIGN = %u", 1899 pi->align, pi->misalign); 1900 newline_and_indent (buffer, spc); 1901 } 1902 } 1903 } 1904 1905 switch (gimple_code (gs)) 1906 { 1907 case GIMPLE_ASM: 1908 dump_gimple_asm (buffer, gs, spc, flags); 1909 break; 1910 1911 case GIMPLE_ASSIGN: 1912 dump_gimple_assign (buffer, gs, spc, flags); 1913 break; 1914 1915 case GIMPLE_BIND: 1916 dump_gimple_bind (buffer, gs, spc, flags); 1917 break; 1918 1919 case GIMPLE_CALL: 1920 dump_gimple_call (buffer, gs, spc, flags); 1921 break; 1922 1923 case GIMPLE_COND: 1924 dump_gimple_cond (buffer, gs, spc, flags); 1925 break; 1926 1927 case GIMPLE_LABEL: 1928 dump_gimple_label (buffer, gs, spc, flags); 1929 break; 1930 1931 case GIMPLE_GOTO: 1932 dump_gimple_goto (buffer, gs, spc, flags); 1933 break; 1934 1935 case GIMPLE_NOP: 1936 pp_string (buffer, "GIMPLE_NOP"); 1937 break; 1938 1939 case GIMPLE_RETURN: 1940 dump_gimple_return (buffer, gs, spc, flags); 1941 break; 1942 1943 case GIMPLE_SWITCH: 1944 dump_gimple_switch (buffer, gs, spc, flags); 1945 break; 1946 1947 case GIMPLE_TRY: 1948 dump_gimple_try (buffer, gs, spc, flags); 1949 break; 1950 1951 case GIMPLE_PHI: 1952 dump_gimple_phi (buffer, gs, spc, flags); 1953 break; 1954 1955 case GIMPLE_OMP_PARALLEL: 1956 dump_gimple_omp_parallel (buffer, gs, spc, flags); 1957 break; 1958 1959 case GIMPLE_OMP_TASK: 1960 dump_gimple_omp_task (buffer, gs, spc, flags); 1961 break; 1962 1963 case GIMPLE_OMP_ATOMIC_LOAD: 1964 dump_gimple_omp_atomic_load (buffer, gs, spc, flags); 1965 1966 break; 1967 1968 case GIMPLE_OMP_ATOMIC_STORE: 1969 dump_gimple_omp_atomic_store (buffer, gs, spc, flags); 1970 break; 1971 1972 case GIMPLE_OMP_FOR: 1973 dump_gimple_omp_for (buffer, gs, spc, flags); 1974 break; 1975 1976 case GIMPLE_OMP_CONTINUE: 1977 dump_gimple_omp_continue (buffer, gs, spc, flags); 1978 break; 1979 1980 case GIMPLE_OMP_SINGLE: 1981 dump_gimple_omp_single (buffer, gs, spc, flags); 1982 break; 1983 1984 case GIMPLE_OMP_RETURN: 1985 dump_gimple_omp_return (buffer, gs, spc, flags); 1986 break; 1987 1988 case GIMPLE_OMP_SECTIONS: 1989 dump_gimple_omp_sections (buffer, gs, spc, flags); 1990 break; 1991 1992 case GIMPLE_OMP_SECTIONS_SWITCH: 1993 pp_string (buffer, "GIMPLE_SECTIONS_SWITCH"); 1994 break; 1995 1996 case GIMPLE_OMP_MASTER: 1997 case GIMPLE_OMP_ORDERED: 1998 case GIMPLE_OMP_SECTION: 1999 dump_gimple_omp_block (buffer, gs, spc, flags); 2000 break; 2001 2002 case GIMPLE_OMP_CRITICAL: 2003 dump_gimple_omp_critical (buffer, gs, spc, flags); 2004 break; 2005 2006 case GIMPLE_CATCH: 2007 dump_gimple_catch (buffer, gs, spc, flags); 2008 break; 2009 2010 case GIMPLE_EH_FILTER: 2011 dump_gimple_eh_filter (buffer, gs, spc, flags); 2012 break; 2013 2014 case GIMPLE_EH_MUST_NOT_THROW: 2015 dump_gimple_eh_must_not_throw (buffer, gs, spc, flags); 2016 break; 2017 2018 case GIMPLE_EH_ELSE: 2019 dump_gimple_eh_else (buffer, gs, spc, flags); 2020 break; 2021 2022 case GIMPLE_RESX: 2023 dump_gimple_resx (buffer, gs, spc, flags); 2024 break; 2025 2026 case GIMPLE_EH_DISPATCH: 2027 dump_gimple_eh_dispatch (buffer, gs, spc, flags); 2028 break; 2029 2030 case GIMPLE_DEBUG: 2031 dump_gimple_debug (buffer, gs, spc, flags); 2032 break; 2033 2034 case GIMPLE_PREDICT: 2035 pp_string (buffer, "// predicted "); 2036 if (gimple_predict_outcome (gs)) 2037 pp_string (buffer, "likely by "); 2038 else 2039 pp_string (buffer, "unlikely by "); 2040 pp_string (buffer, predictor_name (gimple_predict_predictor (gs))); 2041 pp_string (buffer, " predictor."); 2042 break; 2043 2044 case GIMPLE_TRANSACTION: 2045 dump_gimple_transaction (buffer, gs, spc, flags); 2046 break; 2047 2048 default: 2049 GIMPLE_NIY; 2050 } 2051 2052 /* If we're building a diagnostic, the formatted text will be 2053 written into BUFFER's stream by the caller; otherwise, write it 2054 now. */ 2055 if (!(flags & TDF_DIAGNOSTIC)) 2056 pp_write_text_to_stream (buffer); 2057 } 2058 2059 2060 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT 2061 spaces and details described by flags. */ 2062 2063 static void 2064 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags) 2065 { 2066 edge e; 2067 gimple stmt; 2068 edge_iterator ei; 2069 2070 if (flags & TDF_BLOCKS) 2071 { 2072 INDENT (indent); 2073 pp_string (buffer, "# BLOCK "); 2074 pp_decimal_int (buffer, bb->index); 2075 if (bb->frequency) 2076 { 2077 pp_string (buffer, " freq:"); 2078 pp_decimal_int (buffer, bb->frequency); 2079 } 2080 if (bb->count) 2081 { 2082 pp_string (buffer, " count:"); 2083 pp_widest_integer (buffer, bb->count); 2084 } 2085 2086 if (flags & TDF_LINENO) 2087 { 2088 gimple_stmt_iterator gsi; 2089 2090 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 2091 if (!is_gimple_debug (gsi_stmt (gsi)) 2092 && get_lineno (gsi_stmt (gsi)) != UNKNOWN_LOCATION) 2093 { 2094 pp_string (buffer, ", starting at line "); 2095 pp_decimal_int (buffer, get_lineno (gsi_stmt (gsi))); 2096 break; 2097 } 2098 2099 if (bb->discriminator) 2100 { 2101 pp_string (buffer, ", discriminator "); 2102 pp_decimal_int (buffer, bb->discriminator); 2103 } 2104 } 2105 newline_and_indent (buffer, indent); 2106 2107 pp_string (buffer, "# PRED:"); 2108 pp_write_text_to_stream (buffer); 2109 FOR_EACH_EDGE (e, ei, bb->preds) 2110 if (flags & TDF_SLIM) 2111 { 2112 pp_character (buffer, ' '); 2113 if (e->src == ENTRY_BLOCK_PTR) 2114 pp_string (buffer, "ENTRY"); 2115 else 2116 pp_decimal_int (buffer, e->src->index); 2117 } 2118 else 2119 dump_edge_info (buffer->buffer->stream, e, 0); 2120 pp_newline (buffer); 2121 } 2122 else 2123 { 2124 stmt = first_stmt (bb); 2125 if (!stmt || gimple_code (stmt) != GIMPLE_LABEL) 2126 { 2127 INDENT (indent - 2); 2128 pp_string (buffer, "<bb "); 2129 pp_decimal_int (buffer, bb->index); 2130 pp_string (buffer, ">:"); 2131 pp_newline (buffer); 2132 } 2133 } 2134 pp_write_text_to_stream (buffer); 2135 if (cfun) 2136 check_bb_profile (bb, buffer->buffer->stream); 2137 } 2138 2139 2140 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT 2141 spaces. */ 2142 2143 static void 2144 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags) 2145 { 2146 edge e; 2147 edge_iterator ei; 2148 2149 INDENT (indent); 2150 pp_string (buffer, "# SUCC:"); 2151 pp_write_text_to_stream (buffer); 2152 FOR_EACH_EDGE (e, ei, bb->succs) 2153 if (flags & TDF_SLIM) 2154 { 2155 pp_character (buffer, ' '); 2156 if (e->dest == EXIT_BLOCK_PTR) 2157 pp_string (buffer, "EXIT"); 2158 else 2159 pp_decimal_int (buffer, e->dest->index); 2160 } 2161 else 2162 dump_edge_info (buffer->buffer->stream, e, 1); 2163 pp_newline (buffer); 2164 } 2165 2166 2167 /* Dump PHI nodes of basic block BB to BUFFER with details described 2168 by FLAGS and indented by INDENT spaces. */ 2169 2170 static void 2171 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags) 2172 { 2173 gimple_stmt_iterator i; 2174 2175 for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i)) 2176 { 2177 gimple phi = gsi_stmt (i); 2178 if (is_gimple_reg (gimple_phi_result (phi)) || (flags & TDF_VOPS)) 2179 { 2180 INDENT (indent); 2181 pp_string (buffer, "# "); 2182 dump_gimple_phi (buffer, phi, indent, flags); 2183 pp_newline (buffer); 2184 } 2185 } 2186 } 2187 2188 2189 /* Dump jump to basic block BB that is represented implicitly in the cfg 2190 to BUFFER. */ 2191 2192 static void 2193 pp_cfg_jump (pretty_printer *buffer, basic_block bb) 2194 { 2195 gimple stmt; 2196 2197 stmt = first_stmt (bb); 2198 2199 pp_string (buffer, "goto <bb "); 2200 pp_decimal_int (buffer, bb->index); 2201 pp_character (buffer, '>'); 2202 if (stmt && gimple_code (stmt) == GIMPLE_LABEL) 2203 { 2204 pp_string (buffer, " ("); 2205 dump_generic_node (buffer, gimple_label_label (stmt), 0, 0, false); 2206 pp_character (buffer, ')'); 2207 pp_semicolon (buffer); 2208 } 2209 else 2210 pp_semicolon (buffer); 2211 } 2212 2213 2214 /* Dump edges represented implicitly in basic block BB to BUFFER, indented 2215 by INDENT spaces, with details given by FLAGS. */ 2216 2217 static void 2218 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent, 2219 int flags) 2220 { 2221 edge e; 2222 gimple stmt; 2223 2224 stmt = last_stmt (bb); 2225 2226 if (stmt && gimple_code (stmt) == GIMPLE_COND) 2227 { 2228 edge true_edge, false_edge; 2229 2230 /* When we are emitting the code or changing CFG, it is possible that 2231 the edges are not yet created. When we are using debug_bb in such 2232 a situation, we do not want it to crash. */ 2233 if (EDGE_COUNT (bb->succs) != 2) 2234 return; 2235 extract_true_false_edges_from_block (bb, &true_edge, &false_edge); 2236 2237 INDENT (indent + 2); 2238 pp_cfg_jump (buffer, true_edge->dest); 2239 newline_and_indent (buffer, indent); 2240 pp_string (buffer, "else"); 2241 newline_and_indent (buffer, indent + 2); 2242 pp_cfg_jump (buffer, false_edge->dest); 2243 pp_newline (buffer); 2244 return; 2245 } 2246 2247 /* If there is a fallthru edge, we may need to add an artificial 2248 goto to the dump. */ 2249 e = find_fallthru_edge (bb->succs); 2250 2251 if (e && e->dest != bb->next_bb) 2252 { 2253 INDENT (indent); 2254 2255 if ((flags & TDF_LINENO) 2256 && e->goto_locus != UNKNOWN_LOCATION 2257 ) 2258 { 2259 expanded_location goto_xloc; 2260 goto_xloc = expand_location (e->goto_locus); 2261 pp_character (buffer, '['); 2262 if (goto_xloc.file) 2263 { 2264 pp_string (buffer, goto_xloc.file); 2265 pp_string (buffer, " : "); 2266 } 2267 pp_decimal_int (buffer, goto_xloc.line); 2268 pp_string (buffer, " : "); 2269 pp_decimal_int (buffer, goto_xloc.column); 2270 pp_string (buffer, "] "); 2271 } 2272 2273 pp_cfg_jump (buffer, e->dest); 2274 pp_newline (buffer); 2275 } 2276 } 2277 2278 2279 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and 2280 indented by INDENT spaces. */ 2281 2282 static void 2283 gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent, 2284 int flags) 2285 { 2286 gimple_stmt_iterator gsi; 2287 gimple stmt; 2288 int label_indent = indent - 2; 2289 2290 if (label_indent < 0) 2291 label_indent = 0; 2292 2293 dump_bb_header (buffer, bb, indent, flags); 2294 dump_phi_nodes (buffer, bb, indent, flags); 2295 2296 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 2297 { 2298 int curr_indent; 2299 2300 stmt = gsi_stmt (gsi); 2301 2302 curr_indent = gimple_code (stmt) == GIMPLE_LABEL ? label_indent : indent; 2303 2304 INDENT (curr_indent); 2305 dump_gimple_stmt (buffer, stmt, curr_indent, flags); 2306 pp_newline (buffer); 2307 dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt); 2308 } 2309 2310 dump_implicit_edges (buffer, bb, indent, flags); 2311 2312 if (flags & TDF_BLOCKS) 2313 dump_bb_end (buffer, bb, indent, flags); 2314 } 2315 2316 2317 /* Dumps basic block BB to FILE with details described by FLAGS and 2318 indented by INDENT spaces. */ 2319 2320 void 2321 gimple_dump_bb (basic_block bb, FILE *file, int indent, int flags) 2322 { 2323 maybe_init_pretty_print (file); 2324 gimple_dump_bb_buff (&buffer, bb, indent, flags); 2325 pp_flush (&buffer); 2326 } 2327