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_character (buffer, '(');
 233
 234   /* Print the argument types.  */
 235   arg = TYPE_ARG_TYPES (node);
 236   while (arg && arg != void_list_node && arg != error_mark_node)
 237     {
 238       if (wrote_arg)
 239         {
 240           pp_character (buffer, ',');
 241           pp_space (buffer);
 242         }
 243       wrote_arg = true;
 244       dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
 245       arg = TREE_CHAIN (arg);
 246     }
 247
 248   /* Drop the trailing void_type_node if we had any previous argument.  */
 249   if (arg == void_list_node && !wrote_arg)
 250     pp_string (buffer, "void");
 251   /* Properly dump vararg function types.  */
 252   else if (!arg && wrote_arg)
 253     pp_string (buffer, ", ...");
 254   /* Avoid printing any arg for unprototyped functions.  */
 255
 256   pp_character (buffer, ')');
 257 }
 258
 259 /* Dump the domain associated with an array.  */
 260
 261 static void
 262 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
 263 {
 264   pp_character (buffer, '[');
 265   if (domain)
 266     {
 267       tree min = TYPE_MIN_VALUE (domain);
 268       tree max = TYPE_MAX_VALUE (domain);
 269
 270       if (min && max
 271           && integer_zerop (min)
 272           && host_integerp (max, 0))
 273         pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
 274       else
 275         {
 276           if (min)
 277             dump_generic_node (buffer, min, spc, flags, false);
 278           pp_character (buffer, ':');
 279           if (max)
 280             dump_generic_node (buffer, max, spc, flags, false);
 281         }
 282     }
 283   else
 284     pp_string (buffer, "<unknown>");
 285   pp_character (buffer, ']');
 286 }
 287
 288
 289 /* Dump OpenMP clause CLAUSE.  BUFFER, CLAUSE, SPC and FLAGS are as in
 290    dump_generic_node.  */
 291
 292 static void
 293 dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
 294 {
 295   const char *name;
 296
 297   switch (OMP_CLAUSE_CODE (clause))
 298     {
 299     case OMP_CLAUSE_PRIVATE:
 300       name = "private";
 301       goto print_remap;
 302     case OMP_CLAUSE_SHARED:
 303       name = "shared";
 304       goto print_remap;
 305     case OMP_CLAUSE_FIRSTPRIVATE:
 306       name = "firstprivate";
 307       goto print_remap;
 308     case OMP_CLAUSE_LASTPRIVATE:
 309       name = "lastprivate";
 310       goto print_remap;
 311     case OMP_CLAUSE_COPYIN:
 312       name = "copyin";
 313       goto print_remap;
 314     case OMP_CLAUSE_COPYPRIVATE:
 315       name = "copyprivate";
 316       goto print_remap;
 317   print_remap:
 318       pp_string (buffer, name);
 319       pp_character (buffer, '(');
 320       dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
 321           spc, flags, false);
 322       pp_character (buffer, ')');
 323       break;
 324
 325     case OMP_CLAUSE_REDUCTION:
 326       pp_string (buffer, "reduction(");
 327       pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
 328       pp_character (buffer, ':');
 329       dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
 330           spc, flags, false);
 331       pp_character (buffer, ')');
 332       break;
 333
 334     case OMP_CLAUSE_IF:
 335       pp_string (buffer, "if(");
 336       dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
 337           spc, flags, false);
 338       pp_character (buffer, ')');
 339       break;
 340
 341     case OMP_CLAUSE_NUM_THREADS:
 342       pp_string (buffer, "num_threads(");
 343       dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
 344           spc, flags, false);
 345       pp_character (buffer, ')');
 346       break;
 347
 348     case OMP_CLAUSE_NOWAIT:
 349       pp_string (buffer, "nowait");
 350       break;
 351     case OMP_CLAUSE_ORDERED:
 352       pp_string (buffer, "ordered");
 353       break;
 354
 355     case OMP_CLAUSE_DEFAULT:
 356       pp_string (buffer, "default(");
 357       switch (OMP_CLAUSE_DEFAULT_KIND (clause))
 358         {
 359         case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
 360           break;
 361         case OMP_CLAUSE_DEFAULT_SHARED:
 362           pp_string (buffer, "shared");
 363           break;
 364         case OMP_CLAUSE_DEFAULT_NONE:
 365           pp_string (buffer, "none");
 366           break;
 367         case OMP_CLAUSE_DEFAULT_PRIVATE:
 368           pp_string (buffer, "private");
 369           break;
 370         case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
 371           pp_string (buffer, "firstprivate");
 372           break;
 373         default:
 374           gcc_unreachable ();
 375         }
 376       pp_character (buffer, ')');
 377       break;
 378
 379     case OMP_CLAUSE_SCHEDULE:
 380       pp_string (buffer, "schedule(");
 381       switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
 382         {
 383       case OMP_CLAUSE_SCHEDULE_STATIC:
 384         pp_string (buffer, "static");
 385         break;
 386       case OMP_CLAUSE_SCHEDULE_DYNAMIC:
 387         pp_string (buffer, "dynamic");
 388         break;
 389       case OMP_CLAUSE_SCHEDULE_GUIDED:
 390         pp_string (buffer, "guided");
 391         break;
 392       case OMP_CLAUSE_SCHEDULE_RUNTIME:
 393         pp_string (buffer, "runtime");
 394         break;
 395       case OMP_CLAUSE_SCHEDULE_AUTO:
 396         pp_string (buffer, "auto");
 397         break;
 398       default:
 399         gcc_unreachable ();
 400         }
 401       if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
 402         {
 403           pp_character (buffer, ',');
 404           dump_generic_node (buffer,
 405               OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
 406               spc, flags, false);
 407         }
 408       pp_character (buffer, ')');
 409       break;
 410
 411     case OMP_CLAUSE_UNTIED:
 412       pp_string (buffer, "untied");
 413       break;
 414
 415     case OMP_CLAUSE_COLLAPSE:
 416       pp_string (buffer, "collapse(");
 417       dump_generic_node (buffer,
 418                          OMP_CLAUSE_COLLAPSE_EXPR (clause),
 419                          spc, flags, false);
 420       pp_character (buffer, ')');
 421       break;
 422
 423     case OMP_CLAUSE_FINAL:
 424       pp_string (buffer, "final(");
 425       dump_generic_node (buffer, OMP_CLAUSE_FINAL_EXPR (clause),
 426           spc, flags, false);
 427       pp_character (buffer, ')');
 428       break;
 429
 430     case OMP_CLAUSE_MERGEABLE:
 431       pp_string (buffer, "mergeable");
 432       break;
 433
 434     default:
 435       /* Should never happen.  */
 436       dump_generic_node (buffer, clause, spc, flags, false);
 437       break;
 438     }
 439 }
 440
 441
 442 /* Dump the list of OpenMP clauses.  BUFFER, SPC and FLAGS are as in
 443    dump_generic_node.  */
 444
 445 void
 446 dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
 447 {
 448   if (clause == NULL)
 449     return;
 450
 451   pp_space (buffer);
 452   while (1)
 453     {
 454       dump_omp_clause (buffer, clause, spc, flags);
 455       clause = OMP_CLAUSE_CHAIN (clause);
 456       if (clause == NULL)
 457         return;
 458       pp_space (buffer);
 459     }
 460 }
 461
 462
 463 /* Dump location LOC to BUFFER.  */
 464
 465 static void
 466 dump_location (pretty_printer *buffer, location_t loc)
 467 {
 468   expanded_location xloc = expand_location (loc);
 469
 470   pp_character (buffer, '[');
 471   if (xloc.file)
 472     {
 473       pp_string (buffer, xloc.file);
 474       pp_string (buffer, " : ");
 475     }
 476   pp_decimal_int (buffer, xloc.line);
 477   pp_string (buffer, "] ");
 478 }
 479
 480
 481 /* Dump lexical block BLOCK.  BUFFER, SPC and FLAGS are as in
 482    dump_generic_node.  */
 483
 484 static void
 485 dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)
 486 {
 487   tree t;
 488
 489   pp_printf (buffer, "BLOCK #%d ", BLOCK_NUMBER (block));
 490
 491   if (flags & TDF_ADDRESS)
 492     pp_printf (buffer, "[%p] ", (void *) block);
 493
 494   if (BLOCK_ABSTRACT (block))
 495     pp_string (buffer, "[abstract] ");
 496
 497   if (TREE_ASM_WRITTEN (block))
 498     pp_string (buffer, "[written] ");
 499
 500   if (flags & TDF_SLIM)
 501     return;
 502
 503   if (BLOCK_SOURCE_LOCATION (block))
 504     dump_location (buffer, BLOCK_SOURCE_LOCATION (block));
 505
 506   newline_and_indent (buffer, spc + 2);
 507
 508   if (BLOCK_SUPERCONTEXT (block))
 509     {
 510       pp_string (buffer, "SUPERCONTEXT: ");
 511       dump_generic_node (buffer, BLOCK_SUPERCONTEXT (block), 0,
 512                          flags | TDF_SLIM, false);
 513       newline_and_indent (buffer, spc + 2);
 514     }
 515
 516   if (BLOCK_SUBBLOCKS (block))
 517     {
 518       pp_string (buffer, "SUBBLOCKS: ");
 519       for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
 520         {
 521           dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
 522           pp_string (buffer, " ");
 523         }
 524       newline_and_indent (buffer, spc + 2);
 525     }
 526
 527   if (BLOCK_CHAIN (block))
 528     {
 529       pp_string (buffer, "SIBLINGS: ");
 530       for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))
 531         {
 532           dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
 533           pp_string (buffer, " ");
 534         }
 535       newline_and_indent (buffer, spc + 2);
 536     }
 537
 538   if (BLOCK_VARS (block))
 539     {
 540       pp_string (buffer, "VARS: ");
 541       for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
 542         {
 543           dump_generic_node (buffer, t, 0, flags, false);
 544           pp_string (buffer, " ");
 545         }
 546       newline_and_indent (buffer, spc + 2);
 547     }
 548
 549   if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block)) > 0)
 550     {
 551       unsigned i;
 552       vec<tree, va_gc> *nlv = BLOCK_NONLOCALIZED_VARS (block);
 553
 554       pp_string (buffer, "NONLOCALIZED_VARS: ");
 555       FOR_EACH_VEC_ELT (*nlv, i, t)
 556         {
 557           dump_generic_node (buffer, t, 0, flags, false);
 558           pp_string (buffer, " ");
 559         }
 560       newline_and_indent (buffer, spc + 2);
 561     }
 562
 563   if (BLOCK_ABSTRACT_ORIGIN (block))
 564     {
 565       pp_string (buffer, "ABSTRACT_ORIGIN: ");
 566       dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (block), 0,
 567                          flags | TDF_SLIM, false);
 568       newline_and_indent (buffer, spc + 2);
 569     }
 570
 571   if (BLOCK_FRAGMENT_ORIGIN (block))
 572     {
 573       pp_string (buffer, "FRAGMENT_ORIGIN: ");
 574       dump_generic_node (buffer, BLOCK_FRAGMENT_ORIGIN (block), 0,
 575                          flags | TDF_SLIM, false);
 576       newline_and_indent (buffer, spc + 2);
 577     }
 578
 579   if (BLOCK_FRAGMENT_CHAIN (block))
 580     {
 581       pp_string (buffer, "FRAGMENT_CHAIN: ");
 582       for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))
 583         {
 584           dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
 585           pp_string (buffer, " ");
 586         }
 587       newline_and_indent (buffer, spc + 2);
 588     }
 589 }
 590
 591
 592 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_character (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_character (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_character (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_string (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_string (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_string (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_character (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_character (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_string (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_string (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_string (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_string (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_string (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_string (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_character (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_string (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_string (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_character (buffer, '(');
1281       dump_generic_node (buffer, op0, spc, flags, false);
1282       if (op_prio (op0) < op_prio (node))
1283         pp_character (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_character (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_string (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_character (buffer, '(');
1310       dump_generic_node (buffer, op0, spc, flags, false);
1311       if (op_prio (op0) < op_prio (node))
1312         pp_character (buffer, ')');
1313       pp_character (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_character (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_character (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_character (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_character (buffer, '.');
1364                     dump_generic_node (buffer, field, spc, flags, false);
1365                     pp_character (buffer, '=');
1366                   }
1367                 else if (is_array_init
1368                          && (TREE_CODE (field) != INTEGER_CST
1369                              || tree_to_double_int (field) != curidx))
1370                   {
1371                     pp_character (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_character (buffer, ',');
1401                 pp_space (buffer);
1402               }
1403           }
1404         pp_character (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_character (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_character (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_character (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_character (buffer, ',');
1483       pp_space (buffer);
1484       dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1485       pp_character (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_character (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_character (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_character (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_character (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_character (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_character (buffer, '?');
1553           pp_space (buffer);
1554           dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1555           pp_space (buffer);
1556           pp_character (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_character (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_character (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_character (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_character (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_character (buffer, ',');
1609               pp_space (buffer);
1610             }
1611           pp_string (buffer, "__builtin_va_arg_pack ()");
1612         }
1613       pp_character (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_character (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_character (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_character (buffer, '(');
1702             dump_generic_node (buffer, op0, spc, flags, false);
1703             pp_character (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_character (buffer, '(');
1717             dump_generic_node (buffer, op1, spc, flags, false);
1718             pp_character (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_character (buffer, '(');
1743           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1744           pp_character (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_character (buffer, '(');
1755           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1756           pp_character (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_character (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_character (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_character (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_character (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_character (buffer, '(');
1804       dump_generic_node (buffer, op0, spc, flags, false);
1805       if (op_prio (op0) < op_prio (node))
1806         pp_character (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_character (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_character (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_character (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_string (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_string (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_string (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_string (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_string (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_string (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_string (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_string (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_string (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_string (buffer, ")");
1892       newline_and_indent (buffer, spc+2);
1893       pp_string (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_string (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_string (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_string (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_character (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_character (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_character (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_character (buffer, ')');
1978       if (!(flags & TDF_SLIM))
1979         {
1980           newline_and_indent (buffer, spc+2);
1981           pp_character (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_character (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_character (buffer, '(');
2035       dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
2036       pp_character (buffer, ':');
2037       dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
2038       pp_character (buffer, ':');
2039       dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
2040       if (ASM_CLOBBERS (node))
2041         {
2042           pp_character (buffer, ':');
2043           dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
2044         }
2045       pp_string (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_character (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_character (buffer, ';');
2070       dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
2071       pp_character (buffer, '-');
2072       pp_character (buffer, '>');
2073       dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
2074       pp_character (buffer, ')');
2075       break;
2076
2077     case SSA_NAME:
2078       if (SSA_NAME_IDENTIFIER (node))
2079         dump_generic_node (buffer, SSA_NAME_IDENTIFIER (node),
2080                            spc, flags, false);
2081       pp_string (buffer, "_");
2082       pp_decimal_int (buffer, SSA_NAME_VERSION (node));
2083       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
2084         pp_string (buffer, "(ab)");
2085       else if (SSA_NAME_IS_DEFAULT_DEF (node))
2086         pp_string (buffer, "(D)");
2087       break;
2088
2089     case WITH_SIZE_EXPR:
2090       pp_string (buffer, "WITH_SIZE_EXPR <");
2091       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2092       pp_string (buffer, ", ");
2093       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2094       pp_string (buffer, ">");
2095       break;
2096
2097     case ASSERT_EXPR:
2098       pp_string (buffer, "ASSERT_EXPR <");
2099       dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
2100       pp_string (buffer, ", ");
2101       dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
2102       pp_string (buffer, ">");
2103       break;
2104
2105     case SCEV_KNOWN:
2106       pp_string (buffer, "scev_known");
2107       break;
2108
2109     case SCEV_NOT_KNOWN:
2110       pp_string (buffer, "scev_not_known");
2111       break;
2112
2113     case POLYNOMIAL_CHREC:
2114       pp_string (buffer, "{");
2115       dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
2116       pp_string (buffer, ", +, ");
2117       dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
2118       pp_string (buffer, "}_");
2119       dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
2120       is_stmt = false;
2121       break;
2122
2123     case REALIGN_LOAD_EXPR:
2124       pp_string (buffer, "REALIGN_LOAD <");
2125       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2126       pp_string (buffer, ", ");
2127       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2128       pp_string (buffer, ", ");
2129       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2130       pp_string (buffer, ">");
2131       break;
2132
2133     case VEC_COND_EXPR:
2134       pp_string (buffer, " VEC_COND_EXPR < ");
2135       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2136       pp_string (buffer, " , ");
2137       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2138       pp_string (buffer, " , ");
2139       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2140       pp_string (buffer, " > ");
2141       break;
2142
2143     case VEC_PERM_EXPR:
2144       pp_string (buffer, " VEC_PERM_EXPR < ");
2145       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2146       pp_string (buffer, " , ");
2147       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2148       pp_string (buffer, " , ");
2149       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2150       pp_string (buffer, " > ");
2151       break;
2152
2153     case DOT_PROD_EXPR:
2154       pp_string (buffer, " DOT_PROD_EXPR < ");
2155       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2156       pp_string (buffer, ", ");
2157       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2158       pp_string (buffer, ", ");
2159       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2160       pp_string (buffer, " > ");
2161       break;
2162
2163     case WIDEN_MULT_PLUS_EXPR:
2164       pp_string (buffer, " WIDEN_MULT_PLUS_EXPR < ");
2165       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2166       pp_string (buffer, ", ");
2167       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2168       pp_string (buffer, ", ");
2169       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2170       pp_string (buffer, " > ");
2171       break;
2172
2173     case WIDEN_MULT_MINUS_EXPR:
2174       pp_string (buffer, " WIDEN_MULT_MINUS_EXPR < ");
2175       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2176       pp_string (buffer, ", ");
2177       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2178       pp_string (buffer, ", ");
2179       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2180       pp_string (buffer, " > ");
2181       break;
2182
2183     case FMA_EXPR:
2184       pp_string (buffer, " FMA_EXPR < ");
2185       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2186       pp_string (buffer, ", ");
2187       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2188       pp_string (buffer, ", ");
2189       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
2190       pp_string (buffer, " > ");
2191       break;
2192
2193     case OMP_PARALLEL:
2194       pp_string (buffer, "#pragma omp parallel");
2195       dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
2196
2197     dump_omp_body:
2198       if (!(flags & TDF_SLIM) && OMP_BODY (node))
2199         {
2200           newline_and_indent (buffer, spc + 2);
2201           pp_character (buffer, '{');
2202           newline_and_indent (buffer, spc + 4);
2203           dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
2204           newline_and_indent (buffer, spc + 2);
2205           pp_character (buffer, '}');
2206         }
2207       is_expr = false;
2208       break;
2209
2210     case OMP_TASK:
2211       pp_string (buffer, "#pragma omp task");
2212       dump_omp_clauses (buffer, OMP_TASK_CLAUSES (node), spc, flags);
2213       goto dump_omp_body;
2214
2215     case OMP_FOR:
2216       pp_string (buffer, "#pragma omp for");
2217       dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
2218
2219       if (!(flags & TDF_SLIM))
2220         {
2221           int i;
2222
2223           if (OMP_FOR_PRE_BODY (node))
2224             {
2225               newline_and_indent (buffer, spc + 2);
2226               pp_character (buffer, '{');
2227               spc += 4;
2228               newline_and_indent (buffer, spc);
2229               dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
2230                   spc, flags, false);
2231             }
2232           spc -= 2;
2233           for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
2234             {
2235               spc += 2;
2236               newline_and_indent (buffer, spc);
2237               pp_string (buffer, "for (");
2238               dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INIT (node), i),
2239                                  spc, flags, false);
2240               pp_string (buffer, "; ");
2241               dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_COND (node), i),
2242                                  spc, flags, false);
2243               pp_string (buffer, "; ");
2244               dump_generic_node (buffer, TREE_VEC_ELT (OMP_FOR_INCR (node), i),
2245                                  spc, flags, false);
2246               pp_string (buffer, ")");
2247             }
2248           if (OMP_FOR_BODY (node))
2249             {
2250               newline_and_indent (buffer, spc + 2);
2251               pp_character (buffer, '{');
2252               newline_and_indent (buffer, spc + 4);
2253               dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
2254                   false);
2255               newline_and_indent (buffer, spc + 2);
2256               pp_character (buffer, '}');
2257             }
2258           spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
2259           if (OMP_FOR_PRE_BODY (node))
2260             {
2261               spc -= 4;
2262               newline_and_indent (buffer, spc + 2);
2263               pp_character (buffer, '}');
2264             }
2265         }
2266       is_expr = false;
2267       break;
2268
2269     case OMP_SECTIONS:
2270       pp_string (buffer, "#pragma omp sections");
2271       dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
2272       goto dump_omp_body;
2273
2274     case OMP_SECTION:
2275       pp_string (buffer, "#pragma omp section");
2276       goto dump_omp_body;
2277
2278     case OMP_MASTER:
2279       pp_string (buffer, "#pragma omp master");
2280       goto dump_omp_body;
2281
2282     case OMP_ORDERED:
2283       pp_string (buffer, "#pragma omp ordered");
2284       goto dump_omp_body;
2285
2286     case OMP_CRITICAL:
2287       pp_string (buffer, "#pragma omp critical");
2288       if (OMP_CRITICAL_NAME (node))
2289         {
2290           pp_space (buffer);
2291           pp_character (buffer, '(');
2292           dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
2293                              flags, false);
2294           pp_character (buffer, ')');
2295         }
2296       goto dump_omp_body;
2297
2298     case OMP_ATOMIC:
2299       pp_string (buffer, "#pragma omp atomic");
2300       newline_and_indent (buffer, spc + 2);
2301       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2302       pp_space (buffer);
2303       pp_character (buffer, '=');
2304       pp_space (buffer);
2305       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2306       break;
2307
2308     case OMP_ATOMIC_READ:
2309       pp_string (buffer, "#pragma omp atomic read");
2310       newline_and_indent (buffer, spc + 2);
2311       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2312       pp_space (buffer);
2313       break;
2314
2315     case OMP_ATOMIC_CAPTURE_OLD:
2316     case OMP_ATOMIC_CAPTURE_NEW:
2317       pp_string (buffer, "#pragma omp atomic capture");
2318       newline_and_indent (buffer, spc + 2);
2319       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2320       pp_space (buffer);
2321       pp_character (buffer, '=');
2322       pp_space (buffer);
2323       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2324       break;
2325
2326     case OMP_SINGLE:
2327       pp_string (buffer, "#pragma omp single");
2328       dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
2329       goto dump_omp_body;
2330
2331     case OMP_CLAUSE:
2332       dump_omp_clause (buffer, node, spc, flags);
2333       is_expr = false;
2334       break;
2335
2336     case TRANSACTION_EXPR:
2337       if (TRANSACTION_EXPR_OUTER (node))
2338         pp_string (buffer, "__transaction_atomic [[outer]]");
2339       else if (TRANSACTION_EXPR_RELAXED (node))
2340         pp_string (buffer, "__transaction_relaxed");
2341       else
2342         pp_string (buffer, "__transaction_atomic");
2343       if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
2344         {
2345           newline_and_indent (buffer, spc);
2346           pp_character (buffer, '{');
2347           newline_and_indent (buffer, spc + 2);
2348           dump_generic_node (buffer, TRANSACTION_EXPR_BODY (node),
2349                              spc + 2, flags, false);
2350           newline_and_indent (buffer, spc);
2351           pp_character (buffer, '}');
2352         }
2353       is_expr = false;
2354       break;
2355
2356     case REDUC_MAX_EXPR:
2357       pp_string (buffer, " REDUC_MAX_EXPR < ");
2358       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2359       pp_string (buffer, " > ");
2360       break;
2361
2362     case REDUC_MIN_EXPR:
2363       pp_string (buffer, " REDUC_MIN_EXPR < ");
2364       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2365       pp_string (buffer, " > ");
2366       break;
2367
2368     case REDUC_PLUS_EXPR:
2369       pp_string (buffer, " REDUC_PLUS_EXPR < ");
2370       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2371       pp_string (buffer, " > ");
2372       break;
2373
2374     case VEC_WIDEN_MULT_HI_EXPR:
2375     case VEC_WIDEN_MULT_LO_EXPR:
2376     case VEC_WIDEN_MULT_EVEN_EXPR:
2377     case VEC_WIDEN_MULT_ODD_EXPR:
2378     case VEC_WIDEN_LSHIFT_HI_EXPR:
2379     case VEC_WIDEN_LSHIFT_LO_EXPR:
2380       pp_character (buffer, ' ');
2381       for (str = tree_code_name [code]; *str; str++)
2382         pp_character (buffer, TOUPPER (*str));
2383       pp_string (buffer, " < ");
2384       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2385       pp_string (buffer, ", ");
2386       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2387       pp_string (buffer, " > ");
2388       break;
2389
2390     case VEC_UNPACK_HI_EXPR:
2391       pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
2392       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2393       pp_string (buffer, " > ");
2394       break;
2395
2396     case VEC_UNPACK_LO_EXPR:
2397       pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
2398       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2399       pp_string (buffer, " > ");
2400       break;
2401
2402     case VEC_UNPACK_FLOAT_HI_EXPR:
2403       pp_string (buffer, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2404       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2405       pp_string (buffer, " > ");
2406       break;
2407
2408     case VEC_UNPACK_FLOAT_LO_EXPR:
2409       pp_string (buffer, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2410       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2411       pp_string (buffer, " > ");
2412       break;
2413
2414     case VEC_PACK_TRUNC_EXPR:
2415       pp_string (buffer, " VEC_PACK_TRUNC_EXPR < ");
2416       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2417       pp_string (buffer, ", ");
2418       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2419       pp_string (buffer, " > ");
2420       break;
2421
2422     case VEC_PACK_SAT_EXPR:
2423       pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
2424       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2425       pp_string (buffer, ", ");
2426       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2427       pp_string (buffer, " > ");
2428       break;
2429
2430     case VEC_PACK_FIX_TRUNC_EXPR:
2431       pp_string (buffer, " VEC_PACK_FIX_TRUNC_EXPR < ");
2432       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2433       pp_string (buffer, ", ");
2434       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2435       pp_string (buffer, " > ");
2436       break;
2437
2438     case BLOCK:
2439       dump_block_node (buffer, node, spc, flags);
2440       break;
2441
2442     default:
2443       NIY;
2444     }
2445
2446   if (is_stmt && is_expr)
2447     pp_semicolon (buffer);
2448
2449   return spc;
2450 }
2451
2452 /* Print the declaration of a variable.  */
2453
2454 void
2455 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2456 {
2457   INDENT (spc);
2458
2459   if (TREE_CODE (t) == TYPE_DECL)
2460     pp_string (buffer, "typedef ");
2461
2462   if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2463     pp_string (buffer, "register ");
2464
2465   if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2466     pp_string (buffer, "extern ");
2467   else if (TREE_STATIC (t))
2468     pp_string (buffer, "static ");
2469
2470   /* Print the type and name.  */
2471   if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2472     {
2473       tree tmp;
2474
2475       /* Print array's type.  */
2476       tmp = TREE_TYPE (t);
2477       while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2478         tmp = TREE_TYPE (tmp);
2479       dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2480
2481       /* Print variable's name.  */
2482       pp_space (buffer);
2483       dump_generic_node (buffer, t, spc, flags, false);
2484
2485       /* Print the dimensions.  */
2486       tmp = TREE_TYPE (t);
2487       while (TREE_CODE (tmp) == ARRAY_TYPE)
2488         {
2489           dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2490           tmp = TREE_TYPE (tmp);
2491         }
2492     }
2493   else if (TREE_CODE (t) == FUNCTION_DECL)
2494     {
2495       dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2496       pp_space (buffer);
2497       dump_decl_name (buffer, t, flags);
2498       dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2499     }
2500   else
2501     {
2502       /* Print type declaration.  */
2503       dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2504
2505       /* Print variable's name.  */
2506       pp_space (buffer);
2507       dump_generic_node (buffer, t, spc, flags, false);
2508     }
2509
2510   if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2511     {
2512       pp_string (buffer, " __asm__ ");
2513       pp_character (buffer, '(');
2514       dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2515       pp_character (buffer, ')');
2516     }
2517
2518   /* The initial value of a function serves to determine whether the function
2519      is declared or defined.  So the following does not apply to function
2520      nodes.  */
2521   if (TREE_CODE (t) != FUNCTION_DECL)
2522     {
2523       /* Print the initial value.  */
2524       if (DECL_INITIAL (t))
2525         {
2526           pp_space (buffer);
2527           pp_character (buffer, '=');
2528           pp_space (buffer);
2529           dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2530         }
2531     }
2532
2533   if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2534     {
2535       pp_string (buffer, " [value-expr: ");
2536       dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2537       pp_character (buffer, ']');
2538     }
2539
2540   pp_character (buffer, ';');
2541 }
2542
2543
2544 /* Prints a structure: name, fields, and methods.
2545    FIXME: Still incomplete.  */
2546
2547 static void
2548 print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
2549 {
2550   /* Print the name of the structure.  */
2551   if (TYPE_NAME (node))
2552     {
2553       INDENT (spc);
2554       if (TREE_CODE (node) == RECORD_TYPE)
2555         pp_string (buffer, "struct ");
2556       else if ((TREE_CODE (node) == UNION_TYPE
2557                 || TREE_CODE (node) == QUAL_UNION_TYPE))
2558         pp_string (buffer, "union ");
2559
2560       dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2561     }
2562
2563   /* Print the contents of the structure.  */
2564   pp_newline (buffer);
2565   INDENT (spc);
2566   pp_character (buffer, '{');
2567   pp_newline (buffer);
2568
2569   /* Print the fields of the structure.  */
2570   {
2571     tree tmp;
2572     tmp = TYPE_FIELDS (node);
2573     while (tmp)
2574       {
2575         /* Avoid to print recursively the structure.  */
2576         /* FIXME : Not implemented correctly...,
2577            what about the case when we have a cycle in the contain graph? ...
2578            Maybe this could be solved by looking at the scope in which the
2579            structure was declared.  */
2580         if (TREE_TYPE (tmp) != node
2581             && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
2582                 || TREE_TYPE (TREE_TYPE (tmp)) != node))
2583           {
2584             print_declaration (buffer, tmp, spc+2, flags);
2585             pp_newline (buffer);
2586           }
2587         tmp = DECL_CHAIN (tmp);
2588       }
2589   }
2590   INDENT (spc);
2591   pp_character (buffer, '}');
2592 }
2593
2594 /* Return the priority of the operator CODE.
2595
2596    From lowest to highest precedence with either left-to-right (L-R)
2597    or right-to-left (R-L) associativity]:
2598
2599      1  [L-R] ,
2600      2  [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2601      3  [R-L] ?:
2602      4  [L-R] ||
2603      5  [L-R] &&
2604      6  [L-R] |
2605      7  [L-R] ^
2606      8  [L-R] &
2607      9  [L-R] == !=
2608     10  [L-R] < <= > >=
2609     11  [L-R] << >>
2610     12  [L-R] + -
2611     13  [L-R] * / %
2612     14  [R-L] ! ~ ++ -- + - * & (type) sizeof
2613     15  [L-R] fn() [] -> .
2614
2615    unary +, - and * have higher precedence than the corresponding binary
2616    operators.  */
2617
2618 int
2619 op_code_prio (enum tree_code code)
2620 {
2621   switch (code)
2622     {
2623     case TREE_LIST:
2624     case COMPOUND_EXPR:
2625     case BIND_EXPR:
2626       return 1;
2627
2628     case MODIFY_EXPR:
2629     case INIT_EXPR:
2630       return 2;
2631
2632     case COND_EXPR:
2633       return 3;
2634
2635     case TRUTH_OR_EXPR:
2636     case TRUTH_ORIF_EXPR:
2637       return 4;
2638
2639     case TRUTH_AND_EXPR:
2640     case TRUTH_ANDIF_EXPR:
2641       return 5;
2642
2643     case BIT_IOR_EXPR:
2644       return 6;
2645
2646     case BIT_XOR_EXPR:
2647     case TRUTH_XOR_EXPR:
2648       return 7;
2649
2650     case BIT_AND_EXPR:
2651       return 8;
2652
2653     case EQ_EXPR:
2654     case NE_EXPR:
2655       return 9;
2656
2657     case UNLT_EXPR:
2658     case UNLE_EXPR:
2659     case UNGT_EXPR:
2660     case UNGE_EXPR:
2661     case UNEQ_EXPR:
2662     case LTGT_EXPR:
2663     case ORDERED_EXPR:
2664     case UNORDERED_EXPR:
2665     case LT_EXPR:
2666     case LE_EXPR:
2667     case GT_EXPR:
2668     case GE_EXPR:
2669       return 10;
2670
2671     case LSHIFT_EXPR:
2672     case RSHIFT_EXPR:
2673     case LROTATE_EXPR:
2674     case RROTATE_EXPR:
2675     case VEC_WIDEN_LSHIFT_HI_EXPR:
2676     case VEC_WIDEN_LSHIFT_LO_EXPR:
2677     case WIDEN_LSHIFT_EXPR:
2678       return 11;
2679
2680     case WIDEN_SUM_EXPR:
2681     case PLUS_EXPR:
2682     case POINTER_PLUS_EXPR:
2683     case MINUS_EXPR:
2684       return 12;
2685
2686     case VEC_WIDEN_MULT_HI_EXPR:
2687     case VEC_WIDEN_MULT_LO_EXPR:
2688     case WIDEN_MULT_EXPR:
2689     case DOT_PROD_EXPR:
2690     case WIDEN_MULT_PLUS_EXPR:
2691     case WIDEN_MULT_MINUS_EXPR:
2692     case MULT_EXPR:
2693     case MULT_HIGHPART_EXPR:
2694     case TRUNC_DIV_EXPR:
2695     case CEIL_DIV_EXPR:
2696     case FLOOR_DIV_EXPR:
2697     case ROUND_DIV_EXPR:
2698     case RDIV_EXPR:
2699     case EXACT_DIV_EXPR:
2700     case TRUNC_MOD_EXPR:
2701     case CEIL_MOD_EXPR:
2702     case FLOOR_MOD_EXPR:
2703     case ROUND_MOD_EXPR:
2704     case FMA_EXPR:
2705       return 13;
2706
2707     case TRUTH_NOT_EXPR:
2708     case BIT_NOT_EXPR:
2709     case POSTINCREMENT_EXPR:
2710     case POSTDECREMENT_EXPR:
2711     case PREINCREMENT_EXPR:
2712     case PREDECREMENT_EXPR:
2713     case NEGATE_EXPR:
2714     case INDIRECT_REF:
2715     case ADDR_EXPR:
2716     case FLOAT_EXPR:
2717     CASE_CONVERT:
2718     case FIX_TRUNC_EXPR:
2719     case TARGET_EXPR:
2720       return 14;
2721
2722     case CALL_EXPR:
2723     case ARRAY_REF:
2724     case ARRAY_RANGE_REF:
2725     case COMPONENT_REF:
2726       return 15;
2727
2728       /* Special expressions.  */
2729     case MIN_EXPR:
2730     case MAX_EXPR:
2731     case ABS_EXPR:
2732     case REALPART_EXPR:
2733     case IMAGPART_EXPR:
2734     case REDUC_MAX_EXPR:
2735     case REDUC_MIN_EXPR:
2736     case REDUC_PLUS_EXPR:
2737     case VEC_LSHIFT_EXPR:
2738     case VEC_RSHIFT_EXPR:
2739     case VEC_UNPACK_HI_EXPR:
2740     case VEC_UNPACK_LO_EXPR:
2741     case VEC_UNPACK_FLOAT_HI_EXPR:
2742     case VEC_UNPACK_FLOAT_LO_EXPR:
2743     case VEC_PACK_TRUNC_EXPR:
2744     case VEC_PACK_SAT_EXPR:
2745       return 16;
2746
2747     default:
2748       /* Return an arbitrarily high precedence to avoid surrounding single
2749          VAR_DECLs in ()s.  */
2750       return 9999;
2751     }
2752 }
2753
2754 /* Return the priority of the operator OP.  */
2755
2756 int
2757 op_prio (const_tree op)
2758 {
2759   enum tree_code code;
2760
2761   if (op == NULL)
2762     return 9999;
2763
2764   code = TREE_CODE (op);
2765   if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
2766     return op_prio (TREE_OPERAND (op, 0));
2767
2768   return op_code_prio (code);
2769 }
2770
2771 /* Return the symbol associated with operator CODE.  */
2772
2773 const char *
2774 op_symbol_code (enum tree_code code)
2775 {
2776   switch (code)
2777     {
2778     case MODIFY_EXPR:
2779       return "=";
2780
2781     case TRUTH_OR_EXPR:
2782     case TRUTH_ORIF_EXPR:
2783       return "||";
2784
2785     case TRUTH_AND_EXPR:
2786     case TRUTH_ANDIF_EXPR:
2787       return "&&";
2788
2789     case BIT_IOR_EXPR:
2790       return "|";
2791
2792     case TRUTH_XOR_EXPR:
2793     case BIT_XOR_EXPR:
2794       return "^";
2795
2796     case ADDR_EXPR:
2797     case BIT_AND_EXPR:
2798       return "&";
2799
2800     case ORDERED_EXPR:
2801       return "ord";
2802     case UNORDERED_EXPR:
2803       return "unord";
2804
2805     case EQ_EXPR:
2806       return "==";
2807     case UNEQ_EXPR:
2808       return "u==";
2809
2810     case NE_EXPR:
2811       return "!=";
2812
2813     case LT_EXPR:
2814       return "<";
2815     case UNLT_EXPR:
2816       return "u<";
2817
2818     case LE_EXPR:
2819       return "<=";
2820     case UNLE_EXPR:
2821       return "u<=";
2822
2823     case GT_EXPR:
2824       return ">";
2825     case UNGT_EXPR:
2826       return "u>";
2827
2828     case GE_EXPR:
2829       return ">=";
2830     case UNGE_EXPR:
2831       return "u>=";
2832
2833     case LTGT_EXPR:
2834       return "<>";
2835
2836     case LSHIFT_EXPR:
2837       return "<<";
2838
2839     case RSHIFT_EXPR:
2840       return ">>";
2841
2842     case LROTATE_EXPR:
2843       return "r<<";
2844
2845     case RROTATE_EXPR:
2846       return "r>>";
2847
2848     case VEC_LSHIFT_EXPR:
2849       return "v<<";
2850
2851     case VEC_RSHIFT_EXPR:
2852       return "v>>";
2853
2854     case WIDEN_LSHIFT_EXPR:
2855       return "w<<";
2856
2857     case POINTER_PLUS_EXPR:
2858       return "+";
2859
2860     case PLUS_EXPR:
2861       return "+";
2862
2863     case REDUC_PLUS_EXPR:
2864       return "r+";
2865
2866     case WIDEN_SUM_EXPR:
2867       return "w+";
2868
2869     case WIDEN_MULT_EXPR:
2870       return "w*";
2871
2872     case MULT_HIGHPART_EXPR:
2873       return "h*";
2874
2875     case NEGATE_EXPR:
2876     case MINUS_EXPR:
2877       return "-";
2878
2879     case BIT_NOT_EXPR:
2880       return "~";
2881
2882     case TRUTH_NOT_EXPR:
2883       return "!";
2884
2885     case MULT_EXPR:
2886     case INDIRECT_REF:
2887       return "*";
2888
2889     case TRUNC_DIV_EXPR:
2890     case RDIV_EXPR:
2891       return "/";
2892
2893     case CEIL_DIV_EXPR:
2894       return "/[cl]";
2895
2896     case FLOOR_DIV_EXPR:
2897       return "/[fl]";
2898
2899     case ROUND_DIV_EXPR:
2900       return "/[rd]";
2901
2902     case EXACT_DIV_EXPR:
2903       return "/[ex]";
2904
2905     case TRUNC_MOD_EXPR:
2906       return "%";
2907
2908     case CEIL_MOD_EXPR:
2909       return "%[cl]";
2910
2911     case FLOOR_MOD_EXPR:
2912       return "%[fl]";
2913
2914     case ROUND_MOD_EXPR:
2915       return "%[rd]";
2916
2917     case PREDECREMENT_EXPR:
2918       return " --";
2919
2920     case PREINCREMENT_EXPR:
2921       return " ++";
2922
2923     case POSTDECREMENT_EXPR:
2924       return "-- ";
2925
2926     case POSTINCREMENT_EXPR:
2927       return "++ ";
2928
2929     case MAX_EXPR:
2930       return "max";
2931
2932     case MIN_EXPR:
2933       return "min";
2934
2935     default:
2936       return "<<< ??? >>>";
2937     }
2938 }
2939
2940 /* Return the symbol associated with operator OP.  */
2941
2942 static const char *
2943 op_symbol (const_tree op)
2944 {
2945   return op_symbol_code (TREE_CODE (op));
2946 }
2947
2948 /* Prints the name of a call.  NODE is the CALL_EXPR_FN of a CALL_EXPR or
2949    the gimple_call_fn of a GIMPLE_CALL.  */
2950
2951 void
2952 print_call_name (pretty_printer *buffer, tree node, int flags)
2953 {
2954   tree op0 = node;
2955
2956   if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2957     op0 = TREE_OPERAND (op0, 0);
2958
2959  again:
2960   switch (TREE_CODE (op0))
2961     {
2962     case VAR_DECL:
2963     case PARM_DECL:
2964     case FUNCTION_DECL:
2965       dump_function_name (buffer, op0, flags);
2966       break;
2967
2968     case ADDR_EXPR:
2969     case INDIRECT_REF:
2970     case NOP_EXPR:
2971       op0 = TREE_OPERAND (op0, 0);
2972       goto again;
2973
2974     case COND_EXPR:
2975       pp_string (buffer, "(");
2976       dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, flags, false);
2977       pp_string (buffer, ") ? ");
2978       dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, flags, false);
2979       pp_string (buffer, " : ");
2980       dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, flags, false);
2981       break;
2982
2983     case ARRAY_REF:
2984       if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2985         dump_function_name (buffer, TREE_OPERAND (op0, 0), flags);
2986       else
2987         dump_generic_node (buffer, op0, 0, flags, false);
2988       break;
2989
2990     case MEM_REF:
2991       if (integer_zerop (TREE_OPERAND (op0, 1)))
2992         {
2993           op0 = TREE_OPERAND (op0, 0);
2994           goto again;
2995         }
2996       /* Fallthru.  */
2997     case COMPONENT_REF:
2998     case SSA_NAME:
2999     case OBJ_TYPE_REF:
3000       dump_generic_node (buffer, op0, 0, flags, false);
3001       break;
3002
3003     default:
3004       NIY;
3005     }
3006 }
3007
3008 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ...  */
3009
3010 static void
3011 pretty_print_string (pretty_printer *buffer, const char *str)
3012 {
3013   if (str == NULL)
3014     return;
3015
3016   while (*str)
3017     {
3018       switch (str[0])
3019         {
3020         case '\b':
3021           pp_string (buffer, "\\b");
3022           break;
3023
3024         case '\f':
3025           pp_string (buffer, "\\f");
3026           break;
3027
3028         case '\n':
3029           pp_string (buffer, "\\n");
3030           break;
3031
3032         case '\r':
3033           pp_string (buffer, "\\r");
3034           break;
3035
3036         case '\t':
3037           pp_string (buffer, "\\t");
3038           break;
3039
3040         case '\v':
3041           pp_string (buffer, "\\v");
3042           break;
3043
3044         case '\\':
3045           pp_string (buffer, "\\\\");
3046           break;
3047
3048         case '\"':
3049           pp_string (buffer, "\\\"");
3050           break;
3051
3052         case '\'':
3053           pp_string (buffer, "\\'");
3054           break;
3055
3056           /* No need to handle \0; the loop terminates on \0.  */
3057
3058         case '\1':
3059           pp_string (buffer, "\\1");
3060           break;
3061
3062         case '\2':
3063           pp_string (buffer, "\\2");
3064           break;
3065
3066         case '\3':
3067           pp_string (buffer, "\\3");
3068           break;
3069
3070         case '\4':
3071           pp_string (buffer, "\\4");
3072           break;
3073
3074         case '\5':
3075           pp_string (buffer, "\\5");
3076           break;
3077
3078         case '\6':
3079           pp_string (buffer, "\\6");
3080           break;
3081
3082         case '\7':
3083           pp_string (buffer, "\\7");
3084           break;
3085
3086         default:
3087           pp_character (buffer, str[0]);
3088           break;
3089         }
3090       str++;
3091     }
3092 }
3093
3094 static void
3095 maybe_init_pretty_print (FILE *file)
3096 {
3097   if (!initialized)
3098     {
3099       pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
3100       pp_needs_newline (&buffer) = true;
3101       pp_translate_identifiers (&buffer) = false;
3102       initialized = 1;
3103     }
3104
3105   buffer.buffer->stream = file;
3106 }
3107
3108 static void
3109 newline_and_indent (pretty_printer *buffer, int spc)
3110 {
3111   pp_newline (buffer);
3112   INDENT (spc);
3113 }
3114
3115 /* Handle a %K format for TEXT.  Separate from default_tree_printer so
3116    it can also be used in front ends.
3117    %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3118 */
3119
3120 void
3121 percent_K_format (text_info *text)
3122 {
3123   tree t = va_arg (*text->args_ptr, tree), block;
3124   gcc_assert (text->locus != NULL);
3125   *text->locus = EXPR_LOCATION (t);
3126   gcc_assert (pp_ti_abstract_origin (text) != NULL);
3127   block = TREE_BLOCK (t);
3128   *pp_ti_abstract_origin (text) = NULL;
3129   while (block
3130          && TREE_CODE (block) == BLOCK
3131          && BLOCK_ABSTRACT_ORIGIN (block))
3132     {
3133       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
3134
3135       while (TREE_CODE (ao) == BLOCK
3136              && BLOCK_ABSTRACT_ORIGIN (ao)
3137              && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3138         ao = BLOCK_ABSTRACT_ORIGIN (ao);
3139
3140       if (TREE_CODE (ao) == FUNCTION_DECL)
3141         {
3142           *pp_ti_abstract_origin (text) = block;
3143           break;
3144         }
3145       block = BLOCK_SUPERCONTEXT (block);
3146     }
3147 }
3148
3149 /* Print the identifier ID to PRETTY-PRINTER.  */
3150
3151 void
3152 pp_base_tree_identifier (pretty_printer *pp, tree id)
3153 {
3154   if (pp_translate_identifiers (pp))
3155     {
3156       const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
3157       pp_append_text (pp, text, text + strlen (text));
3158     }
3159   else
3160     pp_append_text (pp, IDENTIFIER_POINTER (id),
3161                     IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
3162 }
3163
3164 /* A helper function that is used to dump function information before the
3165    function dump.  */
3166
3167 void
3168 dump_function_header (FILE *dump_file, tree fdecl, int flags)
3169 {
3170   const char *dname, *aname;
3171   struct cgraph_node *node = cgraph_get_node (fdecl);
3172   struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
3173
3174   dname = lang_hooks.decl_printable_name (fdecl, 2);
3175
3176   if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
3177     aname = (IDENTIFIER_POINTER
3178              (DECL_ASSEMBLER_NAME (fdecl)));
3179   else
3180     aname = "<unset-asm-name>";
3181
3182   fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
3183            dname, aname, fun->funcdef_no);
3184   if (!(flags & TDF_NOUID))
3185     fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
3186   if (node)
3187     {
3188       fprintf (dump_file, ", cgraph_uid=%d)%s\n\n", node->uid,
3189                node->frequency == NODE_FREQUENCY_HOT
3190                ? " (hot)"
3191                : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
3192                ? " (unlikely executed)"
3193                : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
3194                ? " (executed once)"
3195                : "");
3196     }
3197   else
3198     fprintf (dump_file, ")\n\n");
3199 }