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