gcc/tree-pretty-print.c

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