gcc/tree-pretty-print.c

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