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     default:
2408       NIY;
2409     }
2410
2411   if (is_stmt && is_expr)
2412     pp_semicolon (buffer);
2413
2414   /* If we're building a diagnostic, the formatted text will be written
2415      into BUFFER's stream by the caller; otherwise, write it now.  */
2416   if (!(flags & TDF_DIAGNOSTIC))
2417     pp_write_text_to_stream (buffer);
2418
2419   return spc;
2420 }
2421
2422 /* Print the declaration of a variable.  */
2423
2424 void
2425 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2426 {
2427   INDENT (spc);
2428
2429   if (TREE_CODE (t) == TYPE_DECL)
2430     pp_string (buffer, "typedef ");
2431
2432   if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2433     pp_string (buffer, "register ");
2434
2435   if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2436     pp_string (buffer, "extern ");
2437   else if (TREE_STATIC (t))
2438     pp_string (buffer, "static ");
2439
2440   /* Print the type and name.  */
2441   if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2442     {
2443       tree tmp;
2444
2445       /* Print array's type.  */
2446       tmp = TREE_TYPE (t);
2447       while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2448         tmp = TREE_TYPE (tmp);
2449       dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2450
2451       /* Print variable's name.  */
2452       pp_space (buffer);
2453       dump_generic_node (buffer, t, spc, flags, false);
2454
2455       /* Print the dimensions.  */
2456       tmp = TREE_TYPE (t);
2457       while (TREE_CODE (tmp) == ARRAY_TYPE)
2458         {
2459           dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2460           tmp = TREE_TYPE (tmp);
2461         }
2462     }
2463   else if (TREE_CODE (t) == FUNCTION_DECL)
2464     {
2465       dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2466       pp_space (buffer);
2467       dump_decl_name (buffer, t, flags);
2468       dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2469     }
2470   else
2471     {
2472       /* Print type declaration.  */
2473       dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2474
2475       /* Print variable's name.  */
2476       pp_space (buffer);
2477       dump_generic_node (buffer, t, spc, flags, false);
2478     }
2479
2480   if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2481     {
2482       pp_string (buffer, " __asm__ ");
2483       pp_character (buffer, '(');
2484       dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2485       pp_character (buffer, ')');
2486     }
2487
2488   /* The initial value of a function serves to determine whether the function
2489      is declared or defined.  So the following does not apply to function
2490      nodes.  */
2491   if (TREE_CODE (t) != FUNCTION_DECL)
2492     {
2493       /* Print the initial value.  */
2494       if (DECL_INITIAL (t))
2495         {
2496           pp_space (buffer);
2497           pp_character (buffer, '=');
2498           pp_space (buffer);
2499           dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2500         }
2501     }
2502
2503   if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2504     {
2505       pp_string (buffer, " [value-expr: ");
2506       dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2507       pp_character (buffer, ']');
2508     }
2509
2510   pp_character (buffer, ';');
2511 }
2512
2513
2514 /* Prints a structure: name, fields, and methods.
2515    FIXME: Still incomplete.  */
2516
2517 static void
2518 print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
2519 {
2520   /* Print the name of the structure.  */
2521   if (TYPE_NAME (node))
2522     {
2523       INDENT (spc);
2524       if (TREE_CODE (node) == RECORD_TYPE)
2525         pp_string (buffer, "struct ");
2526       else if ((TREE_CODE (node) == UNION_TYPE
2527                 || TREE_CODE (node) == QUAL_UNION_TYPE))
2528         pp_string (buffer, "union ");
2529
2530       dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2531     }
2532
2533   /* Print the contents of the structure.  */
2534   pp_newline (buffer);
2535   INDENT (spc);
2536   pp_character (buffer, '{');
2537   pp_newline (buffer);
2538
2539   /* Print the fields of the structure.  */
2540   {
2541     tree tmp;
2542     tmp = TYPE_FIELDS (node);
2543     while (tmp)
2544       {
2545         /* Avoid to print recursively the structure.  */
2546         /* FIXME : Not implemented correctly...,
2547            what about the case when we have a cycle in the contain graph? ...
2548            Maybe this could be solved by looking at the scope in which the
2549            structure was declared.  */
2550         if (TREE_TYPE (tmp) != node
2551             && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
2552                 || TREE_TYPE (TREE_TYPE (tmp)) != node))
2553           {
2554             print_declaration (buffer, tmp, spc+2, flags);
2555             pp_newline (buffer);
2556           }
2557         tmp = DECL_CHAIN (tmp);
2558       }
2559   }
2560   INDENT (spc);
2561   pp_character (buffer, '}');
2562 }
2563
2564 /* Return the priority of the operator CODE.
2565
2566    From lowest to highest precedence with either left-to-right (L-R)
2567    or right-to-left (R-L) associativity]:
2568
2569      1  [L-R] ,
2570      2  [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2571      3  [R-L] ?:
2572      4  [L-R] ||
2573      5  [L-R] &&
2574      6  [L-R] |
2575      7  [L-R] ^
2576      8  [L-R] &
2577      9  [L-R] == !=
2578     10  [L-R] < <= > >=
2579     11  [L-R] << >>
2580     12  [L-R] + -
2581     13  [L-R] * / %
2582     14  [R-L] ! ~ ++ -- + - * & (type) sizeof
2583     15  [L-R] fn() [] -> .
2584
2585    unary +, - and * have higher precedence than the corresponding binary
2586    operators.  */
2587
2588 int
2589 op_code_prio (enum tree_code code)
2590 {
2591   switch (code)
2592     {
2593     case TREE_LIST:
2594     case COMPOUND_EXPR:
2595     case BIND_EXPR:
2596       return 1;
2597
2598     case MODIFY_EXPR:
2599     case INIT_EXPR:
2600       return 2;
2601
2602     case COND_EXPR:
2603       return 3;
2604
2605     case TRUTH_OR_EXPR:
2606     case TRUTH_ORIF_EXPR:
2607       return 4;
2608
2609     case TRUTH_AND_EXPR:
2610     case TRUTH_ANDIF_EXPR:
2611       return 5;
2612
2613     case BIT_IOR_EXPR:
2614       return 6;
2615
2616     case BIT_XOR_EXPR:
2617     case TRUTH_XOR_EXPR:
2618       return 7;
2619
2620     case BIT_AND_EXPR:
2621       return 8;
2622
2623     case EQ_EXPR:
2624     case NE_EXPR:
2625       return 9;
2626
2627     case UNLT_EXPR:
2628     case UNLE_EXPR:
2629     case UNGT_EXPR:
2630     case UNGE_EXPR:
2631     case UNEQ_EXPR:
2632     case LTGT_EXPR:
2633     case ORDERED_EXPR:
2634     case UNORDERED_EXPR:
2635     case LT_EXPR:
2636     case LE_EXPR:
2637     case GT_EXPR:
2638     case GE_EXPR:
2639       return 10;
2640
2641     case LSHIFT_EXPR:
2642     case RSHIFT_EXPR:
2643     case LROTATE_EXPR:
2644     case RROTATE_EXPR:
2645     case VEC_WIDEN_LSHIFT_HI_EXPR:
2646     case VEC_WIDEN_LSHIFT_LO_EXPR:
2647     case WIDEN_LSHIFT_EXPR:
2648       return 11;
2649
2650     case WIDEN_SUM_EXPR:
2651     case PLUS_EXPR:
2652     case POINTER_PLUS_EXPR:
2653     case MINUS_EXPR:
2654       return 12;
2655
2656     case VEC_WIDEN_MULT_HI_EXPR:
2657     case VEC_WIDEN_MULT_LO_EXPR:
2658     case WIDEN_MULT_EXPR:
2659     case DOT_PROD_EXPR:
2660     case WIDEN_MULT_PLUS_EXPR:
2661     case WIDEN_MULT_MINUS_EXPR:
2662     case MULT_EXPR:
2663     case TRUNC_DIV_EXPR:
2664     case CEIL_DIV_EXPR:
2665     case FLOOR_DIV_EXPR:
2666     case ROUND_DIV_EXPR:
2667     case RDIV_EXPR:
2668     case EXACT_DIV_EXPR:
2669     case TRUNC_MOD_EXPR:
2670     case CEIL_MOD_EXPR:
2671     case FLOOR_MOD_EXPR:
2672     case ROUND_MOD_EXPR:
2673     case FMA_EXPR:
2674       return 13;
2675
2676     case TRUTH_NOT_EXPR:
2677     case BIT_NOT_EXPR:
2678     case POSTINCREMENT_EXPR:
2679     case POSTDECREMENT_EXPR:
2680     case PREINCREMENT_EXPR:
2681     case PREDECREMENT_EXPR:
2682     case NEGATE_EXPR:
2683     case INDIRECT_REF:
2684     case ADDR_EXPR:
2685     case FLOAT_EXPR:
2686     CASE_CONVERT:
2687     case FIX_TRUNC_EXPR:
2688     case TARGET_EXPR:
2689       return 14;
2690
2691     case CALL_EXPR:
2692     case ARRAY_REF:
2693     case ARRAY_RANGE_REF:
2694     case COMPONENT_REF:
2695       return 15;
2696
2697       /* Special expressions.  */
2698     case MIN_EXPR:
2699     case MAX_EXPR:
2700     case ABS_EXPR:
2701     case REALPART_EXPR:
2702     case IMAGPART_EXPR:
2703     case REDUC_MAX_EXPR:
2704     case REDUC_MIN_EXPR:
2705     case REDUC_PLUS_EXPR:
2706     case VEC_LSHIFT_EXPR:
2707     case VEC_RSHIFT_EXPR:
2708     case VEC_UNPACK_HI_EXPR:
2709     case VEC_UNPACK_LO_EXPR:
2710     case VEC_UNPACK_FLOAT_HI_EXPR:
2711     case VEC_UNPACK_FLOAT_LO_EXPR:
2712     case VEC_PACK_TRUNC_EXPR:
2713     case VEC_PACK_SAT_EXPR:
2714       return 16;
2715
2716     default:
2717       /* Return an arbitrarily high precedence to avoid surrounding single
2718          VAR_DECLs in ()s.  */
2719       return 9999;
2720     }
2721 }
2722
2723 /* Return the priority of the operator OP.  */
2724
2725 int
2726 op_prio (const_tree op)
2727 {
2728   enum tree_code code;
2729
2730   if (op == NULL)
2731     return 9999;
2732
2733   code = TREE_CODE (op);
2734   if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
2735     return op_prio (TREE_OPERAND (op, 0));
2736
2737   return op_code_prio (code);
2738 }
2739
2740 /* Return the symbol associated with operator CODE.  */
2741
2742 const char *
2743 op_symbol_code (enum tree_code code)
2744 {
2745   switch (code)
2746     {
2747     case MODIFY_EXPR:
2748       return "=";
2749
2750     case TRUTH_OR_EXPR:
2751     case TRUTH_ORIF_EXPR:
2752       return "||";
2753
2754     case TRUTH_AND_EXPR:
2755     case TRUTH_ANDIF_EXPR:
2756       return "&&";
2757
2758     case BIT_IOR_EXPR:
2759       return "|";
2760
2761     case TRUTH_XOR_EXPR:
2762     case BIT_XOR_EXPR:
2763       return "^";
2764
2765     case ADDR_EXPR:
2766     case BIT_AND_EXPR:
2767       return "&";
2768
2769     case ORDERED_EXPR:
2770       return "ord";
2771     case UNORDERED_EXPR:
2772       return "unord";
2773
2774     case EQ_EXPR:
2775       return "==";
2776     case UNEQ_EXPR:
2777       return "u==";
2778
2779     case NE_EXPR:
2780       return "!=";
2781
2782     case LT_EXPR:
2783       return "<";
2784     case UNLT_EXPR:
2785       return "u<";
2786
2787     case LE_EXPR:
2788       return "<=";
2789     case UNLE_EXPR:
2790       return "u<=";
2791
2792     case GT_EXPR:
2793       return ">";
2794     case UNGT_EXPR:
2795       return "u>";
2796
2797     case GE_EXPR:
2798       return ">=";
2799     case UNGE_EXPR:
2800       return "u>=";
2801
2802     case LTGT_EXPR:
2803       return "<>";
2804
2805     case LSHIFT_EXPR:
2806       return "<<";
2807
2808     case RSHIFT_EXPR:
2809       return ">>";
2810
2811     case LROTATE_EXPR:
2812       return "r<<";
2813
2814     case RROTATE_EXPR:
2815       return "r>>";
2816
2817     case VEC_LSHIFT_EXPR:
2818       return "v<<";
2819
2820     case VEC_RSHIFT_EXPR:
2821       return "v>>";
2822
2823     case WIDEN_LSHIFT_EXPR:
2824       return "w<<";
2825
2826     case POINTER_PLUS_EXPR:
2827       return "+";
2828
2829     case PLUS_EXPR:
2830       return "+";
2831
2832     case REDUC_PLUS_EXPR:
2833       return "r+";
2834
2835     case WIDEN_SUM_EXPR:
2836       return "w+";
2837
2838     case WIDEN_MULT_EXPR:
2839       return "w*";
2840
2841     case NEGATE_EXPR:
2842     case MINUS_EXPR:
2843       return "-";
2844
2845     case BIT_NOT_EXPR:
2846       return "~";
2847
2848     case TRUTH_NOT_EXPR:
2849       return "!";
2850
2851     case MULT_EXPR:
2852     case INDIRECT_REF:
2853       return "*";
2854
2855     case TRUNC_DIV_EXPR:
2856     case RDIV_EXPR:
2857       return "/";
2858
2859     case CEIL_DIV_EXPR:
2860       return "/[cl]";
2861
2862     case FLOOR_DIV_EXPR:
2863       return "/[fl]";
2864
2865     case ROUND_DIV_EXPR:
2866       return "/[rd]";
2867
2868     case EXACT_DIV_EXPR:
2869       return "/[ex]";
2870
2871     case TRUNC_MOD_EXPR:
2872       return "%";
2873
2874     case CEIL_MOD_EXPR:
2875       return "%[cl]";
2876
2877     case FLOOR_MOD_EXPR:
2878       return "%[fl]";
2879
2880     case ROUND_MOD_EXPR:
2881       return "%[rd]";
2882
2883     case PREDECREMENT_EXPR:
2884       return " --";
2885
2886     case PREINCREMENT_EXPR:
2887       return " ++";
2888
2889     case POSTDECREMENT_EXPR:
2890       return "-- ";
2891
2892     case POSTINCREMENT_EXPR:
2893       return "++ ";
2894
2895     case MAX_EXPR:
2896       return "max";
2897
2898     case MIN_EXPR:
2899       return "min";
2900
2901     default:
2902       return "<<< ??? >>>";
2903     }
2904 }
2905
2906 /* Return the symbol associated with operator OP.  */
2907
2908 static const char *
2909 op_symbol (const_tree op)
2910 {
2911   return op_symbol_code (TREE_CODE (op));
2912 }
2913
2914 /* Prints the name of a call.  NODE is the CALL_EXPR_FN of a CALL_EXPR or
2915    the gimple_call_fn of a GIMPLE_CALL.  */
2916
2917 void
2918 print_call_name (pretty_printer *buffer, tree node, int flags)
2919 {
2920   tree op0 = node;
2921
2922   if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2923     op0 = TREE_OPERAND (op0, 0);
2924
2925  again:
2926   switch (TREE_CODE (op0))
2927     {
2928     case VAR_DECL:
2929     case PARM_DECL:
2930     case FUNCTION_DECL:
2931       dump_function_name (buffer, op0, flags);
2932       break;
2933
2934     case ADDR_EXPR:
2935     case INDIRECT_REF:
2936     case NOP_EXPR:
2937       op0 = TREE_OPERAND (op0, 0);
2938       goto again;
2939
2940     case COND_EXPR:
2941       pp_string (buffer, "(");
2942       dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, flags, false);
2943       pp_string (buffer, ") ? ");
2944       dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, flags, false);
2945       pp_string (buffer, " : ");
2946       dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, flags, false);
2947       break;
2948
2949     case ARRAY_REF:
2950       if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2951         dump_function_name (buffer, TREE_OPERAND (op0, 0), flags);
2952       else
2953         dump_generic_node (buffer, op0, 0, flags, false);
2954       break;
2955
2956     case MEM_REF:
2957       if (integer_zerop (TREE_OPERAND (op0, 1)))
2958         {
2959           op0 = TREE_OPERAND (op0, 0);
2960           goto again;
2961         }
2962       /* Fallthru.  */
2963     case COMPONENT_REF:
2964     case SSA_NAME:
2965     case OBJ_TYPE_REF:
2966       dump_generic_node (buffer, op0, 0, flags, false);
2967       break;
2968
2969     default:
2970       NIY;
2971     }
2972 }
2973
2974 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ...  */
2975
2976 static void
2977 pretty_print_string (pretty_printer *buffer, const char *str)
2978 {
2979   if (str == NULL)
2980     return;
2981
2982   while (*str)
2983     {
2984       switch (str[0])
2985         {
2986         case '\b':
2987           pp_string (buffer, "\\b");
2988           break;
2989
2990         case '\f':
2991           pp_string (buffer, "\\f");
2992           break;
2993
2994         case '\n':
2995           pp_string (buffer, "\\n");
2996           break;
2997
2998         case '\r':
2999           pp_string (buffer, "\\r");
3000           break;
3001
3002         case '\t':
3003           pp_string (buffer, "\\t");
3004           break;
3005
3006         case '\v':
3007           pp_string (buffer, "\\v");
3008           break;
3009
3010         case '\\':
3011           pp_string (buffer, "\\\\");
3012           break;
3013
3014         case '\"':
3015           pp_string (buffer, "\\\"");
3016           break;
3017
3018         case '\'':
3019           pp_string (buffer, "\\'");
3020           break;
3021
3022           /* No need to handle \0; the loop terminates on \0.  */
3023
3024         case '\1':
3025           pp_string (buffer, "\\1");
3026           break;
3027
3028         case '\2':
3029           pp_string (buffer, "\\2");
3030           break;
3031
3032         case '\3':
3033           pp_string (buffer, "\\3");
3034           break;
3035
3036         case '\4':
3037           pp_string (buffer, "\\4");
3038           break;
3039
3040         case '\5':
3041           pp_string (buffer, "\\5");
3042           break;
3043
3044         case '\6':
3045           pp_string (buffer, "\\6");
3046           break;
3047
3048         case '\7':
3049           pp_string (buffer, "\\7");
3050           break;
3051
3052         default:
3053           pp_character (buffer, str[0]);
3054           break;
3055         }
3056       str++;
3057     }
3058 }
3059
3060 static void
3061 maybe_init_pretty_print (FILE *file)
3062 {
3063   if (!initialized)
3064     {
3065       pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
3066       pp_needs_newline (&buffer) = true;
3067       pp_translate_identifiers (&buffer) = false;
3068       initialized = 1;
3069     }
3070
3071   buffer.buffer->stream = file;
3072 }
3073
3074 static void
3075 newline_and_indent (pretty_printer *buffer, int spc)
3076 {
3077   pp_newline (buffer);
3078   INDENT (spc);
3079 }
3080
3081 /* Handle a %K format for TEXT.  Separate from default_tree_printer so
3082    it can also be used in front ends.
3083    %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3084 */
3085
3086 void
3087 percent_K_format (text_info *text)
3088 {
3089   tree t = va_arg (*text->args_ptr, tree), block;
3090   gcc_assert (text->locus != NULL);
3091   *text->locus = EXPR_LOCATION (t);
3092   gcc_assert (pp_ti_abstract_origin (text) != NULL);
3093   block = TREE_BLOCK (t);
3094   *pp_ti_abstract_origin (text) = NULL;
3095   while (block
3096          && TREE_CODE (block) == BLOCK
3097          && BLOCK_ABSTRACT_ORIGIN (block))
3098     {
3099       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
3100
3101       while (TREE_CODE (ao) == BLOCK
3102              && BLOCK_ABSTRACT_ORIGIN (ao)
3103              && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3104         ao = BLOCK_ABSTRACT_ORIGIN (ao);
3105
3106       if (TREE_CODE (ao) == FUNCTION_DECL)
3107         {
3108           *pp_ti_abstract_origin (text) = block;
3109           break;
3110         }
3111       block = BLOCK_SUPERCONTEXT (block);
3112     }
3113 }
3114
3115 /* Print the identifier ID to PRETTY-PRINTER.  */
3116
3117 void
3118 pp_base_tree_identifier (pretty_printer *pp, tree id)
3119 {
3120   if (pp_translate_identifiers (pp))
3121     {
3122       const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
3123       pp_append_text (pp, text, text + strlen (text));
3124     }
3125   else
3126     pp_append_text (pp, IDENTIFIER_POINTER (id),
3127                     IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
3128 }
3129
3130 /* A helper function that is used to dump function information before the
3131    function dump.  */
3132
3133 void
3134 dump_function_header (FILE *dump_file, tree fdecl, int flags)
3135 {
3136   const char *dname, *aname;
3137   struct cgraph_node *node = cgraph_get_node (fdecl);
3138   struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
3139
3140   dname = lang_hooks.decl_printable_name (fdecl, 2);
3141
3142   if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
3143     aname = (IDENTIFIER_POINTER
3144              (DECL_ASSEMBLER_NAME (fdecl)));
3145   else
3146     aname = "<unset-asm-name>";
3147
3148   fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
3149            dname, aname, fun->funcdef_no);
3150   if (!(flags & TDF_NOUID))
3151     fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
3152   if (node)
3153     {
3154       fprintf (dump_file, ", cgraph_uid=%d)%s\n\n", node->uid,
3155                node->frequency == NODE_FREQUENCY_HOT
3156                ? " (hot)"
3157                : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
3158                ? " (unlikely executed)"
3159                : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
3160                ? " (executed once)"
3161                : "");
3162     }
3163   else
3164     fprintf (dump_file, ")\n\n");
3165 }