gcc/tree-pretty-print.c

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