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