gcc/tree-pretty-print.c

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