gcc/tree-pretty-print.c

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