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