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