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