1 /* Pretty formatting of GENERIC trees in C syntax. 2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 3 2011 Free Software Foundation, Inc. 4 Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.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" 25 #include "tm.h" 26 #include "tree.h" 27 #include "output.h" 28 #include "tree-pretty-print.h" 29 #include "hashtab.h" 30 #include "tree-flow.h" 31 #include "langhooks.h" 32 #include "tree-iterator.h" 33 #include "tree-chrec.h" 34 #include "tree-pass.h" 35 #include "value-prof.h" 36 #include "predict.h" 37 38 /* Local functions, macros and variables. */ 39 static const char *op_symbol (const_tree); 40 static void pretty_print_string (pretty_printer *, const char*); 41 static void newline_and_indent (pretty_printer *, int); 42 static void maybe_init_pretty_print (FILE *); 43 static void print_struct_decl (pretty_printer *, const_tree, int, int); 44 static void do_niy (pretty_printer *, const_tree); 45 46 #define INDENT(SPACE) do { \ 47 int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0) 48 49 #define NIY do_niy(buffer,node) 50 51 static pretty_printer buffer; 52 static int initialized = 0; 53 54 /* Try to print something for an unknown tree code. */ 55 56 static void 57 do_niy (pretty_printer *buffer, const_tree node) 58 { 59 int i, len; 60 61 pp_string (buffer, "<<< Unknown tree: "); 62 pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]); 63 64 if (EXPR_P (node)) 65 { 66 len = TREE_OPERAND_LENGTH (node); 67 for (i = 0; i < len; ++i) 68 { 69 newline_and_indent (buffer, 2); 70 dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false); 71 } 72 } 73 74 pp_string (buffer, " >>>"); 75 } 76 77 /* Debugging function to print out a generic expression. */ 78 79 DEBUG_FUNCTION void 80 debug_generic_expr (tree t) 81 { 82 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS); 83 fprintf (stderr, "\n"); 84 } 85 86 /* Debugging function to print out a generic statement. */ 87 88 DEBUG_FUNCTION void 89 debug_generic_stmt (tree t) 90 { 91 print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS); 92 fprintf (stderr, "\n"); 93 } 94 95 /* Debugging function to print out a chain of trees . */ 96 97 DEBUG_FUNCTION void 98 debug_tree_chain (tree t) 99 { 100 struct pointer_set_t *seen = pointer_set_create (); 101 102 while (t) 103 { 104 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID); 105 fprintf (stderr, " "); 106 t = TREE_CHAIN (t); 107 if (pointer_set_insert (seen, t)) 108 { 109 fprintf (stderr, "... [cycled back to "); 110 print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID); 111 fprintf (stderr, "]"); 112 break; 113 } 114 } 115 fprintf (stderr, "\n"); 116 117 pointer_set_destroy (seen); 118 } 119 120 /* Prints declaration DECL to the FILE with details specified by FLAGS. */ 121 void 122 print_generic_decl (FILE *file, tree decl, int flags) 123 { 124 maybe_init_pretty_print (file); 125 print_declaration (&buffer, decl, 2, flags); 126 pp_write_text_to_stream (&buffer); 127 } 128 129 /* Print tree T, and its successors, on file FILE. FLAGS specifies details 130 to show in the dump. See TDF_* in tree-pass.h. */ 131 132 void 133 print_generic_stmt (FILE *file, tree t, int flags) 134 { 135 maybe_init_pretty_print (file); 136 dump_generic_node (&buffer, t, 0, flags, true); 137 pp_flush (&buffer); 138 } 139 140 /* Print tree T, and its successors, on file FILE. FLAGS specifies details 141 to show in the dump. See TDF_* in tree-pass.h. The output is indented by 142 INDENT spaces. */ 143 144 void 145 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent) 146 { 147 int i; 148 149 maybe_init_pretty_print (file); 150 151 for (i = 0; i < indent; i++) 152 pp_space (&buffer); 153 dump_generic_node (&buffer, t, indent, flags, true); 154 pp_flush (&buffer); 155 } 156 157 /* Print a single expression T on file FILE. FLAGS specifies details to show 158 in the dump. See TDF_* in tree-pass.h. */ 159 160 void 161 print_generic_expr (FILE *file, tree t, int flags) 162 { 163 maybe_init_pretty_print (file); 164 dump_generic_node (&buffer, t, 0, flags, false); 165 } 166 167 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set 168 in FLAGS. */ 169 170 static void 171 dump_decl_name (pretty_printer *buffer, tree node, int flags) 172 { 173 if (DECL_NAME (node)) 174 { 175 if ((flags & TDF_ASMNAME) && DECL_ASSEMBLER_NAME_SET_P (node)) 176 pp_tree_identifier (buffer, DECL_ASSEMBLER_NAME (node)); 177 else 178 pp_tree_identifier (buffer, DECL_NAME (node)); 179 } 180 if ((flags & TDF_UID) || DECL_NAME (node) == NULL_TREE) 181 { 182 if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1) 183 pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (node)); 184 else if (TREE_CODE (node) == DEBUG_EXPR_DECL) 185 { 186 if (flags & TDF_NOUID) 187 pp_string (buffer, "D#xxxx"); 188 else 189 pp_printf (buffer, "D#%i", DEBUG_TEMP_UID (node)); 190 } 191 else 192 { 193 char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D'; 194 if (flags & TDF_NOUID) 195 pp_printf (buffer, "%c.xxxx", c); 196 else 197 pp_printf (buffer, "%c.%u", c, DECL_UID (node)); 198 } 199 } 200 if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node)) 201 { 202 if (flags & TDF_NOUID) 203 pp_printf (buffer, "ptD.xxxx"); 204 else 205 pp_printf (buffer, "ptD.%u", DECL_PT_UID (node)); 206 } 207 } 208 209 /* Like the above, but used for pretty printing function calls. */ 210 211 static void 212 dump_function_name (pretty_printer *buffer, tree node, int flags) 213 { 214 if (TREE_CODE (node) == NOP_EXPR) 215 node = TREE_OPERAND (node, 0); 216 if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0) 217 pp_string (buffer, lang_hooks.decl_printable_name (node, 1)); 218 else 219 dump_decl_name (buffer, node, flags); 220 } 221 222 /* Dump a function declaration. NODE is the FUNCTION_TYPE. BUFFER, SPC and 223 FLAGS are as in dump_generic_node. */ 224 225 static void 226 dump_function_declaration (pretty_printer *buffer, tree node, 227 int spc, int flags) 228 { 229 bool wrote_arg = false; 230 tree arg; 231 232 pp_space (buffer); 233 pp_character (buffer, '('); 234 235 /* Print the argument types. */ 236 arg = TYPE_ARG_TYPES (node); 237 while (arg && arg != void_list_node && arg != error_mark_node) 238 { 239 if (wrote_arg) 240 { 241 pp_character (buffer, ','); 242 pp_space (buffer); 243 } 244 wrote_arg = true; 245 dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false); 246 arg = TREE_CHAIN (arg); 247 } 248 249 /* Drop the trailing void_type_node if we had any previous argument. */ 250 if (arg == void_list_node && !wrote_arg) 251 pp_string (buffer, "void"); 252 /* Properly dump vararg function types. */ 253 else if (!arg && wrote_arg) 254 pp_string (buffer, ", ..."); 255 /* Avoid printing any arg for unprototyped functions. */ 256 257 pp_character (buffer, ')'); 258 } 259 260 /* Dump the domain associated with an array. */ 261 262 static void 263 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags) 264 { 265 pp_character (buffer, '['); 266 if (domain) 267 { 268 tree min = TYPE_MIN_VALUE (domain); 269 tree max = TYPE_MAX_VALUE (domain); 270 271 if (min && max 272 && integer_zerop (min) 273 && host_integerp (max, 0)) 274 pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1); 275 else 276 { 277 if (min) 278 dump_generic_node (buffer, min, spc, flags, false); 279 pp_character (buffer, ':'); 280 if (max) 281 dump_generic_node (buffer, max, spc, flags, false); 282 } 283 } 284 else 285 pp_string (buffer, "<unknown>"); 286 pp_character (buffer, ']'); 287 } 288 289 290 /* Dump OpenMP clause CLAUSE. BUFFER, CLAUSE, SPC and FLAGS are as in 291 dump_generic_node. */ 292 293 static void 294 dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags) 295 { 296 const char *name; 297 298 switch (OMP_CLAUSE_CODE (clause)) 299 { 300 case OMP_CLAUSE_PRIVATE: 301 name = "private"; 302 goto print_remap; 303 case OMP_CLAUSE_SHARED: 304 name = "shared"; 305 goto print_remap; 306 case OMP_CLAUSE_FIRSTPRIVATE: 307 name = "firstprivate"; 308 goto print_remap; 309 case OMP_CLAUSE_LASTPRIVATE: 310 name = "lastprivate"; 311 goto print_remap; 312 case OMP_CLAUSE_COPYIN: 313 name = "copyin"; 314 goto print_remap; 315 case OMP_CLAUSE_COPYPRIVATE: 316 name = "copyprivate"; 317 goto print_remap; 318 print_remap: 319 pp_string (buffer, name); 320 pp_character (buffer, '('); 321 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause), 322 spc, flags, false); 323 pp_character (buffer, ')'); 324 break; 325 326 case OMP_CLAUSE_REDUCTION: 327 pp_string (buffer, "reduction("); 328 pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause))); 329 pp_character (buffer, ':'); 330 dump_generic_node (buffer, OMP_CLAUSE_DECL (clause), 331 spc, flags, false); 332 pp_character (buffer, ')'); 333 break; 334 335 case OMP_CLAUSE_IF: 336 pp_string (buffer, "if("); 337 dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause), 338 spc, flags, false); 339 pp_character (buffer, ')'); 340 break; 341 342 case OMP_CLAUSE_NUM_THREADS: 343 pp_string (buffer, "num_threads("); 344 dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause), 345 spc, flags, false); 346 pp_character (buffer, ')'); 347 break; 348 349 case OMP_CLAUSE_NOWAIT: 350 pp_string (buffer, "nowait"); 351 break; 352 case OMP_CLAUSE_ORDERED: 353 pp_string (buffer, "ordered"); 354 break; 355 356 case OMP_CLAUSE_DEFAULT: 357 pp_string (buffer, "default("); 358 switch (OMP_CLAUSE_DEFAULT_KIND (clause)) 359 { 360 case OMP_CLAUSE_DEFAULT_UNSPECIFIED: 361 break; 362 case OMP_CLAUSE_DEFAULT_SHARED: 363 pp_string (buffer, "shared"); 364 break; 365 case OMP_CLAUSE_DEFAULT_NONE: 366 pp_string (buffer, "none"); 367 break; 368 case OMP_CLAUSE_DEFAULT_PRIVATE: 369 pp_string (buffer, "private"); 370 break; 371 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE: 372 pp_string (buffer, "firstprivate"); 373 break; 374 default: 375 gcc_unreachable (); 376 } 377 pp_character (buffer, ')'); 378 break; 379 380 case OMP_CLAUSE_SCHEDULE: 381 pp_string (buffer, "schedule("); 382 switch (OMP_CLAUSE_SCHEDULE_KIND (clause)) 383 { 384 case OMP_CLAUSE_SCHEDULE_STATIC: 385 pp_string (buffer, "static"); 386 break; 387 case OMP_CLAUSE_SCHEDULE_DYNAMIC: 388 pp_string (buffer, "dynamic"); 389 break; 390 case OMP_CLAUSE_SCHEDULE_GUIDED: 391 pp_string (buffer, "guided"); 392 break; 393 case OMP_CLAUSE_SCHEDULE_RUNTIME: 394 pp_string (buffer, "runtime"); 395 break; 396 case OMP_CLAUSE_SCHEDULE_AUTO: 397 pp_string (buffer, "auto"); 398 break; 399 default: 400 gcc_unreachable (); 401 } 402 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause)) 403 { 404 pp_character (buffer, ','); 405 dump_generic_node (buffer, 406 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause), 407 spc, flags, false); 408 } 409 pp_character (buffer, ')'); 410 break; 411 412 case OMP_CLAUSE_UNTIED: 413 pp_string (buffer, "untied"); 414 break; 415 416 case OMP_CLAUSE_COLLAPSE: 417 pp_string (buffer, "collapse("); 418 dump_generic_node (buffer, 419 OMP_CLAUSE_COLLAPSE_EXPR (clause), 420 spc, flags, false); 421 pp_character (buffer, ')'); 422 break; 423 424 case OMP_CLAUSE_FINAL: 425 pp_string (buffer, "final("); 426 dump_generic_node (buffer, OMP_CLAUSE_FINAL_EXPR (clause), 427 spc, flags, false); 428 pp_character (buffer, ')'); 429 break; 430 431 case OMP_CLAUSE_MERGEABLE: 432 pp_string (buffer, "mergeable"); 433 break; 434 435 default: 436 /* Should never happen. */ 437 dump_generic_node (buffer, clause, spc, flags, false); 438 break; 439 } 440 } 441 442 443 /* Dump the list of OpenMP clauses. BUFFER, SPC and FLAGS are as in 444 dump_generic_node. */ 445 446 void 447 dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags) 448 { 449 if (clause == NULL) 450 return; 451 452 pp_space (buffer); 453 while (1) 454 { 455 dump_omp_clause (buffer, clause, spc, flags); 456 clause = OMP_CLAUSE_CHAIN (clause); 457 if (clause == NULL) 458 return; 459 pp_space (buffer); 460 } 461 } 462 463 464 /* Dump location LOC to BUFFER. */ 465 466 static void 467 dump_location (pretty_printer *buffer, location_t loc) 468 { 469 expanded_location xloc = expand_location (loc); 470 471 pp_character (buffer, '['); 472 if (xloc.file) 473 { 474 pp_string (buffer, xloc.file); 475 pp_string (buffer, " : "); 476 } 477 pp_decimal_int (buffer, xloc.line); 478 pp_string (buffer, "] "); 479 } 480 481 482 /* Dump lexical block BLOCK. BUFFER, SPC and FLAGS are as in 483 dump_generic_node. */ 484 485 static void 486 dump_block_node (pretty_printer *buffer, tree block, int spc, int flags) 487 { 488 tree t; 489 490 pp_printf (buffer, "BLOCK #%d ", BLOCK_NUMBER (block)); 491 492 if (flags & TDF_ADDRESS) 493 pp_printf (buffer, "[%p] ", (void *) block); 494 495 if (BLOCK_ABSTRACT (block)) 496 pp_string (buffer, "[abstract] "); 497 498 if (TREE_ASM_WRITTEN (block)) 499 pp_string (buffer, "[written] "); 500 501 if (flags & TDF_SLIM) 502 return; 503 504 if (BLOCK_SOURCE_LOCATION (block)) 505 dump_location (buffer, BLOCK_SOURCE_LOCATION (block)); 506 507 newline_and_indent (buffer, spc + 2); 508 509 if (BLOCK_SUPERCONTEXT (block)) 510 { 511 pp_string (buffer, "SUPERCONTEXT: "); 512 dump_generic_node (buffer, BLOCK_SUPERCONTEXT (block), 0, 513 flags | TDF_SLIM, false); 514 newline_and_indent (buffer, spc + 2); 515 } 516 517 if (BLOCK_SUBBLOCKS (block)) 518 { 519 pp_string (buffer, "SUBBLOCKS: "); 520 for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t)) 521 { 522 dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false); 523 pp_string (buffer, " "); 524 } 525 newline_and_indent (buffer, spc + 2); 526 } 527 528 if (BLOCK_CHAIN (block)) 529 { 530 pp_string (buffer, "SIBLINGS: "); 531 for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t)) 532 { 533 dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false); 534 pp_string (buffer, " "); 535 } 536 newline_and_indent (buffer, spc + 2); 537 } 538 539 if (BLOCK_VARS (block)) 540 { 541 pp_string (buffer, "VARS: "); 542 for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t)) 543 { 544 dump_generic_node (buffer, t, 0, flags, false); 545 pp_string (buffer, " "); 546 } 547 newline_and_indent (buffer, spc + 2); 548 } 549 550 if (VEC_length (tree, BLOCK_NONLOCALIZED_VARS (block)) > 0) 551 { 552 unsigned i; 553 VEC(tree,gc) *nlv = BLOCK_NONLOCALIZED_VARS (block); 554 555 pp_string (buffer, "NONLOCALIZED_VARS: "); 556 FOR_EACH_VEC_ELT (tree, nlv, i, t) 557 { 558 dump_generic_node (buffer, t, 0, flags, false); 559 pp_string (buffer, " "); 560 } 561 newline_and_indent (buffer, spc + 2); 562 } 563 564 if (BLOCK_ABSTRACT_ORIGIN (block)) 565 { 566 pp_string (buffer, "ABSTRACT_ORIGIN: "); 567 dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (block), 0, 568 flags | TDF_SLIM, false); 569 newline_and_indent (buffer, spc + 2); 570 } 571 572 if (BLOCK_FRAGMENT_ORIGIN (block)) 573 { 574 pp_string (buffer, "FRAGMENT_ORIGIN: "); 575 dump_generic_node (buffer, BLOCK_FRAGMENT_ORIGIN (block), 0, 576 flags | TDF_SLIM, false); 577 newline_and_indent (buffer, spc + 2); 578 } 579 580 if (BLOCK_FRAGMENT_CHAIN (block)) 581 { 582 pp_string (buffer, "FRAGMENT_CHAIN: "); 583 for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t)) 584 { 585 dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false); 586 pp_string (buffer, " "); 587 } 588 newline_and_indent (buffer, spc + 2); 589 } 590 } 591 592 593 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of 594 indent. FLAGS specifies details to show in the dump (see TDF_* in 595 tree-pass.h). If IS_STMT is true, the object printed is considered 596 to be a statement and it is terminated by ';' if appropriate. */ 597 598 int 599 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags, 600 bool is_stmt) 601 { 602 tree type; 603 tree op0, op1; 604 const char *str; 605 bool is_expr; 606 607 if (node == NULL_TREE) 608 return spc; 609 610 is_expr = EXPR_P (node); 611 612 if (is_stmt && (flags & TDF_STMTADDR)) 613 pp_printf (buffer, "<&%p> ", (void *)node); 614 615 if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node)) 616 dump_location (buffer, EXPR_LOCATION (node)); 617 618 switch (TREE_CODE (node)) 619 { 620 case ERROR_MARK: 621 pp_string (buffer, "<<< error >>>"); 622 break; 623 624 case IDENTIFIER_NODE: 625 pp_tree_identifier (buffer, node); 626 break; 627 628 case TREE_LIST: 629 while (node && node != error_mark_node) 630 { 631 if (TREE_PURPOSE (node)) 632 { 633 dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false); 634 pp_space (buffer); 635 } 636 dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false); 637 node = TREE_CHAIN (node); 638 if (node && TREE_CODE (node) == TREE_LIST) 639 { 640 pp_character (buffer, ','); 641 pp_space (buffer); 642 } 643 } 644 break; 645 646 case TREE_BINFO: 647 dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false); 648 break; 649 650 case TREE_VEC: 651 { 652 size_t i; 653 if (TREE_VEC_LENGTH (node) > 0) 654 { 655 size_t len = TREE_VEC_LENGTH (node); 656 for (i = 0; i < len - 1; i++) 657 { 658 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags, 659 false); 660 pp_character (buffer, ','); 661 pp_space (buffer); 662 } 663 dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc, 664 flags, false); 665 } 666 } 667 break; 668 669 case VOID_TYPE: 670 case INTEGER_TYPE: 671 case REAL_TYPE: 672 case FIXED_POINT_TYPE: 673 case COMPLEX_TYPE: 674 case VECTOR_TYPE: 675 case ENUMERAL_TYPE: 676 case BOOLEAN_TYPE: 677 { 678 unsigned int quals = TYPE_QUALS (node); 679 enum tree_code_class tclass; 680 681 if (quals & TYPE_QUAL_CONST) 682 pp_string (buffer, "const "); 683 else if (quals & TYPE_QUAL_VOLATILE) 684 pp_string (buffer, "volatile "); 685 else if (quals & TYPE_QUAL_RESTRICT) 686 pp_string (buffer, "restrict "); 687 688 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) 689 { 690 pp_string (buffer, "<address-space-"); 691 pp_decimal_int (buffer, TYPE_ADDR_SPACE (node)); 692 pp_string (buffer, "> "); 693 } 694 695 tclass = TREE_CODE_CLASS (TREE_CODE (node)); 696 697 if (tclass == tcc_declaration) 698 { 699 if (DECL_NAME (node)) 700 dump_decl_name (buffer, node, flags); 701 else 702 pp_string (buffer, "<unnamed type decl>"); 703 } 704 else if (tclass == tcc_type) 705 { 706 if (TYPE_NAME (node)) 707 { 708 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) 709 pp_tree_identifier (buffer, TYPE_NAME (node)); 710 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL 711 && DECL_NAME (TYPE_NAME (node))) 712 dump_decl_name (buffer, TYPE_NAME (node), flags); 713 else 714 pp_string (buffer, "<unnamed type>"); 715 } 716 else if (TREE_CODE (node) == VECTOR_TYPE) 717 { 718 pp_string (buffer, "vector"); 719 pp_character (buffer, '('); 720 pp_wide_integer (buffer, TYPE_VECTOR_SUBPARTS (node)); 721 pp_string (buffer, ") "); 722 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); 723 } 724 else if (TREE_CODE (node) == INTEGER_TYPE) 725 { 726 pp_string (buffer, (TYPE_UNSIGNED (node) 727 ? "<unnamed-unsigned:" 728 : "<unnamed-signed:")); 729 pp_decimal_int (buffer, TYPE_PRECISION (node)); 730 pp_string (buffer, ">"); 731 } 732 else if (TREE_CODE (node) == COMPLEX_TYPE) 733 { 734 pp_string (buffer, "__complex__ "); 735 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); 736 } 737 else if (TREE_CODE (node) == REAL_TYPE) 738 { 739 pp_string (buffer, "<float:"); 740 pp_decimal_int (buffer, TYPE_PRECISION (node)); 741 pp_string (buffer, ">"); 742 } 743 else if (TREE_CODE (node) == FIXED_POINT_TYPE) 744 { 745 pp_string (buffer, "<fixed-point-"); 746 pp_string (buffer, TYPE_SATURATING (node) ? "sat:" : "nonsat:"); 747 pp_decimal_int (buffer, TYPE_PRECISION (node)); 748 pp_string (buffer, ">"); 749 } 750 else if (TREE_CODE (node) == VOID_TYPE) 751 pp_string (buffer, "void"); 752 else 753 pp_string (buffer, "<unnamed type>"); 754 } 755 break; 756 } 757 758 case POINTER_TYPE: 759 case REFERENCE_TYPE: 760 str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&"); 761 762 if (TREE_TYPE (node) == NULL) 763 { 764 pp_string (buffer, str); 765 pp_string (buffer, "<null type>"); 766 } 767 else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE) 768 { 769 tree fnode = TREE_TYPE (node); 770 771 dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false); 772 pp_space (buffer); 773 pp_character (buffer, '('); 774 pp_string (buffer, str); 775 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node))) 776 dump_decl_name (buffer, TYPE_NAME (node), flags); 777 else if (flags & TDF_NOUID) 778 pp_printf (buffer, "<Txxxx>"); 779 else 780 pp_printf (buffer, "<T%x>", TYPE_UID (node)); 781 782 pp_character (buffer, ')'); 783 dump_function_declaration (buffer, fnode, spc, flags); 784 } 785 else 786 { 787 unsigned int quals = TYPE_QUALS (node); 788 789 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); 790 pp_space (buffer); 791 pp_string (buffer, str); 792 793 if (quals & TYPE_QUAL_CONST) 794 pp_string (buffer, " const"); 795 if (quals & TYPE_QUAL_VOLATILE) 796 pp_string (buffer, " volatile"); 797 if (quals & TYPE_QUAL_RESTRICT) 798 pp_string (buffer, " restrict"); 799 800 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node))) 801 { 802 pp_string (buffer, " <address-space-"); 803 pp_decimal_int (buffer, TYPE_ADDR_SPACE (node)); 804 pp_string (buffer, ">"); 805 } 806 807 if (TYPE_REF_CAN_ALIAS_ALL (node)) 808 pp_string (buffer, " {ref-all}"); 809 } 810 break; 811 812 case OFFSET_TYPE: 813 NIY; 814 break; 815 816 case MEM_REF: 817 { 818 if (integer_zerop (TREE_OPERAND (node, 1)) 819 /* Dump the types of INTEGER_CSTs explicitly, for we can't 820 infer them and MEM_ATTR caching will share MEM_REFs 821 with differently-typed op0s. */ 822 && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST 823 /* Released SSA_NAMES have no TREE_TYPE. */ 824 && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE 825 /* Same pointer types, but ignoring POINTER_TYPE vs. 826 REFERENCE_TYPE. */ 827 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0))) 828 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))) 829 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0))) 830 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1)))) 831 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0))) 832 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1)))) 833 /* Same value types ignoring qualifiers. */ 834 && (TYPE_MAIN_VARIANT (TREE_TYPE (node)) 835 == TYPE_MAIN_VARIANT 836 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))) 837 { 838 if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR) 839 { 840 pp_string (buffer, "*"); 841 dump_generic_node (buffer, TREE_OPERAND (node, 0), 842 spc, flags, false); 843 } 844 else 845 dump_generic_node (buffer, 846 TREE_OPERAND (TREE_OPERAND (node, 0), 0), 847 spc, flags, false); 848 } 849 else 850 { 851 tree ptype; 852 853 pp_string (buffer, "MEM["); 854 pp_string (buffer, "("); 855 ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1))); 856 dump_generic_node (buffer, ptype, 857 spc, flags | TDF_SLIM, false); 858 pp_string (buffer, ")"); 859 dump_generic_node (buffer, TREE_OPERAND (node, 0), 860 spc, flags, false); 861 if (!integer_zerop (TREE_OPERAND (node, 1))) 862 { 863 pp_string (buffer, " + "); 864 dump_generic_node (buffer, TREE_OPERAND (node, 1), 865 spc, flags, false); 866 } 867 pp_string (buffer, "]"); 868 } 869 break; 870 } 871 872 case TARGET_MEM_REF: 873 { 874 const char *sep = ""; 875 tree tmp; 876 877 pp_string (buffer, "MEM["); 878 879 if (TREE_CODE (TMR_BASE (node)) == ADDR_EXPR) 880 { 881 pp_string (buffer, sep); 882 sep = ", "; 883 pp_string (buffer, "symbol: "); 884 dump_generic_node (buffer, TREE_OPERAND (TMR_BASE (node), 0), 885 spc, flags, false); 886 } 887 else 888 { 889 pp_string (buffer, sep); 890 sep = ", "; 891 pp_string (buffer, "base: "); 892 dump_generic_node (buffer, TMR_BASE (node), spc, flags, false); 893 } 894 tmp = TMR_INDEX2 (node); 895 if (tmp) 896 { 897 pp_string (buffer, sep); 898 sep = ", "; 899 pp_string (buffer, "base: "); 900 dump_generic_node (buffer, tmp, spc, flags, false); 901 } 902 tmp = TMR_INDEX (node); 903 if (tmp) 904 { 905 pp_string (buffer, sep); 906 sep = ", "; 907 pp_string (buffer, "index: "); 908 dump_generic_node (buffer, tmp, spc, flags, false); 909 } 910 tmp = TMR_STEP (node); 911 if (tmp) 912 { 913 pp_string (buffer, sep); 914 sep = ", "; 915 pp_string (buffer, "step: "); 916 dump_generic_node (buffer, tmp, spc, flags, false); 917 } 918 tmp = TMR_OFFSET (node); 919 if (tmp) 920 { 921 pp_string (buffer, sep); 922 sep = ", "; 923 pp_string (buffer, "offset: "); 924 dump_generic_node (buffer, tmp, spc, flags, false); 925 } 926 pp_string (buffer, "]"); 927 } 928 break; 929 930 case ARRAY_TYPE: 931 { 932 tree tmp; 933 934 /* Print the innermost component type. */ 935 for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE; 936 tmp = TREE_TYPE (tmp)) 937 ; 938 dump_generic_node (buffer, tmp, spc, flags, false); 939 940 /* Print the dimensions. */ 941 for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp)) 942 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags); 943 break; 944 } 945 946 case RECORD_TYPE: 947 case UNION_TYPE: 948 case QUAL_UNION_TYPE: 949 { 950 unsigned int quals = TYPE_QUALS (node); 951 952 if (quals & TYPE_QUAL_CONST) 953 pp_string (buffer, "const "); 954 if (quals & TYPE_QUAL_VOLATILE) 955 pp_string (buffer, "volatile "); 956 957 /* Print the name of the structure. */ 958 if (TREE_CODE (node) == RECORD_TYPE) 959 pp_string (buffer, "struct "); 960 else if (TREE_CODE (node) == UNION_TYPE) 961 pp_string (buffer, "union "); 962 963 if (TYPE_NAME (node)) 964 dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false); 965 else if (!(flags & TDF_SLIM)) 966 /* FIXME: If we eliminate the 'else' above and attempt 967 to show the fields for named types, we may get stuck 968 following a cycle of pointers to structs. The alleged 969 self-reference check in print_struct_decl will not detect 970 cycles involving more than one pointer or struct type. */ 971 print_struct_decl (buffer, node, spc, flags); 972 break; 973 } 974 975 case LANG_TYPE: 976 NIY; 977 break; 978 979 case INTEGER_CST: 980 if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE) 981 { 982 /* In the case of a pointer, one may want to divide by the 983 size of the pointed-to type. Unfortunately, this not 984 straightforward. The C front-end maps expressions 985 986 (int *) 5 987 int *p; (p + 5) 988 989 in such a way that the two INTEGER_CST nodes for "5" have 990 different values but identical types. In the latter 991 case, the 5 is multiplied by sizeof (int) in c-common.c 992 (pointer_int_sum) to convert it to a byte address, and 993 yet the type of the node is left unchanged. Argh. What 994 is consistent though is that the number value corresponds 995 to bytes (UNITS) offset. 996 997 NB: Neither of the following divisors can be trivially 998 used to recover the original literal: 999 1000 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node))) 1001 TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node))) */ 1002 pp_wide_integer (buffer, TREE_INT_CST_LOW (node)); 1003 pp_string (buffer, "B"); /* pseudo-unit */ 1004 } 1005 else if (host_integerp (node, 0)) 1006 pp_wide_integer (buffer, TREE_INT_CST_LOW (node)); 1007 else if (host_integerp (node, 1)) 1008 pp_unsigned_wide_integer (buffer, TREE_INT_CST_LOW (node)); 1009 else 1010 { 1011 tree val = node; 1012 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val); 1013 HOST_WIDE_INT high = TREE_INT_CST_HIGH (val); 1014 1015 if (tree_int_cst_sgn (val) < 0) 1016 { 1017 pp_character (buffer, '-'); 1018 high = ~high + !low; 1019 low = -low; 1020 } 1021 /* Would "%x%0*x" or "%x%*0x" get zero-padding on all 1022 systems? */ 1023 sprintf (pp_buffer (buffer)->digit_buffer, 1024 HOST_WIDE_INT_PRINT_DOUBLE_HEX, 1025 (unsigned HOST_WIDE_INT) high, low); 1026 pp_string (buffer, pp_buffer (buffer)->digit_buffer); 1027 } 1028 break; 1029 1030 case REAL_CST: 1031 /* Code copied from print_node. */ 1032 { 1033 REAL_VALUE_TYPE d; 1034 if (TREE_OVERFLOW (node)) 1035 pp_string (buffer, " overflow"); 1036 1037 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC) 1038 d = TREE_REAL_CST (node); 1039 if (REAL_VALUE_ISINF (d)) 1040 pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf"); 1041 else if (REAL_VALUE_ISNAN (d)) 1042 pp_string (buffer, " Nan"); 1043 else 1044 { 1045 char string[100]; 1046 real_to_decimal (string, &d, sizeof (string), 0, 1); 1047 pp_string (buffer, string); 1048 } 1049 #else 1050 { 1051 HOST_WIDE_INT i; 1052 unsigned char *p = (unsigned char *) &TREE_REAL_CST (node); 1053 pp_string (buffer, "0x"); 1054 for (i = 0; i < sizeof TREE_REAL_CST (node); i++) 1055 output_formatted_integer (buffer, "%02x", *p++); 1056 } 1057 #endif 1058 break; 1059 } 1060 1061 case FIXED_CST: 1062 { 1063 char string[100]; 1064 fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string)); 1065 pp_string (buffer, string); 1066 break; 1067 } 1068 1069 case COMPLEX_CST: 1070 pp_string (buffer, "__complex__ ("); 1071 dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false); 1072 pp_string (buffer, ", "); 1073 dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false); 1074 pp_string (buffer, ")"); 1075 break; 1076 1077 case STRING_CST: 1078 pp_string (buffer, "\""); 1079 pretty_print_string (buffer, TREE_STRING_POINTER (node)); 1080 pp_string (buffer, "\""); 1081 break; 1082 1083 case VECTOR_CST: 1084 { 1085 tree elt; 1086 pp_string (buffer, "{ "); 1087 for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt)) 1088 { 1089 dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false); 1090 if (TREE_CHAIN (elt)) 1091 pp_string (buffer, ", "); 1092 } 1093 pp_string (buffer, " }"); 1094 } 1095 break; 1096 1097 case FUNCTION_TYPE: 1098 case METHOD_TYPE: 1099 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); 1100 pp_space (buffer); 1101 if (TREE_CODE (node) == METHOD_TYPE) 1102 { 1103 if (TYPE_METHOD_BASETYPE (node)) 1104 dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), 1105 flags); 1106 else 1107 pp_string (buffer, "<null method basetype>"); 1108 pp_string (buffer, "::"); 1109 } 1110 if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node))) 1111 dump_decl_name (buffer, TYPE_NAME (node), flags); 1112 else if (flags & TDF_NOUID) 1113 pp_printf (buffer, "<Txxxx>"); 1114 else 1115 pp_printf (buffer, "<T%x>", TYPE_UID (node)); 1116 dump_function_declaration (buffer, node, spc, flags); 1117 break; 1118 1119 case FUNCTION_DECL: 1120 case CONST_DECL: 1121 dump_decl_name (buffer, node, flags); 1122 break; 1123 1124 case LABEL_DECL: 1125 if (DECL_NAME (node)) 1126 dump_decl_name (buffer, node, flags); 1127 else if (LABEL_DECL_UID (node) != -1) 1128 pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node)); 1129 else 1130 { 1131 if (flags & TDF_NOUID) 1132 pp_string (buffer, "<D.xxxx>"); 1133 else 1134 pp_printf (buffer, "<D.%u>", DECL_UID (node)); 1135 } 1136 break; 1137 1138 case TYPE_DECL: 1139 if (DECL_IS_BUILTIN (node)) 1140 { 1141 /* Don't print the declaration of built-in types. */ 1142 break; 1143 } 1144 if (DECL_NAME (node)) 1145 dump_decl_name (buffer, node, flags); 1146 else if (TYPE_NAME (TREE_TYPE (node)) != node) 1147 { 1148 if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE 1149 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE) 1150 && TYPE_METHODS (TREE_TYPE (node))) 1151 { 1152 /* The type is a c++ class: all structures have at least 1153 4 methods. */ 1154 pp_string (buffer, "class "); 1155 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); 1156 } 1157 else 1158 { 1159 pp_string (buffer, 1160 (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE 1161 ? "union" : "struct ")); 1162 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); 1163 } 1164 } 1165 else 1166 pp_string (buffer, "<anon>"); 1167 break; 1168 1169 case VAR_DECL: 1170 case PARM_DECL: 1171 case FIELD_DECL: 1172 case DEBUG_EXPR_DECL: 1173 case NAMESPACE_DECL: 1174 dump_decl_name (buffer, node, flags); 1175 break; 1176 1177 case RESULT_DECL: 1178 pp_string (buffer, "<retval>"); 1179 break; 1180 1181 case COMPONENT_REF: 1182 op0 = TREE_OPERAND (node, 0); 1183 str = "."; 1184 if (op0 1185 && (TREE_CODE (op0) == INDIRECT_REF 1186 || (TREE_CODE (op0) == MEM_REF 1187 && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR 1188 && integer_zerop (TREE_OPERAND (op0, 1)) 1189 /* Dump the types of INTEGER_CSTs explicitly, for we 1190 can't infer them and MEM_ATTR caching will share 1191 MEM_REFs with differently-typed op0s. */ 1192 && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST 1193 /* Released SSA_NAMES have no TREE_TYPE. */ 1194 && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE 1195 /* Same pointer types, but ignoring POINTER_TYPE vs. 1196 REFERENCE_TYPE. */ 1197 && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0))) 1198 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))) 1199 && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0))) 1200 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1)))) 1201 && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0))) 1202 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1)))) 1203 /* Same value types ignoring qualifiers. */ 1204 && (TYPE_MAIN_VARIANT (TREE_TYPE (op0)) 1205 == TYPE_MAIN_VARIANT 1206 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))))))) 1207 { 1208 op0 = TREE_OPERAND (op0, 0); 1209 str = "->"; 1210 } 1211 if (op_prio (op0) < op_prio (node)) 1212 pp_character (buffer, '('); 1213 dump_generic_node (buffer, op0, spc, flags, false); 1214 if (op_prio (op0) < op_prio (node)) 1215 pp_character (buffer, ')'); 1216 pp_string (buffer, str); 1217 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 1218 op0 = component_ref_field_offset (node); 1219 if (op0 && TREE_CODE (op0) != INTEGER_CST) 1220 { 1221 pp_string (buffer, "{off: "); 1222 dump_generic_node (buffer, op0, spc, flags, false); 1223 pp_character (buffer, '}'); 1224 } 1225 break; 1226 1227 case BIT_FIELD_REF: 1228 pp_string (buffer, "BIT_FIELD_REF <"); 1229 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1230 pp_string (buffer, ", "); 1231 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 1232 pp_string (buffer, ", "); 1233 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); 1234 pp_string (buffer, ">"); 1235 break; 1236 1237 case ARRAY_REF: 1238 case ARRAY_RANGE_REF: 1239 op0 = TREE_OPERAND (node, 0); 1240 if (op_prio (op0) < op_prio (node)) 1241 pp_character (buffer, '('); 1242 dump_generic_node (buffer, op0, spc, flags, false); 1243 if (op_prio (op0) < op_prio (node)) 1244 pp_character (buffer, ')'); 1245 pp_character (buffer, '['); 1246 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 1247 if (TREE_CODE (node) == ARRAY_RANGE_REF) 1248 pp_string (buffer, " ..."); 1249 pp_character (buffer, ']'); 1250 1251 op0 = array_ref_low_bound (node); 1252 op1 = array_ref_element_size (node); 1253 1254 if (!integer_zerop (op0) 1255 || TREE_OPERAND (node, 2) 1256 || TREE_OPERAND (node, 3)) 1257 { 1258 pp_string (buffer, "{lb: "); 1259 dump_generic_node (buffer, op0, spc, flags, false); 1260 pp_string (buffer, " sz: "); 1261 dump_generic_node (buffer, op1, spc, flags, false); 1262 pp_character (buffer, '}'); 1263 } 1264 break; 1265 1266 case CONSTRUCTOR: 1267 { 1268 unsigned HOST_WIDE_INT ix; 1269 tree field, val; 1270 bool is_struct_init = false; 1271 bool is_array_init = false; 1272 double_int curidx = double_int_zero; 1273 pp_character (buffer, '{'); 1274 if (TREE_CLOBBER_P (node)) 1275 pp_string (buffer, "CLOBBER"); 1276 else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE 1277 || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE) 1278 is_struct_init = true; 1279 else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE 1280 && TYPE_DOMAIN (TREE_TYPE (node)) 1281 && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))) 1282 && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))) 1283 == INTEGER_CST) 1284 { 1285 tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))); 1286 is_array_init = true; 1287 curidx = tree_to_double_int (minv); 1288 } 1289 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val) 1290 { 1291 if (field) 1292 { 1293 if (is_struct_init) 1294 { 1295 pp_character (buffer, '.'); 1296 dump_generic_node (buffer, field, spc, flags, false); 1297 pp_character (buffer, '='); 1298 } 1299 else if (is_array_init 1300 && (TREE_CODE (field) != INTEGER_CST 1301 || !double_int_equal_p (tree_to_double_int (field), 1302 curidx))) 1303 { 1304 pp_character (buffer, '['); 1305 if (TREE_CODE (field) == RANGE_EXPR) 1306 { 1307 dump_generic_node (buffer, TREE_OPERAND (field, 0), spc, 1308 flags, false); 1309 pp_string (buffer, " ... "); 1310 dump_generic_node (buffer, TREE_OPERAND (field, 1), spc, 1311 flags, false); 1312 if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST) 1313 curidx = tree_to_double_int (TREE_OPERAND (field, 1)); 1314 } 1315 else 1316 dump_generic_node (buffer, field, spc, flags, false); 1317 if (TREE_CODE (field) == INTEGER_CST) 1318 curidx = tree_to_double_int (field); 1319 pp_string (buffer, "]="); 1320 } 1321 } 1322 if (is_array_init) 1323 curidx = double_int_add (curidx, double_int_one); 1324 if (val && TREE_CODE (val) == ADDR_EXPR) 1325 if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL) 1326 val = TREE_OPERAND (val, 0); 1327 if (val && TREE_CODE (val) == FUNCTION_DECL) 1328 dump_decl_name (buffer, val, flags); 1329 else 1330 dump_generic_node (buffer, val, spc, flags, false); 1331 if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1) 1332 { 1333 pp_character (buffer, ','); 1334 pp_space (buffer); 1335 } 1336 } 1337 pp_character (buffer, '}'); 1338 } 1339 break; 1340 1341 case COMPOUND_EXPR: 1342 { 1343 tree *tp; 1344 if (flags & TDF_SLIM) 1345 { 1346 pp_string (buffer, "<COMPOUND_EXPR>"); 1347 break; 1348 } 1349 1350 dump_generic_node (buffer, TREE_OPERAND (node, 0), 1351 spc, flags, !(flags & TDF_SLIM)); 1352 if (flags & TDF_SLIM) 1353 newline_and_indent (buffer, spc); 1354 else 1355 { 1356 pp_character (buffer, ','); 1357 pp_space (buffer); 1358 } 1359 1360 for (tp = &TREE_OPERAND (node, 1); 1361 TREE_CODE (*tp) == COMPOUND_EXPR; 1362 tp = &TREE_OPERAND (*tp, 1)) 1363 { 1364 dump_generic_node (buffer, TREE_OPERAND (*tp, 0), 1365 spc, flags, !(flags & TDF_SLIM)); 1366 if (flags & TDF_SLIM) 1367 newline_and_indent (buffer, spc); 1368 else 1369 { 1370 pp_character (buffer, ','); 1371 pp_space (buffer); 1372 } 1373 } 1374 1375 dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM)); 1376 } 1377 break; 1378 1379 case STATEMENT_LIST: 1380 { 1381 tree_stmt_iterator si; 1382 bool first = true; 1383 1384 if (flags & TDF_SLIM) 1385 { 1386 pp_string (buffer, "<STATEMENT_LIST>"); 1387 break; 1388 } 1389 1390 for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si)) 1391 { 1392 if (!first) 1393 newline_and_indent (buffer, spc); 1394 else 1395 first = false; 1396 dump_generic_node (buffer, tsi_stmt (si), spc, flags, true); 1397 } 1398 } 1399 break; 1400 1401 case MODIFY_EXPR: 1402 case INIT_EXPR: 1403 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, 1404 false); 1405 pp_space (buffer); 1406 pp_character (buffer, '='); 1407 if (TREE_CODE (node) == MODIFY_EXPR 1408 && MOVE_NONTEMPORAL (node)) 1409 pp_string (buffer, "{nt}"); 1410 pp_space (buffer); 1411 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, 1412 false); 1413 break; 1414 1415 case TARGET_EXPR: 1416 pp_string (buffer, "TARGET_EXPR <"); 1417 dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false); 1418 pp_character (buffer, ','); 1419 pp_space (buffer); 1420 dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false); 1421 pp_character (buffer, '>'); 1422 break; 1423 1424 case DECL_EXPR: 1425 print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags); 1426 is_stmt = false; 1427 break; 1428 1429 case COND_EXPR: 1430 if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node) 1431 { 1432 pp_string (buffer, "if ("); 1433 dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false); 1434 pp_character (buffer, ')'); 1435 /* The lowered cond_exprs should always be printed in full. */ 1436 if (COND_EXPR_THEN (node) 1437 && (IS_EMPTY_STMT (COND_EXPR_THEN (node)) 1438 || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR) 1439 && COND_EXPR_ELSE (node) 1440 && (IS_EMPTY_STMT (COND_EXPR_ELSE (node)) 1441 || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR)) 1442 { 1443 pp_space (buffer); 1444 dump_generic_node (buffer, COND_EXPR_THEN (node), 1445 0, flags, true); 1446 if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node))) 1447 { 1448 pp_string (buffer, " else "); 1449 dump_generic_node (buffer, COND_EXPR_ELSE (node), 1450 0, flags, true); 1451 } 1452 } 1453 else if (!(flags & TDF_SLIM)) 1454 { 1455 /* Output COND_EXPR_THEN. */ 1456 if (COND_EXPR_THEN (node)) 1457 { 1458 newline_and_indent (buffer, spc+2); 1459 pp_character (buffer, '{'); 1460 newline_and_indent (buffer, spc+4); 1461 dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4, 1462 flags, true); 1463 newline_and_indent (buffer, spc+2); 1464 pp_character (buffer, '}'); 1465 } 1466 1467 /* Output COND_EXPR_ELSE. */ 1468 if (COND_EXPR_ELSE (node) 1469 && !IS_EMPTY_STMT (COND_EXPR_ELSE (node))) 1470 { 1471 newline_and_indent (buffer, spc); 1472 pp_string (buffer, "else"); 1473 newline_and_indent (buffer, spc+2); 1474 pp_character (buffer, '{'); 1475 newline_and_indent (buffer, spc+4); 1476 dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4, 1477 flags, true); 1478 newline_and_indent (buffer, spc+2); 1479 pp_character (buffer, '}'); 1480 } 1481 } 1482 is_expr = false; 1483 } 1484 else 1485 { 1486 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1487 pp_space (buffer); 1488 pp_character (buffer, '?'); 1489 pp_space (buffer); 1490 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 1491 pp_space (buffer); 1492 pp_character (buffer, ':'); 1493 pp_space (buffer); 1494 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); 1495 } 1496 break; 1497 1498 case BIND_EXPR: 1499 pp_character (buffer, '{'); 1500 if (!(flags & TDF_SLIM)) 1501 { 1502 if (BIND_EXPR_VARS (node)) 1503 { 1504 pp_newline (buffer); 1505 1506 for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0)) 1507 { 1508 print_declaration (buffer, op0, spc+2, flags); 1509 pp_newline (buffer); 1510 } 1511 } 1512 1513 newline_and_indent (buffer, spc+2); 1514 dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true); 1515 newline_and_indent (buffer, spc); 1516 pp_character (buffer, '}'); 1517 } 1518 is_expr = false; 1519 break; 1520 1521 case CALL_EXPR: 1522 print_call_name (buffer, CALL_EXPR_FN (node), flags); 1523 1524 /* Print parameters. */ 1525 pp_space (buffer); 1526 pp_character (buffer, '('); 1527 { 1528 tree arg; 1529 call_expr_arg_iterator iter; 1530 FOR_EACH_CALL_EXPR_ARG (arg, iter, node) 1531 { 1532 dump_generic_node (buffer, arg, spc, flags, false); 1533 if (more_call_expr_args_p (&iter)) 1534 { 1535 pp_character (buffer, ','); 1536 pp_space (buffer); 1537 } 1538 } 1539 } 1540 if (CALL_EXPR_VA_ARG_PACK (node)) 1541 { 1542 if (call_expr_nargs (node) > 0) 1543 { 1544 pp_character (buffer, ','); 1545 pp_space (buffer); 1546 } 1547 pp_string (buffer, "__builtin_va_arg_pack ()"); 1548 } 1549 pp_character (buffer, ')'); 1550 1551 op1 = CALL_EXPR_STATIC_CHAIN (node); 1552 if (op1) 1553 { 1554 pp_string (buffer, " [static-chain: "); 1555 dump_generic_node (buffer, op1, spc, flags, false); 1556 pp_character (buffer, ']'); 1557 } 1558 1559 if (CALL_EXPR_RETURN_SLOT_OPT (node)) 1560 pp_string (buffer, " [return slot optimization]"); 1561 if (CALL_EXPR_TAILCALL (node)) 1562 pp_string (buffer, " [tail call]"); 1563 break; 1564 1565 case WITH_CLEANUP_EXPR: 1566 NIY; 1567 break; 1568 1569 case CLEANUP_POINT_EXPR: 1570 pp_string (buffer, "<<cleanup_point "); 1571 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1572 pp_string (buffer, ">>"); 1573 break; 1574 1575 case PLACEHOLDER_EXPR: 1576 pp_string (buffer, "<PLACEHOLDER_EXPR "); 1577 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); 1578 pp_character (buffer, '>'); 1579 break; 1580 1581 /* Binary arithmetic and logic expressions. */ 1582 case WIDEN_SUM_EXPR: 1583 case WIDEN_MULT_EXPR: 1584 case MULT_EXPR: 1585 case PLUS_EXPR: 1586 case POINTER_PLUS_EXPR: 1587 case MINUS_EXPR: 1588 case TRUNC_DIV_EXPR: 1589 case CEIL_DIV_EXPR: 1590 case FLOOR_DIV_EXPR: 1591 case ROUND_DIV_EXPR: 1592 case TRUNC_MOD_EXPR: 1593 case CEIL_MOD_EXPR: 1594 case FLOOR_MOD_EXPR: 1595 case ROUND_MOD_EXPR: 1596 case RDIV_EXPR: 1597 case EXACT_DIV_EXPR: 1598 case LSHIFT_EXPR: 1599 case RSHIFT_EXPR: 1600 case LROTATE_EXPR: 1601 case RROTATE_EXPR: 1602 case VEC_LSHIFT_EXPR: 1603 case VEC_RSHIFT_EXPR: 1604 case WIDEN_LSHIFT_EXPR: 1605 case BIT_IOR_EXPR: 1606 case BIT_XOR_EXPR: 1607 case BIT_AND_EXPR: 1608 case TRUTH_ANDIF_EXPR: 1609 case TRUTH_ORIF_EXPR: 1610 case TRUTH_AND_EXPR: 1611 case TRUTH_OR_EXPR: 1612 case TRUTH_XOR_EXPR: 1613 case LT_EXPR: 1614 case LE_EXPR: 1615 case GT_EXPR: 1616 case GE_EXPR: 1617 case EQ_EXPR: 1618 case NE_EXPR: 1619 case UNLT_EXPR: 1620 case UNLE_EXPR: 1621 case UNGT_EXPR: 1622 case UNGE_EXPR: 1623 case UNEQ_EXPR: 1624 case LTGT_EXPR: 1625 case ORDERED_EXPR: 1626 case UNORDERED_EXPR: 1627 { 1628 const char *op = op_symbol (node); 1629 op0 = TREE_OPERAND (node, 0); 1630 op1 = TREE_OPERAND (node, 1); 1631 1632 /* When the operands are expressions with less priority, 1633 keep semantics of the tree representation. */ 1634 if (op_prio (op0) <= op_prio (node)) 1635 { 1636 pp_character (buffer, '('); 1637 dump_generic_node (buffer, op0, spc, flags, false); 1638 pp_character (buffer, ')'); 1639 } 1640 else 1641 dump_generic_node (buffer, op0, spc, flags, false); 1642 1643 pp_space (buffer); 1644 pp_string (buffer, op); 1645 pp_space (buffer); 1646 1647 /* When the operands are expressions with less priority, 1648 keep semantics of the tree representation. */ 1649 if (op_prio (op1) <= op_prio (node)) 1650 { 1651 pp_character (buffer, '('); 1652 dump_generic_node (buffer, op1, spc, flags, false); 1653 pp_character (buffer, ')'); 1654 } 1655 else 1656 dump_generic_node (buffer, op1, spc, flags, false); 1657 } 1658 break; 1659 1660 /* Unary arithmetic and logic expressions. */ 1661 case NEGATE_EXPR: 1662 case BIT_NOT_EXPR: 1663 case TRUTH_NOT_EXPR: 1664 case ADDR_EXPR: 1665 case PREDECREMENT_EXPR: 1666 case PREINCREMENT_EXPR: 1667 case INDIRECT_REF: 1668 if (TREE_CODE (node) == ADDR_EXPR 1669 && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST 1670 || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL)) 1671 ; /* Do not output '&' for strings and function pointers. */ 1672 else 1673 pp_string (buffer, op_symbol (node)); 1674 1675 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node)) 1676 { 1677 pp_character (buffer, '('); 1678 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1679 pp_character (buffer, ')'); 1680 } 1681 else 1682 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1683 break; 1684 1685 case POSTDECREMENT_EXPR: 1686 case POSTINCREMENT_EXPR: 1687 if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node)) 1688 { 1689 pp_character (buffer, '('); 1690 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1691 pp_character (buffer, ')'); 1692 } 1693 else 1694 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1695 pp_string (buffer, op_symbol (node)); 1696 break; 1697 1698 case MIN_EXPR: 1699 pp_string (buffer, "MIN_EXPR <"); 1700 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1701 pp_string (buffer, ", "); 1702 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 1703 pp_character (buffer, '>'); 1704 break; 1705 1706 case MAX_EXPR: 1707 pp_string (buffer, "MAX_EXPR <"); 1708 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1709 pp_string (buffer, ", "); 1710 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 1711 pp_character (buffer, '>'); 1712 break; 1713 1714 case ABS_EXPR: 1715 pp_string (buffer, "ABS_EXPR <"); 1716 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1717 pp_character (buffer, '>'); 1718 break; 1719 1720 case RANGE_EXPR: 1721 NIY; 1722 break; 1723 1724 case ADDR_SPACE_CONVERT_EXPR: 1725 case FIXED_CONVERT_EXPR: 1726 case FIX_TRUNC_EXPR: 1727 case FLOAT_EXPR: 1728 CASE_CONVERT: 1729 type = TREE_TYPE (node); 1730 op0 = TREE_OPERAND (node, 0); 1731 if (type != TREE_TYPE (op0)) 1732 { 1733 pp_character (buffer, '('); 1734 dump_generic_node (buffer, type, spc, flags, false); 1735 pp_string (buffer, ") "); 1736 } 1737 if (op_prio (op0) < op_prio (node)) 1738 pp_character (buffer, '('); 1739 dump_generic_node (buffer, op0, spc, flags, false); 1740 if (op_prio (op0) < op_prio (node)) 1741 pp_character (buffer, ')'); 1742 break; 1743 1744 case VIEW_CONVERT_EXPR: 1745 pp_string (buffer, "VIEW_CONVERT_EXPR<"); 1746 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false); 1747 pp_string (buffer, ">("); 1748 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1749 pp_character (buffer, ')'); 1750 break; 1751 1752 case PAREN_EXPR: 1753 pp_string (buffer, "(("); 1754 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1755 pp_string (buffer, "))"); 1756 break; 1757 1758 case NON_LVALUE_EXPR: 1759 pp_string (buffer, "NON_LVALUE_EXPR <"); 1760 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1761 pp_character (buffer, '>'); 1762 break; 1763 1764 case SAVE_EXPR: 1765 pp_string (buffer, "SAVE_EXPR <"); 1766 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1767 pp_character (buffer, '>'); 1768 break; 1769 1770 case COMPLEX_EXPR: 1771 pp_string (buffer, "COMPLEX_EXPR <"); 1772 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1773 pp_string (buffer, ", "); 1774 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 1775 pp_string (buffer, ">"); 1776 break; 1777 1778 case CONJ_EXPR: 1779 pp_string (buffer, "CONJ_EXPR <"); 1780 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1781 pp_string (buffer, ">"); 1782 break; 1783 1784 case REALPART_EXPR: 1785 pp_string (buffer, "REALPART_EXPR <"); 1786 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1787 pp_string (buffer, ">"); 1788 break; 1789 1790 case IMAGPART_EXPR: 1791 pp_string (buffer, "IMAGPART_EXPR <"); 1792 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1793 pp_string (buffer, ">"); 1794 break; 1795 1796 case VA_ARG_EXPR: 1797 pp_string (buffer, "VA_ARG_EXPR <"); 1798 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1799 pp_string (buffer, ">"); 1800 break; 1801 1802 case TRY_FINALLY_EXPR: 1803 case TRY_CATCH_EXPR: 1804 pp_string (buffer, "try"); 1805 newline_and_indent (buffer, spc+2); 1806 pp_string (buffer, "{"); 1807 newline_and_indent (buffer, spc+4); 1808 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true); 1809 newline_and_indent (buffer, spc+2); 1810 pp_string (buffer, "}"); 1811 newline_and_indent (buffer, spc); 1812 pp_string (buffer, 1813 (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally"); 1814 newline_and_indent (buffer, spc+2); 1815 pp_string (buffer, "{"); 1816 newline_and_indent (buffer, spc+4); 1817 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true); 1818 newline_and_indent (buffer, spc+2); 1819 pp_string (buffer, "}"); 1820 is_expr = false; 1821 break; 1822 1823 case CATCH_EXPR: 1824 pp_string (buffer, "catch ("); 1825 dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false); 1826 pp_string (buffer, ")"); 1827 newline_and_indent (buffer, spc+2); 1828 pp_string (buffer, "{"); 1829 newline_and_indent (buffer, spc+4); 1830 dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true); 1831 newline_and_indent (buffer, spc+2); 1832 pp_string (buffer, "}"); 1833 is_expr = false; 1834 break; 1835 1836 case EH_FILTER_EXPR: 1837 pp_string (buffer, "<<<eh_filter ("); 1838 dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false); 1839 pp_string (buffer, ")>>>"); 1840 newline_and_indent (buffer, spc+2); 1841 pp_string (buffer, "{"); 1842 newline_and_indent (buffer, spc+4); 1843 dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true); 1844 newline_and_indent (buffer, spc+2); 1845 pp_string (buffer, "}"); 1846 is_expr = false; 1847 break; 1848 1849 case LABEL_EXPR: 1850 op0 = TREE_OPERAND (node, 0); 1851 /* If this is for break or continue, don't bother printing it. */ 1852 if (DECL_NAME (op0)) 1853 { 1854 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0)); 1855 if (strcmp (name, "break") == 0 1856 || strcmp (name, "continue") == 0) 1857 break; 1858 } 1859 dump_generic_node (buffer, op0, spc, flags, false); 1860 pp_character (buffer, ':'); 1861 if (DECL_NONLOCAL (op0)) 1862 pp_string (buffer, " [non-local]"); 1863 break; 1864 1865 case LOOP_EXPR: 1866 pp_string (buffer, "while (1)"); 1867 if (!(flags & TDF_SLIM)) 1868 { 1869 newline_and_indent (buffer, spc+2); 1870 pp_character (buffer, '{'); 1871 newline_and_indent (buffer, spc+4); 1872 dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true); 1873 newline_and_indent (buffer, spc+2); 1874 pp_character (buffer, '}'); 1875 } 1876 is_expr = false; 1877 break; 1878 1879 case PREDICT_EXPR: 1880 pp_string (buffer, "// predicted "); 1881 if (PREDICT_EXPR_OUTCOME (node)) 1882 pp_string (buffer, "likely by "); 1883 else 1884 pp_string (buffer, "unlikely by "); 1885 pp_string (buffer, predictor_name (PREDICT_EXPR_PREDICTOR (node))); 1886 pp_string (buffer, " predictor."); 1887 break; 1888 1889 case RETURN_EXPR: 1890 pp_string (buffer, "return"); 1891 op0 = TREE_OPERAND (node, 0); 1892 if (op0) 1893 { 1894 pp_space (buffer); 1895 if (TREE_CODE (op0) == MODIFY_EXPR) 1896 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 1897 spc, flags, false); 1898 else 1899 dump_generic_node (buffer, op0, spc, flags, false); 1900 } 1901 break; 1902 1903 case EXIT_EXPR: 1904 pp_string (buffer, "if ("); 1905 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 1906 pp_string (buffer, ") break"); 1907 break; 1908 1909 case SWITCH_EXPR: 1910 pp_string (buffer, "switch ("); 1911 dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false); 1912 pp_character (buffer, ')'); 1913 if (!(flags & TDF_SLIM)) 1914 { 1915 newline_and_indent (buffer, spc+2); 1916 pp_character (buffer, '{'); 1917 if (SWITCH_BODY (node)) 1918 { 1919 newline_and_indent (buffer, spc+4); 1920 dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags, 1921 true); 1922 } 1923 else 1924 { 1925 tree vec = SWITCH_LABELS (node); 1926 size_t i, n = TREE_VEC_LENGTH (vec); 1927 for (i = 0; i < n; ++i) 1928 { 1929 tree elt = TREE_VEC_ELT (vec, i); 1930 newline_and_indent (buffer, spc+4); 1931 if (elt) 1932 { 1933 dump_generic_node (buffer, elt, spc+4, flags, false); 1934 pp_string (buffer, " goto "); 1935 dump_generic_node (buffer, CASE_LABEL (elt), spc+4, 1936 flags, true); 1937 pp_semicolon (buffer); 1938 } 1939 else 1940 pp_string (buffer, "case ???: goto ???;"); 1941 } 1942 } 1943 newline_and_indent (buffer, spc+2); 1944 pp_character (buffer, '}'); 1945 } 1946 is_expr = false; 1947 break; 1948 1949 case GOTO_EXPR: 1950 op0 = GOTO_DESTINATION (node); 1951 if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0)) 1952 { 1953 const char *name = IDENTIFIER_POINTER (DECL_NAME (op0)); 1954 if (strcmp (name, "break") == 0 1955 || strcmp (name, "continue") == 0) 1956 { 1957 pp_string (buffer, name); 1958 break; 1959 } 1960 } 1961 pp_string (buffer, "goto "); 1962 dump_generic_node (buffer, op0, spc, flags, false); 1963 break; 1964 1965 case ASM_EXPR: 1966 pp_string (buffer, "__asm__"); 1967 if (ASM_VOLATILE_P (node)) 1968 pp_string (buffer, " __volatile__"); 1969 pp_character (buffer, '('); 1970 dump_generic_node (buffer, ASM_STRING (node), spc, flags, false); 1971 pp_character (buffer, ':'); 1972 dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false); 1973 pp_character (buffer, ':'); 1974 dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false); 1975 if (ASM_CLOBBERS (node)) 1976 { 1977 pp_character (buffer, ':'); 1978 dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false); 1979 } 1980 pp_string (buffer, ")"); 1981 break; 1982 1983 case CASE_LABEL_EXPR: 1984 if (CASE_LOW (node) && CASE_HIGH (node)) 1985 { 1986 pp_string (buffer, "case "); 1987 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false); 1988 pp_string (buffer, " ... "); 1989 dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false); 1990 } 1991 else if (CASE_LOW (node)) 1992 { 1993 pp_string (buffer, "case "); 1994 dump_generic_node (buffer, CASE_LOW (node), spc, flags, false); 1995 } 1996 else 1997 pp_string (buffer, "default"); 1998 pp_character (buffer, ':'); 1999 break; 2000 2001 case OBJ_TYPE_REF: 2002 pp_string (buffer, "OBJ_TYPE_REF("); 2003 dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false); 2004 pp_character (buffer, ';'); 2005 dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false); 2006 pp_character (buffer, '-'); 2007 pp_character (buffer, '>'); 2008 dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false); 2009 pp_character (buffer, ')'); 2010 break; 2011 2012 case SSA_NAME: 2013 dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false); 2014 pp_string (buffer, "_"); 2015 pp_decimal_int (buffer, SSA_NAME_VERSION (node)); 2016 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node)) 2017 pp_string (buffer, "(ab)"); 2018 else if (SSA_NAME_IS_DEFAULT_DEF (node)) 2019 pp_string (buffer, "(D)"); 2020 break; 2021 2022 case WITH_SIZE_EXPR: 2023 pp_string (buffer, "WITH_SIZE_EXPR <"); 2024 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2025 pp_string (buffer, ", "); 2026 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2027 pp_string (buffer, ">"); 2028 break; 2029 2030 case ASSERT_EXPR: 2031 pp_string (buffer, "ASSERT_EXPR <"); 2032 dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false); 2033 pp_string (buffer, ", "); 2034 dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false); 2035 pp_string (buffer, ">"); 2036 break; 2037 2038 case SCEV_KNOWN: 2039 pp_string (buffer, "scev_known"); 2040 break; 2041 2042 case SCEV_NOT_KNOWN: 2043 pp_string (buffer, "scev_not_known"); 2044 break; 2045 2046 case POLYNOMIAL_CHREC: 2047 pp_string (buffer, "{"); 2048 dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false); 2049 pp_string (buffer, ", +, "); 2050 dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false); 2051 pp_string (buffer, "}_"); 2052 dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false); 2053 is_stmt = false; 2054 break; 2055 2056 case REALIGN_LOAD_EXPR: 2057 pp_string (buffer, "REALIGN_LOAD <"); 2058 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2059 pp_string (buffer, ", "); 2060 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2061 pp_string (buffer, ", "); 2062 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); 2063 pp_string (buffer, ">"); 2064 break; 2065 2066 case VEC_COND_EXPR: 2067 pp_string (buffer, " VEC_COND_EXPR < "); 2068 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2069 pp_string (buffer, " , "); 2070 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2071 pp_string (buffer, " , "); 2072 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); 2073 pp_string (buffer, " > "); 2074 break; 2075 2076 case VEC_PERM_EXPR: 2077 pp_string (buffer, " VEC_PERM_EXPR < "); 2078 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2079 pp_string (buffer, " , "); 2080 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2081 pp_string (buffer, " , "); 2082 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); 2083 pp_string (buffer, " > "); 2084 break; 2085 2086 case DOT_PROD_EXPR: 2087 pp_string (buffer, " DOT_PROD_EXPR < "); 2088 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2089 pp_string (buffer, ", "); 2090 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2091 pp_string (buffer, ", "); 2092 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); 2093 pp_string (buffer, " > "); 2094 break; 2095 2096 case WIDEN_MULT_PLUS_EXPR: 2097 pp_string (buffer, " WIDEN_MULT_PLUS_EXPR < "); 2098 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2099 pp_string (buffer, ", "); 2100 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2101 pp_string (buffer, ", "); 2102 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); 2103 pp_string (buffer, " > "); 2104 break; 2105 2106 case WIDEN_MULT_MINUS_EXPR: 2107 pp_string (buffer, " WIDEN_MULT_MINUS_EXPR < "); 2108 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2109 pp_string (buffer, ", "); 2110 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2111 pp_string (buffer, ", "); 2112 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); 2113 pp_string (buffer, " > "); 2114 break; 2115 2116 case FMA_EXPR: 2117 pp_string (buffer, " FMA_EXPR < "); 2118 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2119 pp_string (buffer, ", "); 2120 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2121 pp_string (buffer, ", "); 2122 dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false); 2123 pp_string (buffer, " > "); 2124 break; 2125 2126 case OMP_PARALLEL: 2127 pp_string (buffer, "#pragma omp parallel"); 2128 dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags); 2129 2130 dump_omp_body: 2131 if (!(flags & TDF_SLIM) && OMP_BODY (node)) 2132 { 2133 newline_and_indent (buffer, spc + 2); 2134 pp_character (buffer, '{'); 2135 newline_and_indent (buffer, spc + 4); 2136 dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false); 2137 newline_and_indent (buffer, spc + 2); 2138 pp_character (buffer, '}'); 2139 } 2140 is_expr = false; 2141 break; 2142 2143 case OMP_TASK: 2144 pp_string (buffer, "#pragma omp task"); 2145 dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags); 2146 goto dump_omp_body; 2147 2148 case OMP_FOR: 2149 pp_string (buffer, "#pragma omp for"); 2150 dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags); 2151 2152 if (!(flags & TDF_SLIM)) 2153 { 2154 int i; 2155 2156 if (OMP_FOR_PRE_BODY (node)) 2157 { 2158 newline_and_indent (buffer, spc + 2); 2159 pp_character (buffer, '{'); 2160 spc += 4; 2161 newline_and_indent (buffer, spc); 2162 dump_generic_node (buffer, OMP_FOR_PRE_BODY (node), 2163 spc, flags, false); 2164 } 2165 spc -= 2; 2166 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++) 2167 { 2168 spc += 2; 2169 newline_and_indent (buffer, spc); 2170 pp_string (buffer, "for ("); 2171 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i), 2172 spc, flags, false); 2173 pp_string (buffer, "; "); 2174 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i), 2175 spc, flags, false); 2176 pp_string (buffer, "; "); 2177 dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i), 2178 spc, flags, false); 2179 pp_string (buffer, ")"); 2180 } 2181 if (OMP_FOR_BODY (node)) 2182 { 2183 newline_and_indent (buffer, spc + 2); 2184 pp_character (buffer, '{'); 2185 newline_and_indent (buffer, spc + 4); 2186 dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags, 2187 false); 2188 newline_and_indent (buffer, spc + 2); 2189 pp_character (buffer, '}'); 2190 } 2191 spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2; 2192 if (OMP_FOR_PRE_BODY (node)) 2193 { 2194 spc -= 4; 2195 newline_and_indent (buffer, spc + 2); 2196 pp_character (buffer, '}'); 2197 } 2198 } 2199 is_expr = false; 2200 break; 2201 2202 case OMP_SECTIONS: 2203 pp_string (buffer, "#pragma omp sections"); 2204 dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags); 2205 goto dump_omp_body; 2206 2207 case OMP_SECTION: 2208 pp_string (buffer, "#pragma omp section"); 2209 goto dump_omp_body; 2210 2211 case OMP_MASTER: 2212 pp_string (buffer, "#pragma omp master"); 2213 goto dump_omp_body; 2214 2215 case OMP_ORDERED: 2216 pp_string (buffer, "#pragma omp ordered"); 2217 goto dump_omp_body; 2218 2219 case OMP_CRITICAL: 2220 pp_string (buffer, "#pragma omp critical"); 2221 if (OMP_CRITICAL_NAME (node)) 2222 { 2223 pp_space (buffer); 2224 pp_character (buffer, '('); 2225 dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc, 2226 flags, false); 2227 pp_character (buffer, ')'); 2228 } 2229 goto dump_omp_body; 2230 2231 case OMP_ATOMIC: 2232 pp_string (buffer, "#pragma omp atomic"); 2233 newline_and_indent (buffer, spc + 2); 2234 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2235 pp_space (buffer); 2236 pp_character (buffer, '='); 2237 pp_space (buffer); 2238 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2239 break; 2240 2241 case OMP_ATOMIC_READ: 2242 pp_string (buffer, "#pragma omp atomic read"); 2243 newline_and_indent (buffer, spc + 2); 2244 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2245 pp_space (buffer); 2246 break; 2247 2248 case OMP_ATOMIC_CAPTURE_OLD: 2249 case OMP_ATOMIC_CAPTURE_NEW: 2250 pp_string (buffer, "#pragma omp atomic capture"); 2251 newline_and_indent (buffer, spc + 2); 2252 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2253 pp_space (buffer); 2254 pp_character (buffer, '='); 2255 pp_space (buffer); 2256 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2257 break; 2258 2259 case OMP_SINGLE: 2260 pp_string (buffer, "#pragma omp single"); 2261 dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags); 2262 goto dump_omp_body; 2263 2264 case OMP_CLAUSE: 2265 dump_omp_clause (buffer, node, spc, flags); 2266 is_expr = false; 2267 break; 2268 2269 case TRANSACTION_EXPR: 2270 if (TRANSACTION_EXPR_OUTER (node)) 2271 pp_string (buffer, "__transaction_atomic [[outer]]"); 2272 else if (TRANSACTION_EXPR_RELAXED (node)) 2273 pp_string (buffer, "__transaction_relaxed"); 2274 else 2275 pp_string (buffer, "__transaction_atomic"); 2276 if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node)) 2277 { 2278 newline_and_indent (buffer, spc); 2279 pp_character (buffer, '{'); 2280 newline_and_indent (buffer, spc + 2); 2281 dump_generic_node (buffer, TRANSACTION_EXPR_BODY (node), 2282 spc + 2, flags, false); 2283 newline_and_indent (buffer, spc); 2284 pp_character (buffer, '}'); 2285 } 2286 is_expr = false; 2287 break; 2288 2289 case REDUC_MAX_EXPR: 2290 pp_string (buffer, " REDUC_MAX_EXPR < "); 2291 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2292 pp_string (buffer, " > "); 2293 break; 2294 2295 case REDUC_MIN_EXPR: 2296 pp_string (buffer, " REDUC_MIN_EXPR < "); 2297 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2298 pp_string (buffer, " > "); 2299 break; 2300 2301 case REDUC_PLUS_EXPR: 2302 pp_string (buffer, " REDUC_PLUS_EXPR < "); 2303 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2304 pp_string (buffer, " > "); 2305 break; 2306 2307 case VEC_WIDEN_MULT_HI_EXPR: 2308 pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < "); 2309 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2310 pp_string (buffer, ", "); 2311 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2312 pp_string (buffer, " > "); 2313 break; 2314 2315 case VEC_WIDEN_MULT_LO_EXPR: 2316 pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < "); 2317 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2318 pp_string (buffer, ", "); 2319 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2320 pp_string (buffer, " > "); 2321 break; 2322 2323 case VEC_WIDEN_LSHIFT_HI_EXPR: 2324 pp_string (buffer, " VEC_WIDEN_LSHIFT_HI_EXPR < "); 2325 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2326 pp_string (buffer, ", "); 2327 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2328 pp_string (buffer, " > "); 2329 break; 2330 2331 case VEC_WIDEN_LSHIFT_LO_EXPR: 2332 pp_string (buffer, " VEC_WIDEN_LSHIFT_HI_EXPR < "); 2333 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2334 pp_string (buffer, ", "); 2335 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2336 pp_string (buffer, " > "); 2337 break; 2338 2339 case VEC_UNPACK_HI_EXPR: 2340 pp_string (buffer, " VEC_UNPACK_HI_EXPR < "); 2341 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2342 pp_string (buffer, " > "); 2343 break; 2344 2345 case VEC_UNPACK_LO_EXPR: 2346 pp_string (buffer, " VEC_UNPACK_LO_EXPR < "); 2347 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2348 pp_string (buffer, " > "); 2349 break; 2350 2351 case VEC_UNPACK_FLOAT_HI_EXPR: 2352 pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < "); 2353 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2354 pp_string (buffer, " > "); 2355 break; 2356 2357 case VEC_UNPACK_FLOAT_LO_EXPR: 2358 pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < "); 2359 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2360 pp_string (buffer, " > "); 2361 break; 2362 2363 case VEC_PACK_TRUNC_EXPR: 2364 pp_string (buffer, " VEC_PACK_TRUNC_EXPR < "); 2365 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2366 pp_string (buffer, ", "); 2367 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2368 pp_string (buffer, " > "); 2369 break; 2370 2371 case VEC_PACK_SAT_EXPR: 2372 pp_string (buffer, " VEC_PACK_SAT_EXPR < "); 2373 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2374 pp_string (buffer, ", "); 2375 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2376 pp_string (buffer, " > "); 2377 break; 2378 2379 case VEC_PACK_FIX_TRUNC_EXPR: 2380 pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < "); 2381 dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false); 2382 pp_string (buffer, ", "); 2383 dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false); 2384 pp_string (buffer, " > "); 2385 break; 2386 2387 case BLOCK: 2388 dump_block_node (buffer, node, spc, flags); 2389 break; 2390 2391 default: 2392 NIY; 2393 } 2394 2395 if (is_stmt && is_expr) 2396 pp_semicolon (buffer); 2397 2398 /* If we're building a diagnostic, the formatted text will be written 2399 into BUFFER's stream by the caller; otherwise, write it now. */ 2400 if (!(flags & TDF_DIAGNOSTIC)) 2401 pp_write_text_to_stream (buffer); 2402 2403 return spc; 2404 } 2405 2406 /* Print the declaration of a variable. */ 2407 2408 void 2409 print_declaration (pretty_printer *buffer, tree t, int spc, int flags) 2410 { 2411 INDENT (spc); 2412 2413 if (TREE_CODE (t) == TYPE_DECL) 2414 pp_string (buffer, "typedef "); 2415 2416 if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t)) 2417 pp_string (buffer, "register "); 2418 2419 if (TREE_PUBLIC (t) && DECL_EXTERNAL (t)) 2420 pp_string (buffer, "extern "); 2421 else if (TREE_STATIC (t)) 2422 pp_string (buffer, "static "); 2423 2424 /* Print the type and name. */ 2425 if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE) 2426 { 2427 tree tmp; 2428 2429 /* Print array's type. */ 2430 tmp = TREE_TYPE (t); 2431 while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE) 2432 tmp = TREE_TYPE (tmp); 2433 dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false); 2434 2435 /* Print variable's name. */ 2436 pp_space (buffer); 2437 dump_generic_node (buffer, t, spc, flags, false); 2438 2439 /* Print the dimensions. */ 2440 tmp = TREE_TYPE (t); 2441 while (TREE_CODE (tmp) == ARRAY_TYPE) 2442 { 2443 dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags); 2444 tmp = TREE_TYPE (tmp); 2445 } 2446 } 2447 else if (TREE_CODE (t) == FUNCTION_DECL) 2448 { 2449 dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false); 2450 pp_space (buffer); 2451 dump_decl_name (buffer, t, flags); 2452 dump_function_declaration (buffer, TREE_TYPE (t), spc, flags); 2453 } 2454 else 2455 { 2456 /* Print type declaration. */ 2457 dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false); 2458 2459 /* Print variable's name. */ 2460 pp_space (buffer); 2461 dump_generic_node (buffer, t, spc, flags, false); 2462 } 2463 2464 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t)) 2465 { 2466 pp_string (buffer, " __asm__ "); 2467 pp_character (buffer, '('); 2468 dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false); 2469 pp_character (buffer, ')'); 2470 } 2471 2472 /* The initial value of a function serves to determine whether the function 2473 is declared or defined. So the following does not apply to function 2474 nodes. */ 2475 if (TREE_CODE (t) != FUNCTION_DECL) 2476 { 2477 /* Print the initial value. */ 2478 if (DECL_INITIAL (t)) 2479 { 2480 pp_space (buffer); 2481 pp_character (buffer, '='); 2482 pp_space (buffer); 2483 dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false); 2484 } 2485 } 2486 2487 if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t)) 2488 { 2489 pp_string (buffer, " [value-expr: "); 2490 dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false); 2491 pp_character (buffer, ']'); 2492 } 2493 2494 pp_character (buffer, ';'); 2495 } 2496 2497 2498 /* Prints a structure: name, fields, and methods. 2499 FIXME: Still incomplete. */ 2500 2501 static void 2502 print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags) 2503 { 2504 /* Print the name of the structure. */ 2505 if (TYPE_NAME (node)) 2506 { 2507 INDENT (spc); 2508 if (TREE_CODE (node) == RECORD_TYPE) 2509 pp_string (buffer, "struct "); 2510 else if ((TREE_CODE (node) == UNION_TYPE 2511 || TREE_CODE (node) == QUAL_UNION_TYPE)) 2512 pp_string (buffer, "union "); 2513 2514 dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false); 2515 } 2516 2517 /* Print the contents of the structure. */ 2518 pp_newline (buffer); 2519 INDENT (spc); 2520 pp_character (buffer, '{'); 2521 pp_newline (buffer); 2522 2523 /* Print the fields of the structure. */ 2524 { 2525 tree tmp; 2526 tmp = TYPE_FIELDS (node); 2527 while (tmp) 2528 { 2529 /* Avoid to print recursively the structure. */ 2530 /* FIXME : Not implemented correctly..., 2531 what about the case when we have a cycle in the contain graph? ... 2532 Maybe this could be solved by looking at the scope in which the 2533 structure was declared. */ 2534 if (TREE_TYPE (tmp) != node 2535 && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE 2536 || TREE_TYPE (TREE_TYPE (tmp)) != node)) 2537 { 2538 print_declaration (buffer, tmp, spc+2, flags); 2539 pp_newline (buffer); 2540 } 2541 tmp = DECL_CHAIN (tmp); 2542 } 2543 } 2544 INDENT (spc); 2545 pp_character (buffer, '}'); 2546 } 2547 2548 /* Return the priority of the operator CODE. 2549 2550 From lowest to highest precedence with either left-to-right (L-R) 2551 or right-to-left (R-L) associativity]: 2552 2553 1 [L-R] , 2554 2 [R-L] = += -= *= /= %= &= ^= |= <<= >>= 2555 3 [R-L] ?: 2556 4 [L-R] || 2557 5 [L-R] && 2558 6 [L-R] | 2559 7 [L-R] ^ 2560 8 [L-R] & 2561 9 [L-R] == != 2562 10 [L-R] < <= > >= 2563 11 [L-R] << >> 2564 12 [L-R] + - 2565 13 [L-R] * / % 2566 14 [R-L] ! ~ ++ -- + - * & (type) sizeof 2567 15 [L-R] fn() [] -> . 2568 2569 unary +, - and * have higher precedence than the corresponding binary 2570 operators. */ 2571 2572 int 2573 op_code_prio (enum tree_code code) 2574 { 2575 switch (code) 2576 { 2577 case TREE_LIST: 2578 case COMPOUND_EXPR: 2579 case BIND_EXPR: 2580 return 1; 2581 2582 case MODIFY_EXPR: 2583 case INIT_EXPR: 2584 return 2; 2585 2586 case COND_EXPR: 2587 return 3; 2588 2589 case TRUTH_OR_EXPR: 2590 case TRUTH_ORIF_EXPR: 2591 return 4; 2592 2593 case TRUTH_AND_EXPR: 2594 case TRUTH_ANDIF_EXPR: 2595 return 5; 2596 2597 case BIT_IOR_EXPR: 2598 return 6; 2599 2600 case BIT_XOR_EXPR: 2601 case TRUTH_XOR_EXPR: 2602 return 7; 2603 2604 case BIT_AND_EXPR: 2605 return 8; 2606 2607 case EQ_EXPR: 2608 case NE_EXPR: 2609 return 9; 2610 2611 case UNLT_EXPR: 2612 case UNLE_EXPR: 2613 case UNGT_EXPR: 2614 case UNGE_EXPR: 2615 case UNEQ_EXPR: 2616 case LTGT_EXPR: 2617 case ORDERED_EXPR: 2618 case UNORDERED_EXPR: 2619 case LT_EXPR: 2620 case LE_EXPR: 2621 case GT_EXPR: 2622 case GE_EXPR: 2623 return 10; 2624 2625 case LSHIFT_EXPR: 2626 case RSHIFT_EXPR: 2627 case LROTATE_EXPR: 2628 case RROTATE_EXPR: 2629 case VEC_WIDEN_LSHIFT_HI_EXPR: 2630 case VEC_WIDEN_LSHIFT_LO_EXPR: 2631 case WIDEN_LSHIFT_EXPR: 2632 return 11; 2633 2634 case WIDEN_SUM_EXPR: 2635 case PLUS_EXPR: 2636 case POINTER_PLUS_EXPR: 2637 case MINUS_EXPR: 2638 return 12; 2639 2640 case VEC_WIDEN_MULT_HI_EXPR: 2641 case VEC_WIDEN_MULT_LO_EXPR: 2642 case WIDEN_MULT_EXPR: 2643 case DOT_PROD_EXPR: 2644 case WIDEN_MULT_PLUS_EXPR: 2645 case WIDEN_MULT_MINUS_EXPR: 2646 case MULT_EXPR: 2647 case TRUNC_DIV_EXPR: 2648 case CEIL_DIV_EXPR: 2649 case FLOOR_DIV_EXPR: 2650 case ROUND_DIV_EXPR: 2651 case RDIV_EXPR: 2652 case EXACT_DIV_EXPR: 2653 case TRUNC_MOD_EXPR: 2654 case CEIL_MOD_EXPR: 2655 case FLOOR_MOD_EXPR: 2656 case ROUND_MOD_EXPR: 2657 case FMA_EXPR: 2658 return 13; 2659 2660 case TRUTH_NOT_EXPR: 2661 case BIT_NOT_EXPR: 2662 case POSTINCREMENT_EXPR: 2663 case POSTDECREMENT_EXPR: 2664 case PREINCREMENT_EXPR: 2665 case PREDECREMENT_EXPR: 2666 case NEGATE_EXPR: 2667 case INDIRECT_REF: 2668 case ADDR_EXPR: 2669 case FLOAT_EXPR: 2670 CASE_CONVERT: 2671 case FIX_TRUNC_EXPR: 2672 case TARGET_EXPR: 2673 return 14; 2674 2675 case CALL_EXPR: 2676 case ARRAY_REF: 2677 case ARRAY_RANGE_REF: 2678 case COMPONENT_REF: 2679 return 15; 2680 2681 /* Special expressions. */ 2682 case MIN_EXPR: 2683 case MAX_EXPR: 2684 case ABS_EXPR: 2685 case REALPART_EXPR: 2686 case IMAGPART_EXPR: 2687 case REDUC_MAX_EXPR: 2688 case REDUC_MIN_EXPR: 2689 case REDUC_PLUS_EXPR: 2690 case VEC_LSHIFT_EXPR: 2691 case VEC_RSHIFT_EXPR: 2692 case VEC_UNPACK_HI_EXPR: 2693 case VEC_UNPACK_LO_EXPR: 2694 case VEC_UNPACK_FLOAT_HI_EXPR: 2695 case VEC_UNPACK_FLOAT_LO_EXPR: 2696 case VEC_PACK_TRUNC_EXPR: 2697 case VEC_PACK_SAT_EXPR: 2698 return 16; 2699 2700 default: 2701 /* Return an arbitrarily high precedence to avoid surrounding single 2702 VAR_DECLs in ()s. */ 2703 return 9999; 2704 } 2705 } 2706 2707 /* Return the priority of the operator OP. */ 2708 2709 int 2710 op_prio (const_tree op) 2711 { 2712 enum tree_code code; 2713 2714 if (op == NULL) 2715 return 9999; 2716 2717 code = TREE_CODE (op); 2718 if (code == SAVE_EXPR || code == NON_LVALUE_EXPR) 2719 return op_prio (TREE_OPERAND (op, 0)); 2720 2721 return op_code_prio (code); 2722 } 2723 2724 /* Return the symbol associated with operator CODE. */ 2725 2726 const char * 2727 op_symbol_code (enum tree_code code) 2728 { 2729 switch (code) 2730 { 2731 case MODIFY_EXPR: 2732 return "="; 2733 2734 case TRUTH_OR_EXPR: 2735 case TRUTH_ORIF_EXPR: 2736 return "||"; 2737 2738 case TRUTH_AND_EXPR: 2739 case TRUTH_ANDIF_EXPR: 2740 return "&&"; 2741 2742 case BIT_IOR_EXPR: 2743 return "|"; 2744 2745 case TRUTH_XOR_EXPR: 2746 case BIT_XOR_EXPR: 2747 return "^"; 2748 2749 case ADDR_EXPR: 2750 case BIT_AND_EXPR: 2751 return "&"; 2752 2753 case ORDERED_EXPR: 2754 return "ord"; 2755 case UNORDERED_EXPR: 2756 return "unord"; 2757 2758 case EQ_EXPR: 2759 return "=="; 2760 case UNEQ_EXPR: 2761 return "u=="; 2762 2763 case NE_EXPR: 2764 return "!="; 2765 2766 case LT_EXPR: 2767 return "<"; 2768 case UNLT_EXPR: 2769 return "u<"; 2770 2771 case LE_EXPR: 2772 return "<="; 2773 case UNLE_EXPR: 2774 return "u<="; 2775 2776 case GT_EXPR: 2777 return ">"; 2778 case UNGT_EXPR: 2779 return "u>"; 2780 2781 case GE_EXPR: 2782 return ">="; 2783 case UNGE_EXPR: 2784 return "u>="; 2785 2786 case LTGT_EXPR: 2787 return "<>"; 2788 2789 case LSHIFT_EXPR: 2790 return "<<"; 2791 2792 case RSHIFT_EXPR: 2793 return ">>"; 2794 2795 case LROTATE_EXPR: 2796 return "r<<"; 2797 2798 case RROTATE_EXPR: 2799 return "r>>"; 2800 2801 case VEC_LSHIFT_EXPR: 2802 return "v<<"; 2803 2804 case VEC_RSHIFT_EXPR: 2805 return "v>>"; 2806 2807 case WIDEN_LSHIFT_EXPR: 2808 return "w<<"; 2809 2810 case POINTER_PLUS_EXPR: 2811 return "+"; 2812 2813 case PLUS_EXPR: 2814 return "+"; 2815 2816 case REDUC_PLUS_EXPR: 2817 return "r+"; 2818 2819 case WIDEN_SUM_EXPR: 2820 return "w+"; 2821 2822 case WIDEN_MULT_EXPR: 2823 return "w*"; 2824 2825 case NEGATE_EXPR: 2826 case MINUS_EXPR: 2827 return "-"; 2828 2829 case BIT_NOT_EXPR: 2830 return "~"; 2831 2832 case TRUTH_NOT_EXPR: 2833 return "!"; 2834 2835 case MULT_EXPR: 2836 case INDIRECT_REF: 2837 return "*"; 2838 2839 case TRUNC_DIV_EXPR: 2840 case RDIV_EXPR: 2841 return "/"; 2842 2843 case CEIL_DIV_EXPR: 2844 return "/[cl]"; 2845 2846 case FLOOR_DIV_EXPR: 2847 return "/[fl]"; 2848 2849 case ROUND_DIV_EXPR: 2850 return "/[rd]"; 2851 2852 case EXACT_DIV_EXPR: 2853 return "/[ex]"; 2854 2855 case TRUNC_MOD_EXPR: 2856 return "%"; 2857 2858 case CEIL_MOD_EXPR: 2859 return "%[cl]"; 2860 2861 case FLOOR_MOD_EXPR: 2862 return "%[fl]"; 2863 2864 case ROUND_MOD_EXPR: 2865 return "%[rd]"; 2866 2867 case PREDECREMENT_EXPR: 2868 return " --"; 2869 2870 case PREINCREMENT_EXPR: 2871 return " ++"; 2872 2873 case POSTDECREMENT_EXPR: 2874 return "-- "; 2875 2876 case POSTINCREMENT_EXPR: 2877 return "++ "; 2878 2879 case MAX_EXPR: 2880 return "max"; 2881 2882 case MIN_EXPR: 2883 return "min"; 2884 2885 default: 2886 return "<<< ??? >>>"; 2887 } 2888 } 2889 2890 /* Return the symbol associated with operator OP. */ 2891 2892 static const char * 2893 op_symbol (const_tree op) 2894 { 2895 return op_symbol_code (TREE_CODE (op)); 2896 } 2897 2898 /* Prints the name of a call. NODE is the CALL_EXPR_FN of a CALL_EXPR or 2899 the gimple_call_fn of a GIMPLE_CALL. */ 2900 2901 void 2902 print_call_name (pretty_printer *buffer, tree node, int flags) 2903 { 2904 tree op0 = node; 2905 2906 if (TREE_CODE (op0) == NON_LVALUE_EXPR) 2907 op0 = TREE_OPERAND (op0, 0); 2908 2909 again: 2910 switch (TREE_CODE (op0)) 2911 { 2912 case VAR_DECL: 2913 case PARM_DECL: 2914 case FUNCTION_DECL: 2915 dump_function_name (buffer, op0, flags); 2916 break; 2917 2918 case ADDR_EXPR: 2919 case INDIRECT_REF: 2920 case NOP_EXPR: 2921 op0 = TREE_OPERAND (op0, 0); 2922 goto again; 2923 2924 case COND_EXPR: 2925 pp_string (buffer, "("); 2926 dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, flags, false); 2927 pp_string (buffer, ") ? "); 2928 dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, flags, false); 2929 pp_string (buffer, " : "); 2930 dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, flags, false); 2931 break; 2932 2933 case ARRAY_REF: 2934 if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL) 2935 dump_function_name (buffer, TREE_OPERAND (op0, 0), flags); 2936 else 2937 dump_generic_node (buffer, op0, 0, flags, false); 2938 break; 2939 2940 case MEM_REF: 2941 if (integer_zerop (TREE_OPERAND (op0, 1))) 2942 { 2943 op0 = TREE_OPERAND (op0, 0); 2944 goto again; 2945 } 2946 /* Fallthru. */ 2947 case COMPONENT_REF: 2948 case SSA_NAME: 2949 case OBJ_TYPE_REF: 2950 dump_generic_node (buffer, op0, 0, flags, false); 2951 break; 2952 2953 default: 2954 NIY; 2955 } 2956 } 2957 2958 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ... */ 2959 2960 static void 2961 pretty_print_string (pretty_printer *buffer, const char *str) 2962 { 2963 if (str == NULL) 2964 return; 2965 2966 while (*str) 2967 { 2968 switch (str[0]) 2969 { 2970 case '\b': 2971 pp_string (buffer, "\\b"); 2972 break; 2973 2974 case '\f': 2975 pp_string (buffer, "\\f"); 2976 break; 2977 2978 case '\n': 2979 pp_string (buffer, "\\n"); 2980 break; 2981 2982 case '\r': 2983 pp_string (buffer, "\\r"); 2984 break; 2985 2986 case '\t': 2987 pp_string (buffer, "\\t"); 2988 break; 2989 2990 case '\v': 2991 pp_string (buffer, "\\v"); 2992 break; 2993 2994 case '\\': 2995 pp_string (buffer, "\\\\"); 2996 break; 2997 2998 case '\"': 2999 pp_string (buffer, "\\\""); 3000 break; 3001 3002 case '\'': 3003 pp_string (buffer, "\\'"); 3004 break; 3005 3006 /* No need to handle \0; the loop terminates on \0. */ 3007 3008 case '\1': 3009 pp_string (buffer, "\\1"); 3010 break; 3011 3012 case '\2': 3013 pp_string (buffer, "\\2"); 3014 break; 3015 3016 case '\3': 3017 pp_string (buffer, "\\3"); 3018 break; 3019 3020 case '\4': 3021 pp_string (buffer, "\\4"); 3022 break; 3023 3024 case '\5': 3025 pp_string (buffer, "\\5"); 3026 break; 3027 3028 case '\6': 3029 pp_string (buffer, "\\6"); 3030 break; 3031 3032 case '\7': 3033 pp_string (buffer, "\\7"); 3034 break; 3035 3036 default: 3037 pp_character (buffer, str[0]); 3038 break; 3039 } 3040 str++; 3041 } 3042 } 3043 3044 static void 3045 maybe_init_pretty_print (FILE *file) 3046 { 3047 if (!initialized) 3048 { 3049 pp_construct (&buffer, /* prefix */NULL, /* line-width */0); 3050 pp_needs_newline (&buffer) = true; 3051 pp_translate_identifiers (&buffer) = false; 3052 initialized = 1; 3053 } 3054 3055 buffer.buffer->stream = file; 3056 } 3057 3058 static void 3059 newline_and_indent (pretty_printer *buffer, int spc) 3060 { 3061 pp_newline (buffer); 3062 INDENT (spc); 3063 } 3064 3065 /* Handle a %K format for TEXT. Separate from default_tree_printer so 3066 it can also be used in front ends. 3067 %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded. 3068 */ 3069 3070 void 3071 percent_K_format (text_info *text) 3072 { 3073 tree t = va_arg (*text->args_ptr, tree), block; 3074 gcc_assert (text->locus != NULL); 3075 *text->locus = EXPR_LOCATION (t); 3076 gcc_assert (pp_ti_abstract_origin (text) != NULL); 3077 block = TREE_BLOCK (t); 3078 *pp_ti_abstract_origin (text) = NULL; 3079 while (block 3080 && TREE_CODE (block) == BLOCK 3081 && BLOCK_ABSTRACT_ORIGIN (block)) 3082 { 3083 tree ao = BLOCK_ABSTRACT_ORIGIN (block); 3084 3085 while (TREE_CODE (ao) == BLOCK 3086 && BLOCK_ABSTRACT_ORIGIN (ao) 3087 && BLOCK_ABSTRACT_ORIGIN (ao) != ao) 3088 ao = BLOCK_ABSTRACT_ORIGIN (ao); 3089 3090 if (TREE_CODE (ao) == FUNCTION_DECL) 3091 { 3092 *pp_ti_abstract_origin (text) = block; 3093 break; 3094 } 3095 block = BLOCK_SUPERCONTEXT (block); 3096 } 3097 } 3098 3099 /* Print the identifier ID to PRETTY-PRINTER. */ 3100 3101 void 3102 pp_base_tree_identifier (pretty_printer *pp, tree id) 3103 { 3104 if (pp_translate_identifiers (pp)) 3105 { 3106 const char *text = identifier_to_locale (IDENTIFIER_POINTER (id)); 3107 pp_append_text (pp, text, text + strlen (text)); 3108 } 3109 else 3110 pp_append_text (pp, IDENTIFIER_POINTER (id), 3111 IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id)); 3112 } 3113 3114 /* A helper function that is used to dump function information before the 3115 function dump. */ 3116 3117 void 3118 dump_function_header (FILE *dump_file, tree fdecl, int flags) 3119 { 3120 const char *dname, *aname; 3121 struct cgraph_node *node = cgraph_get_node (fdecl); 3122 struct function *fun = DECL_STRUCT_FUNCTION (fdecl); 3123 3124 dname = lang_hooks.decl_printable_name (fdecl, 2); 3125 3126 if (DECL_ASSEMBLER_NAME_SET_P (fdecl)) 3127 aname = (IDENTIFIER_POINTER 3128 (DECL_ASSEMBLER_NAME (fdecl))); 3129 else 3130 aname = "<unset-asm-name>"; 3131 3132 fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d", 3133 dname, aname, fun->funcdef_no); 3134 if (!(flags & TDF_NOUID)) 3135 fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl)); 3136 if (node) 3137 { 3138 fprintf (dump_file, ", cgraph_uid=%d)%s\n\n", node->uid, 3139 node->frequency == NODE_FREQUENCY_HOT 3140 ? " (hot)" 3141 : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED 3142 ? " (unlikely executed)" 3143 : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE 3144 ? " (executed once)" 3145 : ""); 3146 } 3147 else 3148 fprintf (dump_file, ")\n\n"); 3149 } 3150