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 "tree-pretty-print.h"
  28 #include "hashtab.h"
  29 #include "tree-flow.h"
  30 #include "langhooks.h"
  31 #include "tree-iterator.h"
  32 #include "tree-chrec.h"
  33 #include "tree-pass.h"
  34 #include "value-prof.h"
  35 #include "predict.h"
  36
  37 /* Local functions, macros and variables.  */
  38 static const char *op_symbol (const_tree);
  39 static void pretty_print_string (pretty_printer *, const char*);
  40 static void newline_and_indent (pretty_printer *, int);
  41 static void maybe_init_pretty_print (FILE *);
  42 static void print_struct_decl (pretty_printer *, const_tree, int, int);
  43 static void do_niy (pretty_printer *, const_tree);
  44
  45 #define INDENT(SPACE) do { \
  46   int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
  47
  48 #define NIY do_niy(buffer,node)
  49
  50 static pretty_printer buffer;
  51 static int initialized = 0;
  52
  53 /* Try to print something for an unknown tree code.  */
  54
  55 static void
  56 do_niy (pretty_printer *buffer, const_tree node)
  57 {
  58   int i, len;
  59
  60   pp_string (buffer, "<<< Unknown tree: ");
  61   pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
  62
  63   if (EXPR_P (node))
  64     {
  65       len = TREE_OPERAND_LENGTH (node);
  66       for (i = 0; i < len; ++i)
  67         {
  68           newline_and_indent (buffer, 2);
  69           dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
  70         }
  71     }
  72
  73   pp_string (buffer, " >>>");
  74 }
  75
  76 /* Debugging function to print out a generic expression.  */
  77
  78 DEBUG_FUNCTION void
  79 debug_generic_expr (tree t)
  80 {
  81   print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
  82   fprintf (stderr, "\n");
  83 }
  84
  85 /* Debugging function to print out a generic statement.  */
  86
  87 DEBUG_FUNCTION void
  88 debug_generic_stmt (tree t)
  89 {
  90   print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
  91   fprintf (stderr, "\n");
  92 }
  93
  94 /* Debugging function to print out a chain of trees .  */
  95
  96 DEBUG_FUNCTION void
  97 debug_tree_chain (tree t)
  98 {
  99   struct pointer_set_t *seen = pointer_set_create ();
 100
 101   while (t)
 102     {
 103       print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
 104       fprintf (stderr, " ");
 105       t = TREE_CHAIN (t);
 106       if (pointer_set_insert (seen, t))
 107         {
 108           fprintf (stderr, "... [cycled back to ");
 109           print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
 110           fprintf (stderr, "]");
 111           break;
 112         }
 113     }
 114   fprintf (stderr, "\n");
 115
 116   pointer_set_destroy (seen);
 117 }
 118
 119 /* Prints declaration DECL to the FILE with details specified by FLAGS.  */
 120 void
 121 print_generic_decl (FILE *file, tree decl, int flags)
 122 {
 123   maybe_init_pretty_print (file);
 124   print_declaration (&buffer, decl, 2, flags);
 125   pp_write_text_to_stream (&buffer);
 126 }
 127
 128 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
 129    to show in the dump.  See TDF_* in tree-pass.h.  */
 130
 131 void
 132 print_generic_stmt (FILE *file, tree t, int flags)
 133 {
 134   maybe_init_pretty_print (file);
 135   dump_generic_node (&buffer, t, 0, flags, true);
 136   pp_flush (&buffer);
 137 }
 138
 139 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
 140    to show in the dump.  See TDF_* in tree-pass.h.  The output is indented by
 141    INDENT spaces.  */
 142
 143 void
 144 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
 145 {
 146   int i;
 147
 148   maybe_init_pretty_print (file);
 149
 150   for (i = 0; i < indent; i++)
 151     pp_space (&buffer);
 152   dump_generic_node (&buffer, t, indent, flags, true);
 153   pp_flush (&buffer);
 154 }
 155
 156 /* Print a single expression T on file FILE.  FLAGS specifies details to show
 157    in the dump.  See TDF_* in tree-pass.h.  */
 158
 159 void
 160 print_generic_expr (FILE *file, tree t, int flags)
 161 {
 162   maybe_init_pretty_print (file);
 163   dump_generic_node (&buffer, t, 0, flags, false);
 164 }
 165
 166 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
 167    in FLAGS.  */
 168
 169 static void
 170 dump_decl_name (pretty_printer *buffer, tree node, int flags)
 171 {
 172   if (DECL_NAME (node))
 173     {
 174       if ((flags & TDF_ASMNAME) && DECL_ASSEMBLER_NAME_SET_P (node))
 175         pp_tree_identifier (buffer, DECL_ASSEMBLER_NAME (node));
 176       else
 177         pp_tree_identifier (buffer, DECL_NAME (node));
 178     }
 179   if ((flags & TDF_UID) || DECL_NAME (node) == NULL_TREE)
 180     {
 181       if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)
 182         pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (node));
 183       else if (TREE_CODE (node) == DEBUG_EXPR_DECL)
 184         {
 185           if (flags & TDF_NOUID)
 186             pp_string (buffer, "D#xxxx");
 187           else
 188             pp_printf (buffer, "D#%i", DEBUG_TEMP_UID (node));
 189         }
 190       else
 191         {
 192           char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
 193           if (flags & TDF_NOUID)
 194             pp_printf (buffer, "%c.xxxx", c);
 195           else
 196             pp_printf (buffer, "%c.%u", c, DECL_UID (node));
 197         }
 198     }
 199   if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node))
 200     {
 201       if (flags & TDF_NOUID)
 202         pp_printf (buffer, "ptD.xxxx");
 203       else
 204         pp_printf (buffer, "ptD.%u", DECL_PT_UID (node));
 205     }
 206 }
 207
 208 /* Like the above, but used for pretty printing function calls.  */
 209
 210 static void
 211 dump_function_name (pretty_printer *buffer, tree node, int flags)
 212 {
 213   if (TREE_CODE (node) == NOP_EXPR)
 214     node = TREE_OPERAND (node, 0);
 215   if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)
 216     pp_string (buffer, lang_hooks.decl_printable_name (node, 1));
 217   else
 218     dump_decl_name (buffer, node, flags);
 219 }
 220
 221 /* Dump a function declaration.  NODE is the FUNCTION_TYPE.  BUFFER, SPC and
 222    FLAGS are as in dump_generic_node.  */
 223
 224 static void
 225 dump_function_declaration (pretty_printer *buffer, tree node,
 226                            int spc, int flags)
 227 {
 228   bool wrote_arg = false;
 229   tree arg;
 230
 231   pp_space (buffer);
 232   pp_character (buffer, '(');
 233
 234   /* Print the argument types.  */
 235   arg = TYPE_ARG_TYPES (node);
 236   while (arg && arg != void_list_node && arg != error_mark_node)
 237     {
 238       if (wrote_arg)
 239         {
 240           pp_character (buffer, ',');
 241           pp_space (buffer);
 242         }
 243       wrote_arg = true;
 244       dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
 245       arg = TREE_CHAIN (arg);
 246     }
 247
 248   /* Drop the trailing void_type_node if we had any previous argument.  */
 249   if (arg == void_list_node && !wrote_arg)
 250     pp_string (buffer, "void");
 251   /* Properly dump vararg function types.  */
 252   else if (!arg && wrote_arg)
 253     pp_string (buffer, ", ...");
 254   /* Avoid printing any arg for unprototyped functions.  */
 255
 256   pp_character (buffer, ')');
 257 }
 258
 259 /* Dump the domain associated with an array.  */
 260
 261 static void
 262 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
 263 {
 264   pp_character (buffer, '[');
 265   if (domain)
 266     {
 267       tree min = TYPE_MIN_VALUE (domain);
 268       tree max = TYPE_MAX_VALUE (domain);
 269
 270       if (min && max
 271           && integer_zerop (min)
 272           && host_integerp (max, 0))
 273         pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
 274       else
 275         {
 276           if (min)
 277             dump_generic_node (buffer, min, spc, flags, false);
 278           pp_character (buffer, ':');
 279           if (max)
 280             dump_generic_node (buffer, max, spc, flags, false);
 281         }
 282     }
 283   else
 284     pp_string (buffer, "<unknown>");
 285   pp_character (buffer, ']');
 286 }
 287
 288
 289 /* Dump OpenMP clause CLAUSE.  BUFFER, CLAUSE, SPC and FLAGS are as in
 290    dump_generic_node.  */
 291
 292 static void
 293 dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
 294 {
 295   const char *name;
 296
 297   switch (OMP_CLAUSE_CODE (clause))
 298     {
 299     case OMP_CLAUSE_PRIVATE:
 300       name = "private";
 301       goto print_remap;
 302     case OMP_CLAUSE_SHARED:
 303       name = "shared";
 304       goto print_remap;
 305     case OMP_CLAUSE_FIRSTPRIVATE:
 306       name = "firstprivate";
 307       goto print_remap;
 308     case OMP_CLAUSE_LASTPRIVATE:
 309       name = "lastprivate";
 310       goto print_remap;
 311     case OMP_CLAUSE_COPYIN:
 312       name = "copyin";
 313       goto print_remap;
 314     case OMP_CLAUSE_COPYPRIVATE:
 315       name = "copyprivate";
 316       goto print_remap;
 317   print_remap:
 318       pp_string (buffer, name);
 319       pp_character (buffer, '(');
 320       dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
 321           spc, flags, false);
 322       pp_character (buffer, ')');
 323       break;
 324
 325     case OMP_CLAUSE_REDUCTION:
 326       pp_string (buffer, "reduction(");
 327       pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
 328       pp_character (buffer, ':');
 329       dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
 330           spc, flags, false);
 331       pp_character (buffer, ')');
 332       break;
 333
 334     case OMP_CLAUSE_IF:
 335       pp_string (buffer, "if(");
 336       dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
 337           spc, flags, false);
 338       pp_character (buffer, ')');
 339       break;
 340
 341     case OMP_CLAUSE_NUM_THREADS:
 342       pp_string (buffer, "num_threads(");
 343       dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
 344           spc, flags, false);
 345       pp_character (buffer, ')');
 346       break;
 347
 348     case OMP_CLAUSE_NOWAIT:
 349       pp_string (buffer, "nowait");
 350       break;
 351     case OMP_CLAUSE_ORDERED:
 352       pp_string (buffer, "ordered");
 353       break;
 354
 355     case OMP_CLAUSE_DEFAULT:
 356       pp_string (buffer, "default(");
 357       switch (OMP_CLAUSE_DEFAULT_KIND (clause))
 358         {
 359         case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
 360           break;
 361         case OMP_CLAUSE_DEFAULT_SHARED:
 362           pp_string (buffer, "shared");
 363           break;
 364         case OMP_CLAUSE_DEFAULT_NONE:
 365           pp_string (buffer, "none");
 366           break;
 367         case OMP_CLAUSE_DEFAULT_PRIVATE:
 368           pp_string (buffer, "private");
 369           break;
 370         case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
 371           pp_string (buffer, "firstprivate");
 372           break;
 373         default:
 374           gcc_unreachable ();
 375         }
 376       pp_character (buffer, ')');
 377       break;
 378
 379     case OMP_CLAUSE_SCHEDULE:
 380       pp_string (buffer, "schedule(");
 381       switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
 382         {
 383       case OMP_CLAUSE_SCHEDULE_STATIC:
 384         pp_string (buffer, "static");
 385         break;
 386       case OMP_CLAUSE_SCHEDULE_DYNAMIC:
 387         pp_string (buffer, "dynamic");
 388         break;
 389       case OMP_CLAUSE_SCHEDULE_GUIDED:
 390         pp_string (buffer, "guided");
 391         break;
 392       case OMP_CLAUSE_SCHEDULE_RUNTIME:
 393         pp_string (buffer, "runtime");
 394         break;
 395       case OMP_CLAUSE_SCHEDULE_AUTO:
 396         pp_string (buffer, "auto");
 397         break;
 398       default:
 399         gcc_unreachable ();
 400         }
 401       if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
 402         {
 403           pp_character (buffer, ',');
 404           dump_generic_node (buffer,
 405               OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
 406               spc, flags, false);
 407         }
 408       pp_character (buffer, ')');
 409       break;
 410
 411     case OMP_CLAUSE_UNTIED:
 412       pp_string (buffer, "untied");
 413       break;
 414
 415     case OMP_CLAUSE_COLLAPSE:
 416       pp_string (buffer, "collapse(");
 417       dump_generic_node (buffer,
 418                          OMP_CLAUSE_COLLAPSE_EXPR (clause),
 419                          spc, flags, false);
 420       pp_character (buffer, ')');
 421       break;
 422
 423     case OMP_CLAUSE_FINAL:
 424       pp_string (buffer, "final(");
 425       dump_generic_node (buffer, OMP_CLAUSE_FINAL_EXPR (clause),
 426           spc, flags, false);
 427       pp_character (buffer, ')');
 428       break;
 429
 430     case OMP_CLAUSE_MERGEABLE:
 431       pp_string (buffer, "mergeable");
 432       break;
 433
 434     default:
 435       /* Should never happen.  */
 436       dump_generic_node (buffer, clause, spc, flags, false);
 437       break;
 438     }
 439 }
 440
 441
 442 /* Dump the list of OpenMP clauses.  BUFFER, SPC and FLAGS are as in
 443    dump_generic_node.  */
 444
 445 void
 446 dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
 447 {
 448   if (clause == NULL)
 449     return;
 450
 451   pp_space (buffer);
 452   while (1)
 453     {
 454       dump_omp_clause (buffer, clause, spc, flags);
 455       clause = OMP_CLAUSE_CHAIN (clause);
 456       if (clause == NULL)
 457         return;
 458       pp_space (buffer);
 459     }
 460 }
 461
 462
 463 /* Dump location LOC to BUFFER.  */
 464
 465 static void
 466 dump_location (pretty_printer *buffer, location_t loc)
 467 {
 468   expanded_location xloc = expand_location (loc);
 469
 470   pp_character (buffer, '[');
 471   if (xloc.file)
 472     {
 473       pp_string (buffer, xloc.file);
 474       pp_string (buffer, " : ");
 475     }
 476   pp_decimal_int (buffer, xloc.line);
 477   pp_string (buffer, "] ");
 478 }
 479
 480
 481 /* Dump lexical block BLOCK.  BUFFER, SPC and FLAGS are as in
 482    dump_generic_node.  */
 483
 484 static void
 485 dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)
 486 {
 487   tree t;
 488
 489   pp_printf (buffer, "BLOCK #%d ", BLOCK_NUMBER (block));
 490
 491   if (flags & TDF_ADDRESS)
 492     pp_printf (buffer, "[%p] ", (void *) block);
 493
 494   if (BLOCK_ABSTRACT (block))
 495     pp_string (buffer, "[abstract] ");
 496
 497   if (TREE_ASM_WRITTEN (block))
 498     pp_string (buffer, "[written] ");
 499
 500   if (flags & TDF_SLIM)
 501     return;
 502
 503   if (BLOCK_SOURCE_LOCATION (block))
 504     dump_location (buffer, BLOCK_SOURCE_LOCATION (block));
 505
 506   newline_and_indent (buffer, spc + 2);
 507
 508   if (BLOCK_SUPERCONTEXT (block))
 509     {
 510       pp_string (buffer, "SUPERCONTEXT: ");
 511       dump_generic_node (buffer, BLOCK_SUPERCONTEXT (block), 0,
 512                          flags | TDF_SLIM, false);
 513       newline_and_indent (buffer, spc + 2);
 514     }
 515
 516   if (BLOCK_SUBBLOCKS (block))
 517     {
 518       pp_string (buffer, "SUBBLOCKS: ");
 519       for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
 520         {
 521           dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
 522           pp_string (buffer, " ");
 523         }
 524       newline_and_indent (buffer, spc + 2);
 525     }
 526
 527   if (BLOCK_CHAIN (block))
 528     {
 529       pp_string (buffer, "SIBLINGS: ");
 530       for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))
 531         {
 532           dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
 533           pp_string (buffer, " ");
 534         }
 535       newline_and_indent (buffer, spc + 2);
 536     }
 537
 538   if (BLOCK_VARS (block))
 539     {
 540       pp_string (buffer, "VARS: ");
 541       for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
 542         {
 543           dump_generic_node (buffer, t, 0, flags, false);
 544           pp_string (buffer, " ");
 545         }
 546       newline_and_indent (buffer, spc + 2);
 547     }
 548
 549   if (VEC_length (tree, BLOCK_NONLOCALIZED_VARS (block)) > 0)
 550     {
 551       unsigned i;
 552       VEC(tree,gc) *nlv = BLOCK_NONLOCALIZED_VARS (block);
 553
 554       pp_string (buffer, "NONLOCALIZED_VARS: ");
 555       FOR_EACH_VEC_ELT (tree, nlv, i, t)
 556         {
 557           dump_generic_node (buffer, t, 0, flags, false);
 558           pp_string (buffer, " ");
 559         }
 560       newline_and_indent (buffer, spc + 2);
 561     }
 562
 563   if (BLOCK_ABSTRACT_ORIGIN (block))
 564     {
 565       pp_string (buffer, "ABSTRACT_ORIGIN: ");
 566       dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (block), 0,
 567                          flags | TDF_SLIM, false);
 568       newline_and_indent (buffer, spc + 2);
 569     }
 570
 571   if (BLOCK_FRAGMENT_ORIGIN (block))
 572     {
 573       pp_string (buffer, "FRAGMENT_ORIGIN: ");
 574       dump_generic_node (buffer, BLOCK_FRAGMENT_ORIGIN (block), 0,
 575                          flags | TDF_SLIM, false);
 576       newline_and_indent (buffer, spc + 2);
 577     }
 578
 579   if (BLOCK_FRAGMENT_CHAIN (block))
 580     {
 581       pp_string (buffer, "FRAGMENT_CHAIN: ");
 582       for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))
 583         {
 584           dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);
 585           pp_string (buffer, " ");
 586         }
 587       newline_and_indent (buffer, spc + 2);
 588     }
 589 }
 590
 591
 592 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of
 593    indent.  FLAGS specifies details to show in the dump (see TDF_* in
 594    tree-pass.h).  If IS_STMT is true, the object printed is considered
 595    to be a statement and it is terminated by ';' if appropriate.  */
 596
 597 int
 598 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 599                    bool is_stmt)
 600 {
 601   tree type;
 602   tree op0, op1;
 603   const char *str;
 604   bool is_expr;
 605
 606   if (node == NULL_TREE)
 607     return spc;
 608
 609   is_expr = EXPR_P (node);
 610
 611   if (is_stmt && (flags & TDF_STMTADDR))
 612     pp_printf (buffer, "<&%p> ", (void *)node);
 613
 614   if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
 615     dump_location (buffer, EXPR_LOCATION (node));
 616
 617   switch (TREE_CODE (node))
 618     {
 619     case ERROR_MARK:
 620       pp_string (buffer, "<<< error >>>");
 621       break;
 622
 623     case IDENTIFIER_NODE:
 624       pp_tree_identifier (buffer, node);
 625       break;
 626
 627     case TREE_LIST:
 628       while (node && node != error_mark_node)
 629         {
 630           if (TREE_PURPOSE (node))
 631             {
 632               dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
 633               pp_space (buffer);
 634             }
 635           dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
 636           node = TREE_CHAIN (node);
 637           if (node && TREE_CODE (node) == TREE_LIST)
 638             {
 639               pp_character (buffer, ',');
 640               pp_space (buffer);
 641             }
 642         }
 643       break;
 644
 645     case TREE_BINFO:
 646       dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
 647       break;
 648
 649     case TREE_VEC:
 650       {
 651         size_t i;
 652         if (TREE_VEC_LENGTH (node) > 0)
 653           {
 654             size_t len = TREE_VEC_LENGTH (node);
 655             for (i = 0; i < len - 1; i++)
 656               {
 657                 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
 658                                    false);
 659                 pp_character (buffer, ',');
 660                 pp_space (buffer);
 661               }
 662             dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
 663                                flags, false);
 664           }
 665       }
 666       break;
 667
 668     case VOID_TYPE:
 669     case INTEGER_TYPE:
 670     case REAL_TYPE:
 671     case FIXED_POINT_TYPE:
 672     case COMPLEX_TYPE:
 673     case VECTOR_TYPE:
 674     case ENUMERAL_TYPE:
 675     case BOOLEAN_TYPE:
 676       {
 677         unsigned int quals = TYPE_QUALS (node);
 678         enum tree_code_class tclass;
 679
 680         if (quals & TYPE_QUAL_CONST)
 681           pp_string (buffer, "const ");
 682         else if (quals & TYPE_QUAL_VOLATILE)
 683           pp_string (buffer, "volatile ");
 684         else if (quals & TYPE_QUAL_RESTRICT)
 685           pp_string (buffer, "restrict ");
 686
 687         if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
 688           {
 689             pp_string (buffer, "<address-space-");
 690             pp_decimal_int (buffer, TYPE_ADDR_SPACE (node));
 691             pp_string (buffer, "> ");
 692           }
 693
 694         tclass = TREE_CODE_CLASS (TREE_CODE (node));
 695
 696         if (tclass == tcc_declaration)
 697           {
 698             if (DECL_NAME (node))
 699               dump_decl_name (buffer, node, flags);
 700             else
 701               pp_string (buffer, "<unnamed type decl>");
 702           }
 703         else if (tclass == tcc_type)
 704           {
 705             if (TYPE_NAME (node))
 706               {
 707                 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
 708                   pp_tree_identifier (buffer, TYPE_NAME (node));
 709                 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
 710                          && DECL_NAME (TYPE_NAME (node)))
 711                   dump_decl_name (buffer, TYPE_NAME (node), flags);
 712                 else
 713                   pp_string (buffer, "<unnamed type>");
 714               }
 715             else if (TREE_CODE (node) == VECTOR_TYPE)
 716               {
 717                 pp_string (buffer, "vector");
 718                 pp_character (buffer, '(');
 719                 pp_wide_integer (buffer, TYPE_VECTOR_SUBPARTS (node));
 720                 pp_string (buffer, ") ");
 721                 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 722               }
 723             else if (TREE_CODE (node) == INTEGER_TYPE)
 724               {
 725                 if (TYPE_PRECISION (node) == CHAR_TYPE_SIZE)
 726                   pp_string (buffer, (TYPE_UNSIGNED (node)
 727                                       ? "unsigned char"
 728                                       : "signed char"));
 729                 else if (TYPE_PRECISION (node) == SHORT_TYPE_SIZE)
 730                   pp_string (buffer, (TYPE_UNSIGNED (node)
 731                                       ? "unsigned short"
 732                                       : "signed short"));
 733                 else if (TYPE_PRECISION (node) == INT_TYPE_SIZE)
 734                   pp_string (buffer, (TYPE_UNSIGNED (node)
 735                                       ? "unsigned int"
 736                                       : "signed int"));
 737                 else if (TYPE_PRECISION (node) == LONG_TYPE_SIZE)
 738                   pp_string (buffer, (TYPE_UNSIGNED (node)
 739                                       ? "unsigned long"
 740                                       : "signed long"));
 741                 else if (TYPE_PRECISION (node) == LONG_LONG_TYPE_SIZE)
 742                   pp_string (buffer, (TYPE_UNSIGNED (node)
 743                                       ? "unsigned long long"
 744                                       : "signed long long"));
 745                 else if (TYPE_PRECISION (node) >= CHAR_TYPE_SIZE
 746                          && exact_log2 (TYPE_PRECISION (node)) != -1)
 747                   {
 748                     pp_string (buffer, (TYPE_UNSIGNED (node) ? "uint" : "int"));
 749                     pp_decimal_int (buffer, TYPE_PRECISION (node));
 750                     pp_string (buffer, "_t");
 751                   }
 752                 else
 753                   {
 754                     pp_string (buffer, (TYPE_UNSIGNED (node)
 755                                         ? "<unnamed-unsigned:"
 756                                         : "<unnamed-signed:"));
 757                     pp_decimal_int (buffer, TYPE_PRECISION (node));
 758                     pp_string (buffer, ">");
 759                   }
 760               }
 761             else if (TREE_CODE (node) == COMPLEX_TYPE)
 762               {
 763                 pp_string (buffer, "__complex__ ");
 764                 dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 765               }
 766             else if (TREE_CODE (node) == REAL_TYPE)
 767               {
 768                 pp_string (buffer, "<float:");
 769                 pp_decimal_int (buffer, TYPE_PRECISION (node));
 770                 pp_string (buffer, ">");
 771               }
 772             else if (TREE_CODE (node) == FIXED_POINT_TYPE)
 773               {
 774                 pp_string (buffer, "<fixed-point-");
 775                 pp_string (buffer, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
 776                 pp_decimal_int (buffer, TYPE_PRECISION (node));
 777                 pp_string (buffer, ">");
 778               }
 779             else if (TREE_CODE (node) == VOID_TYPE)
 780               pp_string (buffer, "void");
 781             else
 782               pp_string (buffer, "<unnamed type>");
 783           }
 784         break;
 785       }
 786
 787     case POINTER_TYPE:
 788     case REFERENCE_TYPE:
 789       str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
 790
 791       if (TREE_TYPE (node) == NULL)
 792         {
 793           pp_string (buffer, str);
 794           pp_string (buffer, "<null type>");
 795         }
 796       else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
 797         {
 798           tree fnode = TREE_TYPE (node);
 799
 800           dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
 801           pp_space (buffer);
 802           pp_character (buffer, '(');
 803           pp_string (buffer, str);
 804           if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
 805             dump_decl_name (buffer, TYPE_NAME (node), flags);
 806           else if (flags & TDF_NOUID)
 807             pp_printf (buffer, "<Txxxx>");
 808           else
 809             pp_printf (buffer, "<T%x>", TYPE_UID (node));
 810
 811           pp_character (buffer, ')');
 812           dump_function_declaration (buffer, fnode, spc, flags);
 813         }
 814       else
 815         {
 816           unsigned int quals = TYPE_QUALS (node);
 817
 818           dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 819           pp_space (buffer);
 820           pp_string (buffer, str);
 821
 822           if (quals & TYPE_QUAL_CONST)
 823             pp_string (buffer, " const");
 824           if (quals & TYPE_QUAL_VOLATILE)
 825             pp_string (buffer, " volatile");
 826           if (quals & TYPE_QUAL_RESTRICT)
 827             pp_string (buffer, " restrict");
 828
 829           if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
 830             {
 831               pp_string (buffer, " <address-space-");
 832               pp_decimal_int (buffer, TYPE_ADDR_SPACE (node));
 833               pp_string (buffer, ">");
 834             }
 835
 836           if (TYPE_REF_CAN_ALIAS_ALL (node))
 837             pp_string (buffer, " {ref-all}");
 838         }
 839       break;
 840
 841     case OFFSET_TYPE:
 842       NIY;
 843       break;
 844
 845     case MEM_REF:
 846       {
 847         if (integer_zerop (TREE_OPERAND (node, 1))
 848             /* Dump the types of INTEGER_CSTs explicitly, for we can't
 849                infer them and MEM_ATTR caching will share MEM_REFs
 850                with differently-typed op0s.  */
 851             && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
 852             /* Released SSA_NAMES have no TREE_TYPE.  */
 853             && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
 854             /* Same pointer types, but ignoring POINTER_TYPE vs.
 855                REFERENCE_TYPE.  */
 856             && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
 857                 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
 858             && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
 859                 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
 860             && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
 861                 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
 862             /* Same value types ignoring qualifiers.  */
 863             && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
 864                 == TYPE_MAIN_VARIANT
 865                     (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))))
 866           {
 867             if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
 868               {
 869                 pp_string (buffer, "*");
 870                 dump_generic_node (buffer, TREE_OPERAND (node, 0),
 871                                    spc, flags, false);
 872               }
 873             else
 874               dump_generic_node (buffer,
 875                                  TREE_OPERAND (TREE_OPERAND (node, 0), 0),
 876                                  spc, flags, false);
 877           }
 878         else
 879           {
 880             tree ptype;
 881
 882             pp_string (buffer, "MEM[");
 883             pp_string (buffer, "(");
 884             ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1)));
 885             dump_generic_node (buffer, ptype,
 886                                spc, flags | TDF_SLIM, false);
 887             pp_string (buffer, ")");
 888             dump_generic_node (buffer, TREE_OPERAND (node, 0),
 889                                spc, flags, false);
 890             if (!integer_zerop (TREE_OPERAND (node, 1)))
 891               {
 892                 pp_string (buffer, " + ");
 893                 dump_generic_node (buffer, TREE_OPERAND (node, 1),
 894                                    spc, flags, false);
 895               }
 896             pp_string (buffer, "]");
 897           }
 898         break;
 899       }
 900
 901     case TARGET_MEM_REF:
 902       {
 903         const char *sep = "";
 904         tree tmp;
 905
 906         pp_string (buffer, "MEM[");
 907
 908         if (TREE_CODE (TMR_BASE (node)) == ADDR_EXPR)
 909           {
 910             pp_string (buffer, sep);
 911             sep = ", ";
 912             pp_string (buffer, "symbol: ");
 913             dump_generic_node (buffer, TREE_OPERAND (TMR_BASE (node), 0),
 914                                spc, flags, false);
 915           }
 916         else
 917           {
 918             pp_string (buffer, sep);
 919             sep = ", ";
 920             pp_string (buffer, "base: ");
 921             dump_generic_node (buffer, TMR_BASE (node), spc, flags, false);
 922           }
 923         tmp = TMR_INDEX2 (node);
 924         if (tmp)
 925           {
 926             pp_string (buffer, sep);
 927             sep = ", ";
 928             pp_string (buffer, "base: ");
 929             dump_generic_node (buffer, tmp, spc, flags, false);
 930           }
 931         tmp = TMR_INDEX (node);
 932         if (tmp)
 933           {
 934             pp_string (buffer, sep);
 935             sep = ", ";
 936             pp_string (buffer, "index: ");
 937             dump_generic_node (buffer, tmp, spc, flags, false);
 938           }
 939         tmp = TMR_STEP (node);
 940         if (tmp)
 941           {
 942             pp_string (buffer, sep);
 943             sep = ", ";
 944             pp_string (buffer, "step: ");
 945             dump_generic_node (buffer, tmp, spc, flags, false);
 946           }
 947         tmp = TMR_OFFSET (node);
 948         if (tmp)
 949           {
 950             pp_string (buffer, sep);
 951             sep = ", ";
 952             pp_string (buffer, "offset: ");
 953             dump_generic_node (buffer, tmp, spc, flags, false);
 954           }
 955         pp_string (buffer, "]");
 956       }
 957       break;
 958
 959     case ARRAY_TYPE:
 960       {
 961         tree tmp;
 962
 963         /* Print the innermost component type.  */
 964         for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
 965              tmp = TREE_TYPE (tmp))
 966           ;
 967         dump_generic_node (buffer, tmp, spc, flags, false);
 968
 969         /* Print the dimensions.  */
 970         for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
 971           dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
 972         break;
 973       }
 974
 975     case RECORD_TYPE:
 976     case UNION_TYPE:
 977     case QUAL_UNION_TYPE:
 978       {
 979         unsigned int quals = TYPE_QUALS (node);
 980
 981         if (quals & TYPE_QUAL_CONST)
 982           pp_string (buffer, "const ");
 983         if (quals & TYPE_QUAL_VOLATILE)
 984           pp_string (buffer, "volatile ");
 985
 986         /* Print the name of the structure.  */
 987         if (TREE_CODE (node) == RECORD_TYPE)
 988           pp_string (buffer, "struct ");
 989         else if (TREE_CODE (node) == UNION_TYPE)
 990           pp_string (buffer, "union ");
 991
 992         if (TYPE_NAME (node))
 993           dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
 994         else if (!(flags & TDF_SLIM))
 995           /* FIXME: If we eliminate the 'else' above and attempt
 996              to show the fields for named types, we may get stuck
 997              following a cycle of pointers to structs.  The alleged
 998              self-reference check in print_struct_decl will not detect
 999              cycles involving more than one pointer or struct type.  */
1000           print_struct_decl (buffer, node, spc, flags);
1001         break;
1002       }
1003
1004     case LANG_TYPE:
1005       NIY;
1006       break;
1007
1008     case INTEGER_CST:
1009       if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
1010         {
1011           /* In the case of a pointer, one may want to divide by the
1012              size of the pointed-to type.  Unfortunately, this not
1013              straightforward.  The C front-end maps expressions
1014
1015              (int *) 5
1016              int *p; (p + 5)
1017
1018              in such a way that the two INTEGER_CST nodes for "5" have
1019              different values but identical types.  In the latter
1020              case, the 5 is multiplied by sizeof (int) in c-common.c
1021              (pointer_int_sum) to convert it to a byte address, and
1022              yet the type of the node is left unchanged.  Argh.  What
1023              is consistent though is that the number value corresponds
1024              to bytes (UNITS) offset.
1025
1026              NB: Neither of the following divisors can be trivially
1027              used to recover the original literal:
1028
1029              TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1030              TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node)))  */
1031           pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
1032           pp_string (buffer, "B"); /* pseudo-unit */
1033         }
1034       else if (host_integerp (node, 0))
1035         pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
1036       else if (host_integerp (node, 1))
1037         pp_unsigned_wide_integer (buffer, TREE_INT_CST_LOW (node));
1038       else
1039         {
1040           tree val = node;
1041           unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
1042           HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
1043
1044           if (tree_int_cst_sgn (val) < 0)
1045             {
1046               pp_character (buffer, '-');
1047               high = ~high + !low;
1048               low = -low;
1049             }
1050           /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
1051              systems?  */
1052           sprintf (pp_buffer (buffer)->digit_buffer,
1053                    HOST_WIDE_INT_PRINT_DOUBLE_HEX,
1054                    (unsigned HOST_WIDE_INT) high, low);
1055           pp_string (buffer, pp_buffer (buffer)->digit_buffer);
1056         }
1057       break;
1058
1059     case REAL_CST:
1060       /* Code copied from print_node.  */
1061       {
1062         REAL_VALUE_TYPE d;
1063         if (TREE_OVERFLOW (node))
1064           pp_string (buffer, " overflow");
1065
1066 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
1067         d = TREE_REAL_CST (node);
1068         if (REAL_VALUE_ISINF (d))
1069           pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
1070         else if (REAL_VALUE_ISNAN (d))
1071           pp_string (buffer, " Nan");
1072         else
1073           {
1074             char string[100];
1075             real_to_decimal (string, &d, sizeof (string), 0, 1);
1076             pp_string (buffer, string);
1077           }
1078 #else
1079         {
1080           HOST_WIDE_INT i;
1081           unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
1082           pp_string (buffer, "0x");
1083           for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
1084             output_formatted_integer (buffer, "%02x", *p++);
1085         }
1086 #endif
1087         break;
1088       }
1089
1090     case FIXED_CST:
1091       {
1092         char string[100];
1093         fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
1094         pp_string (buffer, string);
1095         break;
1096       }
1097
1098     case COMPLEX_CST:
1099       pp_string (buffer, "__complex__ (");
1100       dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
1101       pp_string (buffer, ", ");
1102       dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
1103       pp_string (buffer, ")");
1104       break;
1105
1106     case STRING_CST:
1107       pp_string (buffer, "\"");
1108       pretty_print_string (buffer, TREE_STRING_POINTER (node));
1109       pp_string (buffer, "\"");
1110       break;
1111
1112     case VECTOR_CST:
1113       {
1114         unsigned i;
1115         pp_string (buffer, "{ ");
1116         for (i = 0; i < VECTOR_CST_NELTS (node); ++i)
1117           {
1118             if (i != 0)
1119               pp_string (buffer, ", ");
1120             dump_generic_node (buffer, VECTOR_CST_ELT (node, i),
1121                                spc, flags, false);
1122           }
1123         pp_string (buffer, " }");
1124       }
1125       break;
1126
1127     case FUNCTION_TYPE:
1128     case METHOD_TYPE:
1129       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1130       pp_space (buffer);
1131       if (TREE_CODE (node) == METHOD_TYPE)
1132         {
1133           if (TYPE_METHOD_BASETYPE (node))
1134             dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
1135                             flags);
1136           else
1137             pp_string (buffer, "<null method basetype>");
1138           pp_string (buffer, "::");
1139         }
1140       if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
1141         dump_decl_name (buffer, TYPE_NAME (node), flags);
1142       else if (flags & TDF_NOUID)
1143         pp_printf (buffer, "<Txxxx>");
1144       else
1145         pp_printf (buffer, "<T%x>", TYPE_UID (node));
1146       dump_function_declaration (buffer, node, spc, flags);
1147       break;
1148
1149     case FUNCTION_DECL:
1150     case CONST_DECL:
1151       dump_decl_name (buffer, node, flags);
1152       break;
1153
1154     case LABEL_DECL:
1155       if (DECL_NAME (node))
1156         dump_decl_name (buffer, node, flags);
1157       else if (LABEL_DECL_UID (node) != -1)
1158         pp_printf (buffer, "<L%d>", (int) LABEL_DECL_UID (node));
1159       else
1160         {
1161           if (flags & TDF_NOUID)
1162             pp_string (buffer, "<D.xxxx>");
1163           else
1164             pp_printf (buffer, "<D.%u>", DECL_UID (node));
1165         }
1166       break;
1167
1168     case TYPE_DECL:
1169       if (DECL_IS_BUILTIN (node))
1170         {
1171           /* Don't print the declaration of built-in types.  */
1172           break;
1173         }
1174       if (DECL_NAME (node))
1175         dump_decl_name (buffer, node, flags);
1176       else if (TYPE_NAME (TREE_TYPE (node)) != node)
1177         {
1178           if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
1179                || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
1180               && TYPE_METHODS (TREE_TYPE (node)))
1181             {
1182               /* The type is a c++ class: all structures have at least
1183                  4 methods.  */
1184               pp_string (buffer, "class ");
1185               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1186             }
1187           else
1188             {
1189               pp_string (buffer,
1190                          (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
1191                           ? "union" : "struct "));
1192               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1193             }
1194         }
1195       else
1196         pp_string (buffer, "<anon>");
1197       break;
1198
1199     case VAR_DECL:
1200     case PARM_DECL:
1201     case FIELD_DECL:
1202     case DEBUG_EXPR_DECL:
1203     case NAMESPACE_DECL:
1204       dump_decl_name (buffer, node, flags);
1205       break;
1206
1207     case RESULT_DECL:
1208       pp_string (buffer, "<retval>");
1209       break;
1210
1211     case COMPONENT_REF:
1212       op0 = TREE_OPERAND (node, 0);
1213       str = ".";
1214       if (op0
1215           && (TREE_CODE (op0) == INDIRECT_REF
1216               || (TREE_CODE (op0) == MEM_REF
1217                   && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
1218                   && integer_zerop (TREE_OPERAND (op0, 1))
1219                   /* Dump the types of INTEGER_CSTs explicitly, for we
1220                      can't infer them and MEM_ATTR caching will share
1221                      MEM_REFs with differently-typed op0s.  */
1222                   && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
1223                   /* Released SSA_NAMES have no TREE_TYPE.  */
1224                   && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE
1225                   /* Same pointer types, but ignoring POINTER_TYPE vs.
1226                      REFERENCE_TYPE.  */
1227                   && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
1228                       == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))
1229                   && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0)))
1230                       == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
1231                   && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
1232                       == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
1233                   /* Same value types ignoring qualifiers.  */
1234                   && (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
1235                       == TYPE_MAIN_VARIANT
1236                           (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))))))
1237         {
1238           op0 = TREE_OPERAND (op0, 0);
1239           str = "->";
1240         }
1241       if (op_prio (op0) < op_prio (node))
1242         pp_character (buffer, '(');
1243       dump_generic_node (buffer, op0, spc, flags, false);
1244       if (op_prio (op0) < op_prio (node))
1245         pp_character (buffer, ')');
1246       pp_string (buffer, str);
1247       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1248       op0 = component_ref_field_offset (node);
1249       if (op0 && TREE_CODE (op0) != INTEGER_CST)
1250         {
1251           pp_string (buffer, "{off: ");
1252               dump_generic_node (buffer, op0, spc, flags, false);
1253               pp_character (buffer, '}');
1254         }
1255       break;
1256
1257     case BIT_FIELD_REF:
1258       pp_string (buffer, "BIT_FIELD_REF <");
1259       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1260       pp_string (buffer, ", ");
1261       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1262       pp_string (buffer, ", ");
1263       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1264       pp_string (buffer, ">");
1265       break;
1266
1267     case ARRAY_REF:
1268     case ARRAY_RANGE_REF:
1269       op0 = TREE_OPERAND (node, 0);
1270       if (op_prio (op0) < op_prio (node))
1271         pp_character (buffer, '(');
1272       dump_generic_node (buffer, op0, spc, flags, false);
1273       if (op_prio (op0) < op_prio (node))
1274         pp_character (buffer, ')');
1275       pp_character (buffer, '[');
1276       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1277       if (TREE_CODE (node) == ARRAY_RANGE_REF)
1278         pp_string (buffer, " ...");
1279       pp_character (buffer, ']');
1280
1281       op0 = array_ref_low_bound (node);
1282       op1 = array_ref_element_size (node);
1283
1284       if (!integer_zerop (op0)
1285           || TREE_OPERAND (node, 2)
1286           || TREE_OPERAND (node, 3))
1287         {
1288           pp_string (buffer, "{lb: ");
1289           dump_generic_node (buffer, op0, spc, flags, false);
1290           pp_string (buffer, " sz: ");
1291           dump_generic_node (buffer, op1, spc, flags, false);
1292           pp_character (buffer, '}');
1293         }
1294       break;
1295
1296     case CONSTRUCTOR:
1297       {
1298         unsigned HOST_WIDE_INT ix;
1299         tree field, val;
1300         bool is_struct_init = false;
1301         bool is_array_init = false;
1302         double_int curidx = double_int_zero;
1303         pp_character (buffer, '{');
1304         if (TREE_CLOBBER_P (node))
1305           pp_string (buffer, "CLOBBER");
1306         else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
1307                  || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
1308           is_struct_init = true;
1309         else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE
1310                  && TYPE_DOMAIN (TREE_TYPE (node))
1311                  && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))
1312                  && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))))
1313                     == INTEGER_CST)
1314           {
1315             tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)));
1316             is_array_init = true;
1317             curidx = tree_to_double_int (minv);
1318           }
1319         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
1320           {
1321             if (field)
1322               {
1323                 if (is_struct_init)
1324                   {
1325                     pp_character (buffer, '.');
1326                     dump_generic_node (buffer, field, spc, flags, false);
1327                     pp_character (buffer, '=');
1328                   }
1329                 else if (is_array_init
1330                          && (TREE_CODE (field) != INTEGER_CST
1331                              || !double_int_equal_p (tree_to_double_int (field),
1332                                                      curidx)))
1333                   {
1334                     pp_character (buffer, '[');
1335                     if (TREE_CODE (field) == RANGE_EXPR)
1336                       {
1337                         dump_generic_node (buffer, TREE_OPERAND (field, 0), spc,
1338                                            flags, false);
1339                         pp_string (buffer, " ... ");
1340                         dump_generic_node (buffer, TREE_OPERAND (field, 1), spc,
1341                                            flags, false);
1342                         if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST)
1343                           curidx = tree_to_double_int (TREE_OPERAND (field, 1));
1344                       }
1345                     else
1346                       dump_generic_node (buffer, field, spc, flags, false);
1347                     if (TREE_CODE (field) == INTEGER_CST)
1348                       curidx = tree_to_double_int (field);
1349                     pp_string (buffer, "]=");
1350                   }
1351               }
1352             if (is_array_init)
1353               curidx = double_int_add (curidx, double_int_one);
1354             if (val && TREE_CODE (val) == ADDR_EXPR)
1355               if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
1356                 val = TREE_OPERAND (val, 0);
1357             if (val && TREE_CODE (val) == FUNCTION_DECL)
1358                 dump_decl_name (buffer, val, flags);
1359             else
1360                 dump_generic_node (buffer, val, spc, flags, false);
1361             if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
1362               {
1363                 pp_character (buffer, ',');
1364                 pp_space (buffer);
1365               }
1366           }
1367         pp_character (buffer, '}');
1368       }
1369       break;
1370
1371     case COMPOUND_EXPR:
1372       {
1373         tree *tp;
1374         if (flags & TDF_SLIM)
1375           {
1376             pp_string (buffer, "<COMPOUND_EXPR>");
1377             break;
1378           }
1379
1380         dump_generic_node (buffer, TREE_OPERAND (node, 0),
1381                            spc, flags, !(flags & TDF_SLIM));
1382         if (flags & TDF_SLIM)
1383           newline_and_indent (buffer, spc);
1384         else
1385           {
1386             pp_character (buffer, ',');
1387             pp_space (buffer);
1388           }
1389
1390         for (tp = &TREE_OPERAND (node, 1);
1391              TREE_CODE (*tp) == COMPOUND_EXPR;
1392              tp = &TREE_OPERAND (*tp, 1))
1393           {
1394             dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
1395                                spc, flags, !(flags & TDF_SLIM));
1396             if (flags & TDF_SLIM)
1397               newline_and_indent (buffer, spc);
1398             else
1399               {
1400                 pp_character (buffer, ',');
1401                 pp_space (buffer);
1402               }
1403           }
1404
1405         dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
1406       }
1407       break;
1408
1409     case STATEMENT_LIST:
1410       {
1411         tree_stmt_iterator si;
1412         bool first = true;
1413
1414         if (flags & TDF_SLIM)
1415           {
1416             pp_string (buffer, "<STATEMENT_LIST>");
1417             break;
1418           }
1419
1420         for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1421           {
1422             if (!first)
1423               newline_and_indent (buffer, spc);
1424             else
1425               first = false;
1426             dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1427           }
1428       }
1429       break;
1430
1431     case MODIFY_EXPR:
1432     case INIT_EXPR:
1433       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags,
1434                          false);
1435       pp_space (buffer);
1436       pp_character (buffer, '=');
1437       if (TREE_CODE (node) == MODIFY_EXPR
1438           && MOVE_NONTEMPORAL (node))
1439         pp_string (buffer, "{nt}");
1440       pp_space (buffer);
1441       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags,
1442                          false);
1443       break;
1444
1445     case TARGET_EXPR:
1446       pp_string (buffer, "TARGET_EXPR <");
1447       dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1448       pp_character (buffer, ',');
1449       pp_space (buffer);
1450       dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1451       pp_character (buffer, '>');
1452       break;
1453
1454     case DECL_EXPR:
1455       print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1456       is_stmt = false;
1457       break;
1458
1459     case COND_EXPR:
1460       if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1461         {
1462           pp_string (buffer, "if (");
1463           dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1464           pp_character (buffer, ')');
1465           /* The lowered cond_exprs should always be printed in full.  */
1466           if (COND_EXPR_THEN (node)
1467               && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1468                   || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1469               && COND_EXPR_ELSE (node)
1470               && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1471                   || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1472             {
1473               pp_space (buffer);
1474               dump_generic_node (buffer, COND_EXPR_THEN (node),
1475                                  0, flags, true);
1476               if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1477                 {
1478                   pp_string (buffer, " else ");
1479                   dump_generic_node (buffer, COND_EXPR_ELSE (node),
1480                                      0, flags, true);
1481                 }
1482             }
1483           else if (!(flags & TDF_SLIM))
1484             {
1485               /* Output COND_EXPR_THEN.  */
1486               if (COND_EXPR_THEN (node))
1487                 {
1488                   newline_and_indent (buffer, spc+2);
1489                   pp_character (buffer, '{');
1490                   newline_and_indent (buffer, spc+4);
1491                   dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1492                                      flags, true);
1493                   newline_and_indent (buffer, spc+2);
1494                   pp_character (buffer, '}');
1495                 }
1496
1497               /* Output COND_EXPR_ELSE.  */
1498               if (COND_EXPR_ELSE (node)
1499                   && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1500                 {
1501                   newline_and_indent (buffer, spc);
1502                   pp_string (buffer, "else");
1503                   newline_and_indent (buffer, spc+2);
1504                   pp_character (buffer, '{');
1505                   newline_and_indent (buffer, spc+4);
1506                   dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1507                                      flags, true);
1508                   newline_and_indent (buffer, spc+2);
1509                   pp_character (buffer, '}');
1510                 }
1511             }
1512           is_expr = false;
1513         }
1514       else
1515         {
1516           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1517           pp_space (buffer);
1518           pp_character (buffer, '?');
1519           pp_space (buffer);
1520           dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1521           pp_space (buffer);
1522           pp_character (buffer, ':');
1523           pp_space (buffer);
1524           dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1525         }
1526       break;
1527
1528     case BIND_EXPR:
1529       pp_character (buffer, '{');
1530       if (!(flags & TDF_SLIM))
1531         {
1532           if (BIND_EXPR_VARS (node))
1533             {
1534               pp_newline (buffer);
1535
1536               for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0))
1537                 {
1538                   print_declaration (buffer, op0, spc+2, flags);
1539                   pp_newline (buffer);
1540                 }
1541             }
1542
1543           newline_and_indent (buffer, spc+2);
1544           dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1545           newline_and_indent (buffer, spc);
1546           pp_character (buffer, '}');
1547         }
1548       is_expr = false;
1549       break;
1550
1551     case CALL_EXPR:
1552       print_call_name (buffer, CALL_EXPR_FN (node), flags);
1553
1554       /* Print parameters.  */
1555       pp_space (buffer);
1556       pp_character (buffer, '(');
1557       {
1558         tree arg;
1559         call_expr_arg_iterator iter;
1560         FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
1561           {
1562             dump_generic_node (buffer, arg, spc, flags, false);
1563             if (more_call_expr_args_p (&iter))
1564               {
1565                 pp_character (buffer, ',');
1566                 pp_space (buffer);
1567               }
1568           }
1569       }
1570       if (CALL_EXPR_VA_ARG_PACK (node))
1571         {
1572           if (call_expr_nargs (node) > 0)
1573             {
1574               pp_character (buffer, ',');
1575               pp_space (buffer);
1576             }
1577           pp_string (buffer, "__builtin_va_arg_pack ()");
1578         }
1579       pp_character (buffer, ')');
1580
1581       op1 = CALL_EXPR_STATIC_CHAIN (node);
1582       if (op1)
1583         {
1584           pp_string (buffer, " [static-chain: ");
1585           dump_generic_node (buffer, op1, spc, flags, false);
1586           pp_character (buffer, ']');
1587         }
1588
1589       if (CALL_EXPR_RETURN_SLOT_OPT (node))
1590         pp_string (buffer, " [return slot optimization]");
1591       if (CALL_EXPR_TAILCALL (node))
1592         pp_string (buffer, " [tail call]");
1593       break;
1594
1595     case WITH_CLEANUP_EXPR:
1596       NIY;
1597       break;
1598
1599     case CLEANUP_POINT_EXPR:
1600       pp_string (buffer, "<<cleanup_point ");
1601       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1602       pp_string (buffer, ">>");
1603       break;
1604
1605     case PLACEHOLDER_EXPR:
1606       pp_string (buffer, "<PLACEHOLDER_EXPR ");
1607       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1608       pp_character (buffer, '>');
1609       break;
1610
1611       /* Binary arithmetic and logic expressions.  */
1612     case WIDEN_SUM_EXPR:
1613     case WIDEN_MULT_EXPR:
1614     case MULT_EXPR:
1615     case MULT_HIGHPART_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 MULT_HIGHPART_EXPR:
2679     case TRUNC_DIV_EXPR:
2680     case CEIL_DIV_EXPR:
2681     case FLOOR_DIV_EXPR:
2682     case ROUND_DIV_EXPR:
2683     case RDIV_EXPR:
2684     case EXACT_DIV_EXPR:
2685     case TRUNC_MOD_EXPR:
2686     case CEIL_MOD_EXPR:
2687     case FLOOR_MOD_EXPR:
2688     case ROUND_MOD_EXPR:
2689     case FMA_EXPR:
2690       return 13;
2691
2692     case TRUTH_NOT_EXPR:
2693     case BIT_NOT_EXPR:
2694     case POSTINCREMENT_EXPR:
2695     case POSTDECREMENT_EXPR:
2696     case PREINCREMENT_EXPR:
2697     case PREDECREMENT_EXPR:
2698     case NEGATE_EXPR:
2699     case INDIRECT_REF:
2700     case ADDR_EXPR:
2701     case FLOAT_EXPR:
2702     CASE_CONVERT:
2703     case FIX_TRUNC_EXPR:
2704     case TARGET_EXPR:
2705       return 14;
2706
2707     case CALL_EXPR:
2708     case ARRAY_REF:
2709     case ARRAY_RANGE_REF:
2710     case COMPONENT_REF:
2711       return 15;
2712
2713       /* Special expressions.  */
2714     case MIN_EXPR:
2715     case MAX_EXPR:
2716     case ABS_EXPR:
2717     case REALPART_EXPR:
2718     case IMAGPART_EXPR:
2719     case REDUC_MAX_EXPR:
2720     case REDUC_MIN_EXPR:
2721     case REDUC_PLUS_EXPR:
2722     case VEC_LSHIFT_EXPR:
2723     case VEC_RSHIFT_EXPR:
2724     case VEC_UNPACK_HI_EXPR:
2725     case VEC_UNPACK_LO_EXPR:
2726     case VEC_UNPACK_FLOAT_HI_EXPR:
2727     case VEC_UNPACK_FLOAT_LO_EXPR:
2728     case VEC_PACK_TRUNC_EXPR:
2729     case VEC_PACK_SAT_EXPR:
2730       return 16;
2731
2732     default:
2733       /* Return an arbitrarily high precedence to avoid surrounding single
2734          VAR_DECLs in ()s.  */
2735       return 9999;
2736     }
2737 }
2738
2739 /* Return the priority of the operator OP.  */
2740
2741 int
2742 op_prio (const_tree op)
2743 {
2744   enum tree_code code;
2745
2746   if (op == NULL)
2747     return 9999;
2748
2749   code = TREE_CODE (op);
2750   if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
2751     return op_prio (TREE_OPERAND (op, 0));
2752
2753   return op_code_prio (code);
2754 }
2755
2756 /* Return the symbol associated with operator CODE.  */
2757
2758 const char *
2759 op_symbol_code (enum tree_code code)
2760 {
2761   switch (code)
2762     {
2763     case MODIFY_EXPR:
2764       return "=";
2765
2766     case TRUTH_OR_EXPR:
2767     case TRUTH_ORIF_EXPR:
2768       return "||";
2769
2770     case TRUTH_AND_EXPR:
2771     case TRUTH_ANDIF_EXPR:
2772       return "&&";
2773
2774     case BIT_IOR_EXPR:
2775       return "|";
2776
2777     case TRUTH_XOR_EXPR:
2778     case BIT_XOR_EXPR:
2779       return "^";
2780
2781     case ADDR_EXPR:
2782     case BIT_AND_EXPR:
2783       return "&";
2784
2785     case ORDERED_EXPR:
2786       return "ord";
2787     case UNORDERED_EXPR:
2788       return "unord";
2789
2790     case EQ_EXPR:
2791       return "==";
2792     case UNEQ_EXPR:
2793       return "u==";
2794
2795     case NE_EXPR:
2796       return "!=";
2797
2798     case LT_EXPR:
2799       return "<";
2800     case UNLT_EXPR:
2801       return "u<";
2802
2803     case LE_EXPR:
2804       return "<=";
2805     case UNLE_EXPR:
2806       return "u<=";
2807
2808     case GT_EXPR:
2809       return ">";
2810     case UNGT_EXPR:
2811       return "u>";
2812
2813     case GE_EXPR:
2814       return ">=";
2815     case UNGE_EXPR:
2816       return "u>=";
2817
2818     case LTGT_EXPR:
2819       return "<>";
2820
2821     case LSHIFT_EXPR:
2822       return "<<";
2823
2824     case RSHIFT_EXPR:
2825       return ">>";
2826
2827     case LROTATE_EXPR:
2828       return "r<<";
2829
2830     case RROTATE_EXPR:
2831       return "r>>";
2832
2833     case VEC_LSHIFT_EXPR:
2834       return "v<<";
2835
2836     case VEC_RSHIFT_EXPR:
2837       return "v>>";
2838
2839     case WIDEN_LSHIFT_EXPR:
2840       return "w<<";
2841
2842     case POINTER_PLUS_EXPR:
2843       return "+";
2844
2845     case PLUS_EXPR:
2846       return "+";
2847
2848     case REDUC_PLUS_EXPR:
2849       return "r+";
2850
2851     case WIDEN_SUM_EXPR:
2852       return "w+";
2853
2854     case WIDEN_MULT_EXPR:
2855       return "w*";
2856
2857     case MULT_HIGHPART_EXPR:
2858       return "h*";
2859
2860     case NEGATE_EXPR:
2861     case MINUS_EXPR:
2862       return "-";
2863
2864     case BIT_NOT_EXPR:
2865       return "~";
2866
2867     case TRUTH_NOT_EXPR:
2868       return "!";
2869
2870     case MULT_EXPR:
2871     case INDIRECT_REF:
2872       return "*";
2873
2874     case TRUNC_DIV_EXPR:
2875     case RDIV_EXPR:
2876       return "/";
2877
2878     case CEIL_DIV_EXPR:
2879       return "/[cl]";
2880
2881     case FLOOR_DIV_EXPR:
2882       return "/[fl]";
2883
2884     case ROUND_DIV_EXPR:
2885       return "/[rd]";
2886
2887     case EXACT_DIV_EXPR:
2888       return "/[ex]";
2889
2890     case TRUNC_MOD_EXPR:
2891       return "%";
2892
2893     case CEIL_MOD_EXPR:
2894       return "%[cl]";
2895
2896     case FLOOR_MOD_EXPR:
2897       return "%[fl]";
2898
2899     case ROUND_MOD_EXPR:
2900       return "%[rd]";
2901
2902     case PREDECREMENT_EXPR:
2903       return " --";
2904
2905     case PREINCREMENT_EXPR:
2906       return " ++";
2907
2908     case POSTDECREMENT_EXPR:
2909       return "-- ";
2910
2911     case POSTINCREMENT_EXPR:
2912       return "++ ";
2913
2914     case MAX_EXPR:
2915       return "max";
2916
2917     case MIN_EXPR:
2918       return "min";
2919
2920     default:
2921       return "<<< ??? >>>";
2922     }
2923 }
2924
2925 /* Return the symbol associated with operator OP.  */
2926
2927 static const char *
2928 op_symbol (const_tree op)
2929 {
2930   return op_symbol_code (TREE_CODE (op));
2931 }
2932
2933 /* Prints the name of a call.  NODE is the CALL_EXPR_FN of a CALL_EXPR or
2934    the gimple_call_fn of a GIMPLE_CALL.  */
2935
2936 void
2937 print_call_name (pretty_printer *buffer, tree node, int flags)
2938 {
2939   tree op0 = node;
2940
2941   if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2942     op0 = TREE_OPERAND (op0, 0);
2943
2944  again:
2945   switch (TREE_CODE (op0))
2946     {
2947     case VAR_DECL:
2948     case PARM_DECL:
2949     case FUNCTION_DECL:
2950       dump_function_name (buffer, op0, flags);
2951       break;
2952
2953     case ADDR_EXPR:
2954     case INDIRECT_REF:
2955     case NOP_EXPR:
2956       op0 = TREE_OPERAND (op0, 0);
2957       goto again;
2958
2959     case COND_EXPR:
2960       pp_string (buffer, "(");
2961       dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, flags, false);
2962       pp_string (buffer, ") ? ");
2963       dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, flags, false);
2964       pp_string (buffer, " : ");
2965       dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, flags, false);
2966       break;
2967
2968     case ARRAY_REF:
2969       if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2970         dump_function_name (buffer, TREE_OPERAND (op0, 0), flags);
2971       else
2972         dump_generic_node (buffer, op0, 0, flags, false);
2973       break;
2974
2975     case MEM_REF:
2976       if (integer_zerop (TREE_OPERAND (op0, 1)))
2977         {
2978           op0 = TREE_OPERAND (op0, 0);
2979           goto again;
2980         }
2981       /* Fallthru.  */
2982     case COMPONENT_REF:
2983     case SSA_NAME:
2984     case OBJ_TYPE_REF:
2985       dump_generic_node (buffer, op0, 0, flags, false);
2986       break;
2987
2988     default:
2989       NIY;
2990     }
2991 }
2992
2993 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ...  */
2994
2995 static void
2996 pretty_print_string (pretty_printer *buffer, const char *str)
2997 {
2998   if (str == NULL)
2999     return;
3000
3001   while (*str)
3002     {
3003       switch (str[0])
3004         {
3005         case '\b':
3006           pp_string (buffer, "\\b");
3007           break;
3008
3009         case '\f':
3010           pp_string (buffer, "\\f");
3011           break;
3012
3013         case '\n':
3014           pp_string (buffer, "\\n");
3015           break;
3016
3017         case '\r':
3018           pp_string (buffer, "\\r");
3019           break;
3020
3021         case '\t':
3022           pp_string (buffer, "\\t");
3023           break;
3024
3025         case '\v':
3026           pp_string (buffer, "\\v");
3027           break;
3028
3029         case '\\':
3030           pp_string (buffer, "\\\\");
3031           break;
3032
3033         case '\"':
3034           pp_string (buffer, "\\\"");
3035           break;
3036
3037         case '\'':
3038           pp_string (buffer, "\\'");
3039           break;
3040
3041           /* No need to handle \0; the loop terminates on \0.  */
3042
3043         case '\1':
3044           pp_string (buffer, "\\1");
3045           break;
3046
3047         case '\2':
3048           pp_string (buffer, "\\2");
3049           break;
3050
3051         case '\3':
3052           pp_string (buffer, "\\3");
3053           break;
3054
3055         case '\4':
3056           pp_string (buffer, "\\4");
3057           break;
3058
3059         case '\5':
3060           pp_string (buffer, "\\5");
3061           break;
3062
3063         case '\6':
3064           pp_string (buffer, "\\6");
3065           break;
3066
3067         case '\7':
3068           pp_string (buffer, "\\7");
3069           break;
3070
3071         default:
3072           pp_character (buffer, str[0]);
3073           break;
3074         }
3075       str++;
3076     }
3077 }
3078
3079 static void
3080 maybe_init_pretty_print (FILE *file)
3081 {
3082   if (!initialized)
3083     {
3084       pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
3085       pp_needs_newline (&buffer) = true;
3086       pp_translate_identifiers (&buffer) = false;
3087       initialized = 1;
3088     }
3089
3090   buffer.buffer->stream = file;
3091 }
3092
3093 static void
3094 newline_and_indent (pretty_printer *buffer, int spc)
3095 {
3096   pp_newline (buffer);
3097   INDENT (spc);
3098 }
3099
3100 /* Handle a %K format for TEXT.  Separate from default_tree_printer so
3101    it can also be used in front ends.
3102    %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3103 */
3104
3105 void
3106 percent_K_format (text_info *text)
3107 {
3108   tree t = va_arg (*text->args_ptr, tree), block;
3109   gcc_assert (text->locus != NULL);
3110   *text->locus = EXPR_LOCATION (t);
3111   gcc_assert (pp_ti_abstract_origin (text) != NULL);
3112   block = TREE_BLOCK (t);
3113   *pp_ti_abstract_origin (text) = NULL;
3114   while (block
3115          && TREE_CODE (block) == BLOCK
3116          && BLOCK_ABSTRACT_ORIGIN (block))
3117     {
3118       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
3119
3120       while (TREE_CODE (ao) == BLOCK
3121              && BLOCK_ABSTRACT_ORIGIN (ao)
3122              && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3123         ao = BLOCK_ABSTRACT_ORIGIN (ao);
3124
3125       if (TREE_CODE (ao) == FUNCTION_DECL)
3126         {
3127           *pp_ti_abstract_origin (text) = block;
3128           break;
3129         }
3130       block = BLOCK_SUPERCONTEXT (block);
3131     }
3132 }
3133
3134 /* Print the identifier ID to PRETTY-PRINTER.  */
3135
3136 void
3137 pp_base_tree_identifier (pretty_printer *pp, tree id)
3138 {
3139   if (pp_translate_identifiers (pp))
3140     {
3141       const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
3142       pp_append_text (pp, text, text + strlen (text));
3143     }
3144   else
3145     pp_append_text (pp, IDENTIFIER_POINTER (id),
3146                     IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
3147 }
3148
3149 /* A helper function that is used to dump function information before the
3150    function dump.  */
3151
3152 void
3153 dump_function_header (FILE *dump_file, tree fdecl, int flags)
3154 {
3155   const char *dname, *aname;
3156   struct cgraph_node *node = cgraph_get_node (fdecl);
3157   struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
3158
3159   dname = lang_hooks.decl_printable_name (fdecl, 2);
3160
3161   if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
3162     aname = (IDENTIFIER_POINTER
3163              (DECL_ASSEMBLER_NAME (fdecl)));
3164   else
3165     aname = "<unset-asm-name>";
3166
3167   fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
3168            dname, aname, fun->funcdef_no);
3169   if (!(flags & TDF_NOUID))
3170     fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
3171   if (node)
3172     {
3173       fprintf (dump_file, ", cgraph_uid=%d)%s\n\n", node->uid,
3174                node->frequency == NODE_FREQUENCY_HOT
3175                ? " (hot)"
3176                : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
3177                ? " (unlikely executed)"
3178                : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
3179                ? " (executed once)"
3180                : "");
3181     }
3182   else
3183     fprintf (dump_file, ")\n\n");
3184 }