gcc/tree-pretty-print.c

   1 /* Pretty formatting of GENERIC trees in C syntax.
   2    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
   3    Free Software Foundation, Inc.
   4    Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to the Free
  20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  21 02110-1301, USA.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "tree.h"
  28 #include "diagnostic.h"
  29 #include "real.h"
  30 #include "hashtab.h"
  31 #include "tree-flow.h"
  32 #include "langhooks.h"
  33 #include "tree-iterator.h"
  34 #include "tree-chrec.h"
  35 #include "tree-pass.h"
  36 #include "value-prof.h"
  37
  38 /* Local functions, macros and variables.  */
  39 static int op_prio (tree);
  40 static const char *op_symbol_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_OPERAND_LENGTH (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           unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (val);
 752           HOST_WIDE_INT high = TREE_INT_CST_HIGH (val);
 753
 754           if (tree_int_cst_sgn (val) < 0)
 755             {
 756               pp_character (buffer, '-');
 757               high = ~high + !low;
 758               low = -low;
 759             }
 760           /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
 761              systems?  */
 762           sprintf (pp_buffer (buffer)->digit_buffer,
 763                    HOST_WIDE_INT_PRINT_DOUBLE_HEX, high, low);
 764           pp_string (buffer, pp_buffer (buffer)->digit_buffer);
 765         }
 766       else
 767         pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
 768       break;
 769
 770     case REAL_CST:
 771       /* Code copied from print_node.  */
 772       {
 773         REAL_VALUE_TYPE d;
 774         if (TREE_OVERFLOW (node))
 775           pp_string (buffer, " overflow");
 776
 777 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
 778         d = TREE_REAL_CST (node);
 779         if (REAL_VALUE_ISINF (d))
 780           pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
 781         else if (REAL_VALUE_ISNAN (d))
 782           pp_string (buffer, " Nan");
 783         else
 784           {
 785             char string[100];
 786             real_to_decimal (string, &d, sizeof (string), 0, 1);
 787             pp_string (buffer, string);
 788           }
 789 #else
 790         {
 791           HOST_WIDE_INT i;
 792           unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
 793           pp_string (buffer, "0x");
 794           for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
 795             output_formatted_integer (buffer, "%02x", *p++);
 796         }
 797 #endif
 798         break;
 799       }
 800
 801     case COMPLEX_CST:
 802       pp_string (buffer, "__complex__ (");
 803       dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
 804       pp_string (buffer, ", ");
 805       dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
 806       pp_string (buffer, ")");
 807       break;
 808
 809     case STRING_CST:
 810       pp_string (buffer, "\"");
 811       pretty_print_string (buffer, TREE_STRING_POINTER (node));
 812       pp_string (buffer, "\"");
 813       break;
 814
 815     case VECTOR_CST:
 816       {
 817         tree elt;
 818         pp_string (buffer, "{ ");
 819         for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
 820           {
 821             dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
 822             if (TREE_CHAIN (elt))
 823               pp_string (buffer, ", ");
 824           }
 825         pp_string (buffer, " }");
 826       }
 827       break;
 828
 829     case FUNCTION_TYPE:
 830       break;
 831
 832     case FUNCTION_DECL:
 833     case CONST_DECL:
 834       dump_decl_name (buffer, node, flags);
 835       break;
 836
 837     case LABEL_DECL:
 838       if (DECL_NAME (node))
 839         dump_decl_name (buffer, node, flags);
 840       else if (LABEL_DECL_UID (node) != -1)
 841         pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
 842                    LABEL_DECL_UID (node));
 843       else
 844         pp_printf (buffer, "<D%u>", DECL_UID (node));
 845       break;
 846
 847     case TYPE_DECL:
 848       if (DECL_IS_BUILTIN (node))
 849         {
 850           /* Don't print the declaration of built-in types.  */
 851           break;
 852         }
 853       if (DECL_NAME (node))
 854         dump_decl_name (buffer, node, flags);
 855       else
 856         {
 857           if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
 858                || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
 859               && TYPE_METHODS (TREE_TYPE (node)))
 860             {
 861               /* The type is a c++ class: all structures have at least
 862                  4 methods.  */
 863               pp_string (buffer, "class ");
 864               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 865             }
 866           else
 867             {
 868               pp_string (buffer,
 869                          (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
 870                           ? "union" : "struct "));
 871               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 872             }
 873         }
 874       break;
 875
 876     case SYMBOL_MEMORY_TAG:
 877     case NAME_MEMORY_TAG:
 878     case STRUCT_FIELD_TAG:
 879     case VAR_DECL:
 880     case PARM_DECL:
 881     case FIELD_DECL:
 882     case NAMESPACE_DECL:
 883     case MEMORY_PARTITION_TAG:
 884       dump_decl_name (buffer, node, flags);
 885       break;
 886
 887     case RESULT_DECL:
 888       pp_string (buffer, "<retval>");
 889       break;
 890
 891     case COMPONENT_REF:
 892       op0 = TREE_OPERAND (node, 0);
 893       str = ".";
 894       if (TREE_CODE (op0) == INDIRECT_REF)
 895         {
 896           op0 = TREE_OPERAND (op0, 0);
 897           str = "->";
 898         }
 899       if (op_prio (op0) < op_prio (node))
 900         pp_character (buffer, '(');
 901       dump_generic_node (buffer, op0, spc, flags, false);
 902       if (op_prio (op0) < op_prio (node))
 903         pp_character (buffer, ')');
 904       pp_string (buffer, str);
 905       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 906
 907       if (TREE_CODE (op0) != VALUE_HANDLE)
 908         {
 909           op0 = component_ref_field_offset (node);
 910           if (op0 && TREE_CODE (op0) != INTEGER_CST)
 911             {
 912               pp_string (buffer, "{off: ");
 913               dump_generic_node (buffer, op0, spc, flags, false);
 914               pp_character (buffer, '}');
 915             }
 916         }
 917       break;
 918
 919     case BIT_FIELD_REF:
 920       pp_string (buffer, "BIT_FIELD_REF <");
 921       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
 922       pp_string (buffer, ", ");
 923       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 924       pp_string (buffer, ", ");
 925       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
 926       pp_string (buffer, ">");
 927       break;
 928
 929     case ARRAY_REF:
 930     case ARRAY_RANGE_REF:
 931       op0 = TREE_OPERAND (node, 0);
 932       if (op_prio (op0) < op_prio (node))
 933         pp_character (buffer, '(');
 934       dump_generic_node (buffer, op0, spc, flags, false);
 935       if (op_prio (op0) < op_prio (node))
 936         pp_character (buffer, ')');
 937       pp_character (buffer, '[');
 938       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 939       if (TREE_CODE (node) == ARRAY_RANGE_REF)
 940         pp_string (buffer, " ...");
 941       pp_character (buffer, ']');
 942
 943       op0 = array_ref_low_bound (node);
 944       op1 = array_ref_element_size (node);
 945
 946       if (!integer_zerop (op0)
 947           || (TYPE_SIZE_UNIT (TREE_TYPE (node))
 948               && !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))
 949         {
 950           pp_string (buffer, "{lb: ");
 951           dump_generic_node (buffer, op0, spc, flags, false);
 952           pp_string (buffer, " sz: ");
 953           dump_generic_node (buffer, op1, spc, flags, false);
 954           pp_character (buffer, '}');
 955         }
 956       break;
 957
 958     case CONSTRUCTOR:
 959       {
 960         unsigned HOST_WIDE_INT ix;
 961         tree field, val;
 962         bool is_struct_init = FALSE;
 963         pp_character (buffer, '{');
 964         if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
 965             || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
 966           is_struct_init = TRUE;
 967         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
 968           {
 969             if (field && is_struct_init)
 970               {
 971                 pp_character (buffer, '.');
 972                 dump_generic_node (buffer, field, spc, flags, false);
 973                 pp_string (buffer, "=");
 974               }
 975             if (val && TREE_CODE (val) == ADDR_EXPR)
 976               if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
 977                 val = TREE_OPERAND (val, 0);
 978             if (val && TREE_CODE (val) == FUNCTION_DECL)
 979                 dump_decl_name (buffer, val, flags);
 980             else
 981                 dump_generic_node (buffer, val, spc, flags, false);
 982             if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
 983               {
 984                 pp_character (buffer, ',');
 985                 pp_space (buffer);
 986               }
 987           }
 988         pp_character (buffer, '}');
 989       }
 990       break;
 991
 992     case COMPOUND_EXPR:
 993       {
 994         tree *tp;
 995         if (flags & TDF_SLIM)
 996           {
 997             pp_string (buffer, "<COMPOUND_EXPR>");
 998             break;
 999           }
1000
1001         dump_generic_node (buffer, TREE_OPERAND (node, 0),
1002                            spc, flags, !(flags & TDF_SLIM));
1003         if (flags & TDF_SLIM)
1004           newline_and_indent (buffer, spc);
1005         else
1006           {
1007             pp_character (buffer, ',');
1008             pp_space (buffer);
1009           }
1010
1011         for (tp = &TREE_OPERAND (node, 1);
1012              TREE_CODE (*tp) == COMPOUND_EXPR;
1013              tp = &TREE_OPERAND (*tp, 1))
1014           {
1015             dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
1016                                spc, flags, !(flags & TDF_SLIM));
1017             if (flags & TDF_SLIM)
1018               newline_and_indent (buffer, spc);
1019             else
1020               {
1021                 pp_character (buffer, ',');
1022                 pp_space (buffer);
1023               }
1024           }
1025
1026         dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
1027       }
1028       break;
1029
1030     case STATEMENT_LIST:
1031       {
1032         tree_stmt_iterator si;
1033         bool first = true;
1034
1035         if (flags & TDF_SLIM)
1036           {
1037             pp_string (buffer, "<STATEMENT_LIST>");
1038             break;
1039           }
1040
1041         for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1042           {
1043             if (!first)
1044               newline_and_indent (buffer, spc);
1045             else
1046               first = false;
1047             dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1048           }
1049       }
1050       break;
1051
1052     case MODIFY_EXPR:
1053     case GIMPLE_MODIFY_STMT:
1054     case INIT_EXPR:
1055       dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags,
1056                          false);
1057       pp_space (buffer);
1058       pp_character (buffer, '=');
1059       pp_space (buffer);
1060       dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
1061                          false);
1062       break;
1063
1064     case TARGET_EXPR:
1065       pp_string (buffer, "TARGET_EXPR <");
1066       dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1067       pp_character (buffer, ',');
1068       pp_space (buffer);
1069       dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1070       pp_character (buffer, '>');
1071       break;
1072
1073     case DECL_EXPR:
1074       print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1075       is_stmt = false;
1076       break;
1077
1078     case COND_EXPR:
1079       if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1080         {
1081           pp_string (buffer, "if (");
1082           dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1083           pp_character (buffer, ')');
1084           /* The lowered cond_exprs should always be printed in full.  */
1085           if (COND_EXPR_THEN (node)
1086               && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1087                   || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1088               && COND_EXPR_ELSE (node)
1089               && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1090                   || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1091             {
1092               pp_space (buffer);
1093               dump_generic_node (buffer, COND_EXPR_THEN (node),
1094                                  0, flags, true);
1095               if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1096                 {
1097                   pp_string (buffer, " else ");
1098                   dump_generic_node (buffer, COND_EXPR_ELSE (node),
1099                                      0, flags, true);
1100                 }
1101             }
1102           else if (!(flags & TDF_SLIM))
1103             {
1104               /* Output COND_EXPR_THEN.  */
1105               if (COND_EXPR_THEN (node))
1106                 {
1107                   newline_and_indent (buffer, spc+2);
1108                   pp_character (buffer, '{');
1109                   newline_and_indent (buffer, spc+4);
1110                   dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1111                                      flags, true);
1112                   newline_and_indent (buffer, spc+2);
1113                   pp_character (buffer, '}');
1114                 }
1115
1116               /* Output COND_EXPR_ELSE.  */
1117               if (COND_EXPR_ELSE (node)
1118                   && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1119                 {
1120                   newline_and_indent (buffer, spc);
1121                   pp_string (buffer, "else");
1122                   newline_and_indent (buffer, spc+2);
1123                   pp_character (buffer, '{');
1124                   newline_and_indent (buffer, spc+4);
1125                   dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1126                                      flags, true);
1127                   newline_and_indent (buffer, spc+2);
1128                   pp_character (buffer, '}');
1129                 }
1130             }
1131           is_expr = false;
1132         }
1133       else
1134         {
1135           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1136           pp_space (buffer);
1137           pp_character (buffer, '?');
1138           pp_space (buffer);
1139           dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1140           pp_space (buffer);
1141           pp_character (buffer, ':');
1142           pp_space (buffer);
1143           dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1144         }
1145       break;
1146
1147     case BIND_EXPR:
1148       pp_character (buffer, '{');
1149       if (!(flags & TDF_SLIM))
1150         {
1151           if (BIND_EXPR_VARS (node))
1152             {
1153               pp_newline (buffer);
1154
1155               for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
1156                 {
1157                   print_declaration (buffer, op0, spc+2, flags);
1158                   pp_newline (buffer);
1159                 }
1160             }
1161
1162           newline_and_indent (buffer, spc+2);
1163           dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1164           newline_and_indent (buffer, spc);
1165           pp_character (buffer, '}');
1166         }
1167       is_expr = false;
1168       break;
1169
1170     case CALL_EXPR:
1171       print_call_name (buffer, node);
1172
1173       /* Print parameters.  */
1174       pp_space (buffer);
1175       pp_character (buffer, '(');
1176       {
1177         tree arg;
1178         call_expr_arg_iterator iter;
1179         FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
1180           {
1181             dump_generic_node (buffer, arg, spc, flags, false);
1182             if (more_call_expr_args_p (&iter))
1183               {
1184                 pp_character (buffer, ',');
1185                 pp_space (buffer);
1186               }
1187           }
1188       }
1189       pp_character (buffer, ')');
1190
1191       op1 = CALL_EXPR_STATIC_CHAIN (node);
1192       if (op1)
1193         {
1194           pp_string (buffer, " [static-chain: ");
1195           dump_generic_node (buffer, op1, spc, flags, false);
1196           pp_character (buffer, ']');
1197         }
1198
1199       if (CALL_EXPR_RETURN_SLOT_OPT (node))
1200         pp_string (buffer, " [return slot optimization]");
1201       if (CALL_EXPR_TAILCALL (node))
1202         pp_string (buffer, " [tail call]");
1203       break;
1204
1205     case WITH_CLEANUP_EXPR:
1206       NIY;
1207       break;
1208
1209     case CLEANUP_POINT_EXPR:
1210       pp_string (buffer, "<<cleanup_point ");
1211       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1212       pp_string (buffer, ">>");
1213       break;
1214
1215     case PLACEHOLDER_EXPR:
1216       pp_string (buffer, "<PLACEHOLDER_EXPR ");
1217       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1218       pp_character (buffer, '>');
1219       break;
1220
1221       /* Binary arithmetic and logic expressions.  */
1222     case WIDEN_SUM_EXPR:
1223     case WIDEN_MULT_EXPR:
1224     case MULT_EXPR:
1225     case PLUS_EXPR:
1226     case MINUS_EXPR:
1227     case TRUNC_DIV_EXPR:
1228     case CEIL_DIV_EXPR:
1229     case FLOOR_DIV_EXPR:
1230     case ROUND_DIV_EXPR:
1231     case TRUNC_MOD_EXPR:
1232     case CEIL_MOD_EXPR:
1233     case FLOOR_MOD_EXPR:
1234     case ROUND_MOD_EXPR:
1235     case RDIV_EXPR:
1236     case EXACT_DIV_EXPR:
1237     case LSHIFT_EXPR:
1238     case RSHIFT_EXPR:
1239     case LROTATE_EXPR:
1240     case RROTATE_EXPR:
1241     case VEC_LSHIFT_EXPR:
1242     case VEC_RSHIFT_EXPR:
1243     case BIT_IOR_EXPR:
1244     case BIT_XOR_EXPR:
1245     case BIT_AND_EXPR:
1246     case TRUTH_ANDIF_EXPR:
1247     case TRUTH_ORIF_EXPR:
1248     case TRUTH_AND_EXPR:
1249     case TRUTH_OR_EXPR:
1250     case TRUTH_XOR_EXPR:
1251     case LT_EXPR:
1252     case LE_EXPR:
1253     case GT_EXPR:
1254     case GE_EXPR:
1255     case EQ_EXPR:
1256     case NE_EXPR:
1257     case UNLT_EXPR:
1258     case UNLE_EXPR:
1259     case UNGT_EXPR:
1260     case UNGE_EXPR:
1261     case UNEQ_EXPR:
1262     case LTGT_EXPR:
1263     case ORDERED_EXPR:
1264     case UNORDERED_EXPR:
1265       {
1266         const char *op = op_symbol (node);
1267         op0 = TREE_OPERAND (node, 0);
1268         op1 = TREE_OPERAND (node, 1);
1269
1270         /* When the operands are expressions with less priority,
1271            keep semantics of the tree representation.  */
1272         if (op_prio (op0) <= op_prio (node))
1273           {
1274             pp_character (buffer, '(');
1275             dump_generic_node (buffer, op0, spc, flags, false);
1276             pp_character (buffer, ')');
1277           }
1278         else
1279           dump_generic_node (buffer, op0, spc, flags, false);
1280
1281         pp_space (buffer);
1282         pp_string (buffer, op);
1283         pp_space (buffer);
1284
1285         /* When the operands are expressions with less priority,
1286            keep semantics of the tree representation.  */
1287         if (op_prio (op1) <= op_prio (node))
1288           {
1289             pp_character (buffer, '(');
1290             dump_generic_node (buffer, op1, spc, flags, false);
1291             pp_character (buffer, ')');
1292           }
1293         else
1294           dump_generic_node (buffer, op1, spc, flags, false);
1295       }
1296       break;
1297
1298       /* Unary arithmetic and logic expressions.  */
1299     case NEGATE_EXPR:
1300     case BIT_NOT_EXPR:
1301     case TRUTH_NOT_EXPR:
1302     case ADDR_EXPR:
1303     case PREDECREMENT_EXPR:
1304     case PREINCREMENT_EXPR:
1305     case ALIGN_INDIRECT_REF:
1306     case MISALIGNED_INDIRECT_REF:
1307     case INDIRECT_REF:
1308       if (TREE_CODE (node) == ADDR_EXPR
1309           && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1310               || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1311         ;       /* Do not output '&' for strings and function pointers.  */
1312       else
1313         pp_string (buffer, op_symbol (node));
1314
1315       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1316         {
1317           pp_character (buffer, '(');
1318           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1319           pp_character (buffer, ')');
1320         }
1321       else
1322         dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1323
1324       if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1325         {
1326           pp_string (buffer, "{misalignment: ");
1327           dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1328           pp_character (buffer, '}');
1329         }
1330       break;
1331
1332     case POSTDECREMENT_EXPR:
1333     case POSTINCREMENT_EXPR:
1334       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1335         {
1336           pp_character (buffer, '(');
1337           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1338           pp_character (buffer, ')');
1339         }
1340       else
1341         dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1342       pp_string (buffer, op_symbol (node));
1343       break;
1344
1345     case MIN_EXPR:
1346       pp_string (buffer, "MIN_EXPR <");
1347       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1348       pp_string (buffer, ", ");
1349       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1350       pp_character (buffer, '>');
1351       break;
1352
1353     case MAX_EXPR:
1354       pp_string (buffer, "MAX_EXPR <");
1355       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1356       pp_string (buffer, ", ");
1357       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1358       pp_character (buffer, '>');
1359       break;
1360
1361     case ABS_EXPR:
1362       pp_string (buffer, "ABS_EXPR <");
1363       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1364       pp_character (buffer, '>');
1365       break;
1366
1367     case RANGE_EXPR:
1368       NIY;
1369       break;
1370
1371     case FIX_TRUNC_EXPR:
1372     case FLOAT_EXPR:
1373     case CONVERT_EXPR:
1374     case NOP_EXPR:
1375       type = TREE_TYPE (node);
1376       op0 = TREE_OPERAND (node, 0);
1377       if (type != TREE_TYPE (op0))
1378         {
1379           pp_character (buffer, '(');
1380           dump_generic_node (buffer, type, spc, flags, false);
1381           pp_string (buffer, ") ");
1382         }
1383       if (op_prio (op0) < op_prio (node))
1384         pp_character (buffer, '(');
1385       dump_generic_node (buffer, op0, spc, flags, false);
1386       if (op_prio (op0) < op_prio (node))
1387         pp_character (buffer, ')');
1388       break;
1389
1390     case VIEW_CONVERT_EXPR:
1391       pp_string (buffer, "VIEW_CONVERT_EXPR<");
1392       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1393       pp_string (buffer, ">(");
1394       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1395       pp_character (buffer, ')');
1396       break;
1397
1398     case NON_LVALUE_EXPR:
1399       pp_string (buffer, "NON_LVALUE_EXPR <");
1400       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1401       pp_character (buffer, '>');
1402       break;
1403
1404     case SAVE_EXPR:
1405       pp_string (buffer, "SAVE_EXPR <");
1406       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1407       pp_character (buffer, '>');
1408       break;
1409
1410     case COMPLEX_EXPR:
1411       pp_string (buffer, "COMPLEX_EXPR <");
1412       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1413       pp_string (buffer, ", ");
1414       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1415       pp_string (buffer, ">");
1416       break;
1417
1418     case CONJ_EXPR:
1419       pp_string (buffer, "CONJ_EXPR <");
1420       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1421       pp_string (buffer, ">");
1422       break;
1423
1424     case REALPART_EXPR:
1425       pp_string (buffer, "REALPART_EXPR <");
1426       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1427       pp_string (buffer, ">");
1428       break;
1429
1430     case IMAGPART_EXPR:
1431       pp_string (buffer, "IMAGPART_EXPR <");
1432       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1433       pp_string (buffer, ">");
1434       break;
1435
1436     case VA_ARG_EXPR:
1437       pp_string (buffer, "VA_ARG_EXPR <");
1438       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1439       pp_string (buffer, ">");
1440       break;
1441
1442     case TRY_FINALLY_EXPR:
1443     case TRY_CATCH_EXPR:
1444       pp_string (buffer, "try");
1445       newline_and_indent (buffer, spc+2);
1446       pp_string (buffer, "{");
1447       newline_and_indent (buffer, spc+4);
1448       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1449       newline_and_indent (buffer, spc+2);
1450       pp_string (buffer, "}");
1451       newline_and_indent (buffer, spc);
1452       pp_string (buffer,
1453                          (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1454       newline_and_indent (buffer, spc+2);
1455       pp_string (buffer, "{");
1456       newline_and_indent (buffer, spc+4);
1457       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1458       newline_and_indent (buffer, spc+2);
1459       pp_string (buffer, "}");
1460       is_expr = false;
1461       break;
1462
1463     case CATCH_EXPR:
1464       pp_string (buffer, "catch (");
1465       dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1466       pp_string (buffer, ")");
1467       newline_and_indent (buffer, spc+2);
1468       pp_string (buffer, "{");
1469       newline_and_indent (buffer, spc+4);
1470       dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1471       newline_and_indent (buffer, spc+2);
1472       pp_string (buffer, "}");
1473       is_expr = false;
1474       break;
1475
1476     case EH_FILTER_EXPR:
1477       pp_string (buffer, "<<<eh_filter (");
1478       dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1479       pp_string (buffer, ")>>>");
1480       newline_and_indent (buffer, spc+2);
1481       pp_string (buffer, "{");
1482       newline_and_indent (buffer, spc+4);
1483       dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1484       newline_and_indent (buffer, spc+2);
1485       pp_string (buffer, "}");
1486       is_expr = false;
1487       break;
1488
1489     case LABEL_EXPR:
1490       op0 = TREE_OPERAND (node, 0);
1491       /* If this is for break or continue, don't bother printing it.  */
1492       if (DECL_NAME (op0))
1493         {
1494           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1495           if (strcmp (name, "break") == 0
1496               || strcmp (name, "continue") == 0)
1497             break;
1498         }
1499       dump_generic_node (buffer, op0, spc, flags, false);
1500       pp_character (buffer, ':');
1501       if (DECL_NONLOCAL (op0))
1502         pp_string (buffer, " [non-local]");
1503       break;
1504
1505     case EXC_PTR_EXPR:
1506       pp_string (buffer, "<<<exception object>>>");
1507       break;
1508
1509     case FILTER_EXPR:
1510       pp_string (buffer, "<<<filter object>>>");
1511       break;
1512
1513     case LOOP_EXPR:
1514       pp_string (buffer, "while (1)");
1515       if (!(flags & TDF_SLIM))
1516         {
1517           newline_and_indent (buffer, spc+2);
1518           pp_character (buffer, '{');
1519           newline_and_indent (buffer, spc+4);
1520           dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1521           newline_and_indent (buffer, spc+2);
1522           pp_character (buffer, '}');
1523         }
1524       is_expr = false;
1525       break;
1526
1527     case RETURN_EXPR:
1528       pp_string (buffer, "return");
1529       op0 = TREE_OPERAND (node, 0);
1530       if (op0)
1531         {
1532           pp_space (buffer);
1533           if (TREE_CODE (op0) == MODIFY_EXPR
1534               || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
1535             dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
1536                                spc, flags, false);
1537           else
1538             dump_generic_node (buffer, op0, spc, flags, false);
1539         }
1540       break;
1541
1542     case EXIT_EXPR:
1543       pp_string (buffer, "if (");
1544       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1545       pp_string (buffer, ") break");
1546       break;
1547
1548     case SWITCH_EXPR:
1549       pp_string (buffer, "switch (");
1550       dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1551       pp_character (buffer, ')');
1552       if (!(flags & TDF_SLIM))
1553         {
1554           newline_and_indent (buffer, spc+2);
1555           pp_character (buffer, '{');
1556           if (SWITCH_BODY (node))
1557             {
1558               newline_and_indent (buffer, spc+4);
1559               dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1560                                  true);
1561             }
1562           else
1563             {
1564               tree vec = SWITCH_LABELS (node);
1565               size_t i, n = TREE_VEC_LENGTH (vec);
1566               for (i = 0; i < n; ++i)
1567                 {
1568                   tree elt = TREE_VEC_ELT (vec, i);
1569                   newline_and_indent (buffer, spc+4);
1570                   if (elt)
1571                     {
1572                       dump_generic_node (buffer, elt, spc+4, flags, false);
1573                       pp_string (buffer, " goto ");
1574                       dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1575                                          flags, true);
1576                       pp_semicolon (buffer);
1577                     }
1578                   else
1579                     pp_string (buffer, "case ???: goto ???;");
1580                 }
1581             }
1582           newline_and_indent (buffer, spc+2);
1583           pp_character (buffer, '}');
1584         }
1585       is_expr = false;
1586       break;
1587
1588     case GOTO_EXPR:
1589       op0 = GOTO_DESTINATION (node);
1590       if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1591         {
1592           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1593           if (strcmp (name, "break") == 0
1594               || strcmp (name, "continue") == 0)
1595             {
1596               pp_string (buffer, name);
1597               break;
1598             }
1599         }
1600       pp_string (buffer, "goto ");
1601       dump_generic_node (buffer, op0, spc, flags, false);
1602       break;
1603
1604     case RESX_EXPR:
1605       pp_string (buffer, "resx ");
1606       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1607       break;
1608
1609     case ASM_EXPR:
1610       pp_string (buffer, "__asm__");
1611       if (ASM_VOLATILE_P (node))
1612         pp_string (buffer, " __volatile__");
1613       pp_character (buffer, '(');
1614       dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1615       pp_character (buffer, ':');
1616       dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1617       pp_character (buffer, ':');
1618       dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1619       if (ASM_CLOBBERS (node))
1620         {
1621           pp_character (buffer, ':');
1622           dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1623         }
1624       pp_string (buffer, ")");
1625       break;
1626
1627     case CASE_LABEL_EXPR:
1628       if (CASE_LOW (node) && CASE_HIGH (node))
1629         {
1630           pp_string (buffer, "case ");
1631           dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1632           pp_string (buffer, " ... ");
1633           dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1634         }
1635       else if (CASE_LOW (node))
1636         {
1637           pp_string (buffer, "case ");
1638           dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1639         }
1640       else
1641         pp_string (buffer, "default ");
1642       pp_character (buffer, ':');
1643       break;
1644
1645     case OBJ_TYPE_REF:
1646       pp_string (buffer, "OBJ_TYPE_REF(");
1647       dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1648       pp_character (buffer, ';');
1649       dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1650       pp_character (buffer, '-');
1651       pp_character (buffer, '>');
1652       dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1653       pp_character (buffer, ')');
1654       break;
1655
1656     case PHI_NODE:
1657       {
1658         int i;
1659
1660         dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1661         pp_string (buffer, " = PHI <");
1662         for (i = 0; i < PHI_NUM_ARGS (node); i++)
1663           {
1664             dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1665             pp_string (buffer, "(");
1666             pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1667             pp_string (buffer, ")");
1668             if (i < PHI_NUM_ARGS (node) - 1)
1669               pp_string (buffer, ", ");
1670           }
1671         pp_string (buffer, ">");
1672
1673         if (stmt_references_memory_p (node) && (flags & TDF_MEMSYMS))
1674           dump_symbols (buffer, STORED_SYMS (node), flags);
1675       }
1676       break;
1677
1678     case SSA_NAME:
1679       dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1680       pp_string (buffer, "_");
1681       pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1682       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1683         pp_string (buffer, "(ab)");
1684       else if (SSA_NAME_IS_DEFAULT_DEF (node))
1685         pp_string (buffer, "(D)");
1686       break;
1687
1688     case WITH_SIZE_EXPR:
1689       pp_string (buffer, "WITH_SIZE_EXPR <");
1690       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1691       pp_string (buffer, ", ");
1692       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1693       pp_string (buffer, ">");
1694       break;
1695
1696     case VALUE_HANDLE:
1697       pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1698       break;
1699
1700     case ASSERT_EXPR:
1701       pp_string (buffer, "ASSERT_EXPR <");
1702       dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1703       pp_string (buffer, ", ");
1704       dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1705       pp_string (buffer, ">");
1706       break;
1707
1708     case SCEV_KNOWN:
1709       pp_string (buffer, "scev_known");
1710       break;
1711
1712     case SCEV_NOT_KNOWN:
1713       pp_string (buffer, "scev_not_known");
1714       break;
1715
1716     case POLYNOMIAL_CHREC:
1717       pp_string (buffer, "{");
1718       dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1719       pp_string (buffer, ", +, ");
1720       dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1721       pp_string (buffer, "}_");
1722       dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1723       is_stmt = false;
1724       break;
1725
1726     case REALIGN_LOAD_EXPR:
1727       pp_string (buffer, "REALIGN_LOAD <");
1728       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1729       pp_string (buffer, ", ");
1730       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1731       pp_string (buffer, ", ");
1732       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1733       pp_string (buffer, ">");
1734       break;
1735
1736     case VEC_COND_EXPR:
1737       pp_string (buffer, " VEC_COND_EXPR < ");
1738       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1739       pp_string (buffer, " , ");
1740       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1741       pp_string (buffer, " , ");
1742       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1743       pp_string (buffer, " > ");
1744       break;
1745
1746     case DOT_PROD_EXPR:
1747       pp_string (buffer, " DOT_PROD_EXPR < ");
1748       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1749       pp_string (buffer, ", ");
1750       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1751       pp_string (buffer, ", ");
1752       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1753       pp_string (buffer, " > ");
1754       break;
1755
1756     case OMP_PARALLEL:
1757       pp_string (buffer, "#pragma omp parallel");
1758       dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1759       if (OMP_PARALLEL_FN (node))
1760         {
1761           pp_string (buffer, " [child fn: ");
1762           dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
1763
1764           pp_string (buffer, " (");
1765
1766           if (OMP_PARALLEL_DATA_ARG (node))
1767             dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
1768                                false);
1769           else
1770             pp_string (buffer, "???");
1771
1772           pp_string (buffer, ")]");
1773         }
1774
1775     dump_omp_body:
1776       if (!(flags & TDF_SLIM) && OMP_BODY (node))
1777         {
1778           newline_and_indent (buffer, spc + 2);
1779           pp_character (buffer, '{');
1780           newline_and_indent (buffer, spc + 4);
1781           dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1782           newline_and_indent (buffer, spc + 2);
1783           pp_character (buffer, '}');
1784         }
1785       is_expr = false;
1786       break;
1787
1788     case OMP_FOR:
1789       pp_string (buffer, "#pragma omp for");
1790       dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1791
1792       if (!(flags & TDF_SLIM))
1793         {
1794           if (OMP_FOR_PRE_BODY (node))
1795             {
1796               newline_and_indent (buffer, spc + 2);
1797               pp_character (buffer, '{');
1798               spc += 4;
1799               newline_and_indent (buffer, spc);
1800               dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1801                   spc, flags, false);
1802             }
1803           newline_and_indent (buffer, spc);
1804           pp_string (buffer, "for (");
1805           dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
1806           pp_string (buffer, "; ");
1807           dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
1808           pp_string (buffer, "; ");
1809           dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);
1810           pp_string (buffer, ")");
1811           if (OMP_FOR_BODY (node))
1812             {
1813               newline_and_indent (buffer, spc + 2);
1814               pp_character (buffer, '{');
1815               newline_and_indent (buffer, spc + 4);
1816               dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1817                   false);
1818               newline_and_indent (buffer, spc + 2);
1819               pp_character (buffer, '}');
1820             }
1821           if (OMP_FOR_PRE_BODY (node))
1822             {
1823               spc -= 4;
1824               newline_and_indent (buffer, spc + 2);
1825               pp_character (buffer, '}');
1826             }
1827         }
1828       is_expr = false;
1829       break;
1830
1831     case OMP_SECTIONS:
1832       pp_string (buffer, "#pragma omp sections");
1833       dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1834       goto dump_omp_body;
1835
1836     case OMP_SECTION:
1837       pp_string (buffer, "#pragma omp section");
1838       goto dump_omp_body;
1839
1840     case OMP_MASTER:
1841       pp_string (buffer, "#pragma omp master");
1842       goto dump_omp_body;
1843
1844     case OMP_ORDERED:
1845       pp_string (buffer, "#pragma omp ordered");
1846       goto dump_omp_body;
1847
1848     case OMP_CRITICAL:
1849       pp_string (buffer, "#pragma omp critical");
1850       if (OMP_CRITICAL_NAME (node))
1851         {
1852           pp_space (buffer);
1853           pp_character (buffer, '(');
1854           dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
1855                              flags, false);
1856           pp_character (buffer, ')');
1857         }
1858       goto dump_omp_body;
1859
1860     case OMP_ATOMIC:
1861       pp_string (buffer, "#pragma omp atomic");
1862       newline_and_indent (buffer, spc + 2);
1863       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1864       pp_space (buffer);
1865       pp_character (buffer, '=');
1866       pp_space (buffer);
1867       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1868       break;
1869
1870     case OMP_SINGLE:
1871       pp_string (buffer, "#pragma omp single");
1872       dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
1873       goto dump_omp_body;
1874
1875     case OMP_RETURN:
1876       pp_string (buffer, "OMP_RETURN");
1877       if (OMP_RETURN_NOWAIT (node))
1878         pp_string (buffer, " [nowait]");
1879       is_expr = false;
1880       break;
1881
1882     case OMP_CONTINUE:
1883       pp_string (buffer, "OMP_CONTINUE");
1884       is_expr = false;
1885       break;
1886
1887     case OMP_CLAUSE:
1888       dump_omp_clause (buffer, node, spc, flags);
1889       is_expr = false;
1890       break;
1891
1892     case REDUC_MAX_EXPR:
1893       pp_string (buffer, " REDUC_MAX_EXPR < ");
1894       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1895       pp_string (buffer, " > ");
1896       break;
1897
1898     case REDUC_MIN_EXPR:
1899       pp_string (buffer, " REDUC_MIN_EXPR < ");
1900       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1901       pp_string (buffer, " > ");
1902       break;
1903
1904     case REDUC_PLUS_EXPR:
1905       pp_string (buffer, " REDUC_PLUS_EXPR < ");
1906       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1907       pp_string (buffer, " > ");
1908       break;
1909
1910     case VEC_WIDEN_MULT_HI_EXPR:
1911       pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
1912       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1913       pp_string (buffer, ", ");
1914       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1915       pp_string (buffer, " > ");
1916       break;
1917
1918     case VEC_WIDEN_MULT_LO_EXPR:
1919       pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
1920       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1921       pp_string (buffer, ", ");
1922       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1923       pp_string (buffer, " > ");
1924       break;
1925
1926     case VEC_UNPACK_HI_EXPR:
1927       pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
1928       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1929       pp_string (buffer, " > ");
1930       break;
1931
1932     case VEC_UNPACK_LO_EXPR:
1933       pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
1934       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1935       pp_string (buffer, " > ");
1936       break;
1937
1938     case VEC_PACK_MOD_EXPR:
1939       pp_string (buffer, " VEC_PACK_MOD_EXPR < ");
1940       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1941       pp_string (buffer, ", ");
1942       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1943       pp_string (buffer, " > ");
1944       break;
1945
1946     case VEC_PACK_SAT_EXPR:
1947       pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
1948       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1949       pp_string (buffer, ", ");
1950       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1951       pp_string (buffer, " > ");
1952       break;
1953
1954     case BLOCK:
1955       {
1956         tree t;
1957         pp_string (buffer, "BLOCK");
1958
1959         if (BLOCK_ABSTRACT (node))
1960           pp_string (buffer, " [abstract]");
1961
1962         if (TREE_ASM_WRITTEN (node))
1963           pp_string (buffer, " [written]");
1964
1965         newline_and_indent (buffer, spc + 2);
1966
1967         if (BLOCK_SUPERCONTEXT (node))
1968           {
1969             pp_string (buffer, "SUPERCONTEXT: ");
1970             if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
1971               pp_printf (buffer, "BLOCK %p",
1972                          (void *)BLOCK_SUPERCONTEXT (node));
1973             else
1974               dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
1975                                  false);
1976             newline_and_indent (buffer, spc + 2);
1977           }
1978
1979         if (BLOCK_SUBBLOCKS (node))
1980           {
1981             pp_string (buffer, "SUBBLOCKS: ");
1982             for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
1983               pp_printf (buffer, "%p ", (void *)t);
1984             newline_and_indent (buffer, spc + 2);
1985           }
1986
1987         if (BLOCK_VARS (node))
1988           {
1989             pp_string (buffer, "VARS: ");
1990             for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
1991               {
1992                 dump_generic_node (buffer, t, 0, flags, false);
1993                 pp_string (buffer, " ");
1994               }
1995             newline_and_indent (buffer, spc + 2);
1996           }
1997
1998         if (BLOCK_ABSTRACT_ORIGIN (node))
1999           {
2000             pp_string (buffer, "ABSTRACT_ORIGIN: ");
2001             if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
2002               pp_printf (buffer, "BLOCK %p",
2003                          (void *)BLOCK_ABSTRACT_ORIGIN (node));
2004             else
2005               dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
2006                                  false);
2007             newline_and_indent (buffer, spc + 2);
2008           }
2009       }
2010     break;
2011
2012     case VEC_EXTRACT_EVEN_EXPR:
2013       pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
2014       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2015       pp_string (buffer, ", ");
2016       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2017       pp_string (buffer, " > ");
2018       break;
2019
2020     case VEC_EXTRACT_ODD_EXPR:
2021       pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
2022       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2023       pp_string (buffer, ", ");
2024       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2025       pp_string (buffer, " > ");
2026       break;
2027
2028     case VEC_INTERLEAVE_HIGH_EXPR:
2029       pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
2030       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2031       pp_string (buffer, ", ");
2032       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2033       pp_string (buffer, " > ");
2034       break;
2035
2036     case VEC_INTERLEAVE_LOW_EXPR:
2037       pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
2038       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
2039       pp_string (buffer, ", ");
2040       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
2041       pp_string (buffer, " > ");
2042       break;
2043
2044     default:
2045       NIY;
2046     }
2047
2048   if (is_stmt && is_expr)
2049     pp_semicolon (buffer);
2050   pp_write_text_to_stream (buffer);
2051
2052   return spc;
2053 }
2054
2055 /* Print the declaration of a variable.  */
2056
2057 static void
2058 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2059 {
2060   INDENT (spc);
2061
2062   if (TREE_CODE (t) == TYPE_DECL)
2063     pp_string (buffer, "typedef ");
2064
2065   if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2066     pp_string (buffer, "register ");
2067
2068   if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2069     pp_string (buffer, "extern ");
2070   else if (TREE_STATIC (t))
2071     pp_string (buffer, "static ");
2072
2073   /* Print the type and name.  */
2074   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2075     {
2076       tree tmp;
2077
2078       /* Print array's type.  */
2079       tmp = TREE_TYPE (t);
2080       while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2081         tmp = TREE_TYPE (tmp);
2082       dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2083
2084       /* Print variable's name.  */
2085       pp_space (buffer);
2086       dump_generic_node (buffer, t, spc, flags, false);
2087
2088       /* Print the dimensions.  */
2089       tmp = TREE_TYPE (t);
2090       while (TREE_CODE (tmp) == ARRAY_TYPE)
2091         {
2092           dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2093           tmp = TREE_TYPE (tmp);
2094         }
2095     }
2096   else if (TREE_CODE (t) == FUNCTION_DECL)
2097     {
2098       dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2099       pp_space (buffer);
2100       dump_decl_name (buffer, t, flags);
2101       dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2102     }
2103   else
2104     {
2105       /* Print type declaration.  */
2106       dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2107
2108       /* Print variable's name.  */
2109       pp_space (buffer);
2110       dump_generic_node (buffer, t, spc, flags, false);
2111     }
2112
2113   if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2114     {
2115       pp_string (buffer, " __asm__ ");
2116       pp_character (buffer, '(');
2117       dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2118       pp_character (buffer, ')');
2119     }
2120
2121   /* The initial value of a function serves to determine wether the function
2122      is declared or defined.  So the following does not apply to function
2123      nodes.  */
2124   if (TREE_CODE (t) != FUNCTION_DECL)
2125     {
2126       /* Print the initial value.  */
2127       if (DECL_INITIAL (t))
2128         {
2129           pp_space (buffer);
2130           pp_character (buffer, '=');
2131           pp_space (buffer);
2132           dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2133         }
2134     }
2135
2136   if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2137     {
2138       pp_string (buffer, " [value-expr: ");
2139       dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2140       pp_character (buffer, ']');
2141     }
2142
2143   pp_character (buffer, ';');
2144 }
2145
2146
2147 /* Prints a structure: name, fields, and methods.
2148    FIXME: Still incomplete.  */
2149
2150 static void
2151 print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
2152 {
2153   /* Print the name of the structure.  */
2154   if (TYPE_NAME (node))
2155     {
2156       INDENT (spc);
2157       if (TREE_CODE (node) == RECORD_TYPE)
2158         pp_string (buffer, "struct ");
2159       else if ((TREE_CODE (node) == UNION_TYPE
2160                 || TREE_CODE (node) == QUAL_UNION_TYPE))
2161         pp_string (buffer, "union ");
2162
2163       dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2164     }
2165
2166   /* Print the contents of the structure.  */
2167   pp_newline (buffer);
2168   INDENT (spc);
2169   pp_character (buffer, '{');
2170   pp_newline (buffer);
2171
2172   /* Print the fields of the structure.  */
2173   {
2174     tree tmp;
2175     tmp = TYPE_FIELDS (node);
2176     while (tmp)
2177       {
2178         /* Avoid to print recursively the structure.  */
2179         /* FIXME : Not implemented correctly...,
2180            what about the case when we have a cycle in the contain graph? ...
2181            Maybe this could be solved by looking at the scope in which the
2182            structure was declared.  */
2183         if (TREE_TYPE (tmp) != node
2184             || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
2185                 && TREE_TYPE (TREE_TYPE (tmp)) != node))
2186           {
2187             print_declaration (buffer, tmp, spc+2, flags);
2188             pp_newline (buffer);
2189           }
2190         tmp = TREE_CHAIN (tmp);
2191       }
2192   }
2193   INDENT (spc);
2194   pp_character (buffer, '}');
2195 }
2196
2197 /* Return the priority of the operator OP.
2198
2199    From lowest to highest precedence with either left-to-right (L-R)
2200    or right-to-left (R-L) associativity]:
2201
2202      1  [L-R] ,
2203      2  [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2204      3  [R-L] ?:
2205      4  [L-R] ||
2206      5  [L-R] &&
2207      6  [L-R] |
2208      7  [L-R] ^
2209      8  [L-R] &
2210      9  [L-R] == !=
2211     10  [L-R] < <= > >=
2212     11  [L-R] << >>
2213     12  [L-R] + -
2214     13  [L-R] * / %
2215     14  [R-L] ! ~ ++ -- + - * & (type) sizeof
2216     15  [L-R] fn() [] -> .
2217
2218    unary +, - and * have higher precedence than the corresponding binary
2219    operators.  */
2220
2221 static int
2222 op_prio (tree op)
2223 {
2224   if (op == NULL)
2225     return 9999;
2226
2227   switch (TREE_CODE (op))
2228     {
2229     case TREE_LIST:
2230     case COMPOUND_EXPR:
2231     case BIND_EXPR:
2232       return 1;
2233
2234     case MODIFY_EXPR:
2235     case GIMPLE_MODIFY_STMT:
2236     case INIT_EXPR:
2237       return 2;
2238
2239     case COND_EXPR:
2240       return 3;
2241
2242     case TRUTH_OR_EXPR:
2243     case TRUTH_ORIF_EXPR:
2244       return 4;
2245
2246     case TRUTH_AND_EXPR:
2247     case TRUTH_ANDIF_EXPR:
2248       return 5;
2249
2250     case BIT_IOR_EXPR:
2251       return 6;
2252
2253     case BIT_XOR_EXPR:
2254     case TRUTH_XOR_EXPR:
2255       return 7;
2256
2257     case BIT_AND_EXPR:
2258       return 8;
2259
2260     case EQ_EXPR:
2261     case NE_EXPR:
2262       return 9;
2263
2264     case UNLT_EXPR:
2265     case UNLE_EXPR:
2266     case UNGT_EXPR:
2267     case UNGE_EXPR:
2268     case UNEQ_EXPR:
2269     case LTGT_EXPR:
2270     case ORDERED_EXPR:
2271     case UNORDERED_EXPR:
2272     case LT_EXPR:
2273     case LE_EXPR:
2274     case GT_EXPR:
2275     case GE_EXPR:
2276       return 10;
2277
2278     case LSHIFT_EXPR:
2279     case RSHIFT_EXPR:
2280     case LROTATE_EXPR:
2281     case RROTATE_EXPR:
2282       return 11;
2283
2284     case WIDEN_SUM_EXPR:
2285     case PLUS_EXPR:
2286     case MINUS_EXPR:
2287       return 12;
2288
2289     case VEC_WIDEN_MULT_HI_EXPR:
2290     case VEC_WIDEN_MULT_LO_EXPR:
2291     case WIDEN_MULT_EXPR:
2292     case DOT_PROD_EXPR:
2293     case MULT_EXPR:
2294     case TRUNC_DIV_EXPR:
2295     case CEIL_DIV_EXPR:
2296     case FLOOR_DIV_EXPR:
2297     case ROUND_DIV_EXPR:
2298     case RDIV_EXPR:
2299     case EXACT_DIV_EXPR:
2300     case TRUNC_MOD_EXPR:
2301     case CEIL_MOD_EXPR:
2302     case FLOOR_MOD_EXPR:
2303     case ROUND_MOD_EXPR:
2304       return 13;
2305
2306     case TRUTH_NOT_EXPR:
2307     case BIT_NOT_EXPR:
2308     case POSTINCREMENT_EXPR:
2309     case POSTDECREMENT_EXPR:
2310     case PREINCREMENT_EXPR:
2311     case PREDECREMENT_EXPR:
2312     case NEGATE_EXPR:
2313     case ALIGN_INDIRECT_REF:
2314     case MISALIGNED_INDIRECT_REF:
2315     case INDIRECT_REF:
2316     case ADDR_EXPR:
2317     case FLOAT_EXPR:
2318     case NOP_EXPR:
2319     case CONVERT_EXPR:
2320     case FIX_TRUNC_EXPR:
2321     case TARGET_EXPR:
2322       return 14;
2323
2324     case CALL_EXPR:
2325     case ARRAY_REF:
2326     case ARRAY_RANGE_REF:
2327     case COMPONENT_REF:
2328       return 15;
2329
2330       /* Special expressions.  */
2331     case MIN_EXPR:
2332     case MAX_EXPR:
2333     case ABS_EXPR:
2334     case REALPART_EXPR:
2335     case IMAGPART_EXPR:
2336     case REDUC_MAX_EXPR:
2337     case REDUC_MIN_EXPR:
2338     case REDUC_PLUS_EXPR:
2339     case VEC_LSHIFT_EXPR:
2340     case VEC_RSHIFT_EXPR:
2341     case VEC_UNPACK_HI_EXPR:
2342     case VEC_UNPACK_LO_EXPR:
2343     case VEC_PACK_MOD_EXPR:
2344     case VEC_PACK_SAT_EXPR:
2345       return 16;
2346
2347     case SAVE_EXPR:
2348     case NON_LVALUE_EXPR:
2349       return op_prio (TREE_OPERAND (op, 0));
2350
2351     default:
2352       /* Return an arbitrarily high precedence to avoid surrounding single
2353          VAR_DECLs in ()s.  */
2354       return 9999;
2355     }
2356 }
2357
2358
2359 /* Return the symbol associated with operator OP.  */
2360
2361 static const char *
2362 op_symbol_1 (enum tree_code code)
2363 {
2364   switch (code)
2365     {
2366     case MODIFY_EXPR:
2367     case GIMPLE_MODIFY_STMT:
2368       return "=";
2369
2370     case TRUTH_OR_EXPR:
2371     case TRUTH_ORIF_EXPR:
2372       return "||";
2373
2374     case TRUTH_AND_EXPR:
2375     case TRUTH_ANDIF_EXPR:
2376       return "&&";
2377
2378     case BIT_IOR_EXPR:
2379       return "|";
2380
2381     case TRUTH_XOR_EXPR:
2382     case BIT_XOR_EXPR:
2383       return "^";
2384
2385     case ADDR_EXPR:
2386     case BIT_AND_EXPR:
2387       return "&";
2388
2389     case ORDERED_EXPR:
2390       return "ord";
2391     case UNORDERED_EXPR:
2392       return "unord";
2393
2394     case EQ_EXPR:
2395       return "==";
2396     case UNEQ_EXPR:
2397       return "u==";
2398
2399     case NE_EXPR:
2400       return "!=";
2401
2402     case LT_EXPR:
2403       return "<";
2404     case UNLT_EXPR:
2405       return "u<";
2406
2407     case LE_EXPR:
2408       return "<=";
2409     case UNLE_EXPR:
2410       return "u<=";
2411
2412     case GT_EXPR:
2413       return ">";
2414     case UNGT_EXPR:
2415       return "u>";
2416
2417     case GE_EXPR:
2418       return ">=";
2419     case UNGE_EXPR:
2420       return "u>=";
2421
2422     case LTGT_EXPR:
2423       return "<>";
2424
2425     case LSHIFT_EXPR:
2426       return "<<";
2427
2428     case RSHIFT_EXPR:
2429       return ">>";
2430
2431     case LROTATE_EXPR:
2432       return "r<<";
2433
2434     case RROTATE_EXPR:
2435       return "r>>";
2436
2437     case VEC_LSHIFT_EXPR:
2438       return "v<<";
2439
2440     case VEC_RSHIFT_EXPR:
2441       return "v>>";
2442
2443     case PLUS_EXPR:
2444       return "+";
2445
2446     case REDUC_PLUS_EXPR:
2447       return "r+";
2448
2449     case WIDEN_SUM_EXPR:
2450       return "w+";
2451
2452     case WIDEN_MULT_EXPR:
2453       return "w*";
2454
2455     case NEGATE_EXPR:
2456     case MINUS_EXPR:
2457       return "-";
2458
2459     case BIT_NOT_EXPR:
2460       return "~";
2461
2462     case TRUTH_NOT_EXPR:
2463       return "!";
2464
2465     case MULT_EXPR:
2466     case INDIRECT_REF:
2467       return "*";
2468
2469     case ALIGN_INDIRECT_REF:
2470       return "A*";
2471
2472     case MISALIGNED_INDIRECT_REF:
2473       return "M*";
2474
2475     case TRUNC_DIV_EXPR:
2476     case RDIV_EXPR:
2477       return "/";
2478
2479     case CEIL_DIV_EXPR:
2480       return "/[cl]";
2481
2482     case FLOOR_DIV_EXPR:
2483       return "/[fl]";
2484
2485     case ROUND_DIV_EXPR:
2486       return "/[rd]";
2487
2488     case EXACT_DIV_EXPR:
2489       return "/[ex]";
2490
2491     case TRUNC_MOD_EXPR:
2492       return "%";
2493
2494     case CEIL_MOD_EXPR:
2495       return "%[cl]";
2496
2497     case FLOOR_MOD_EXPR:
2498       return "%[fl]";
2499
2500     case ROUND_MOD_EXPR:
2501       return "%[rd]";
2502
2503     case PREDECREMENT_EXPR:
2504       return " --";
2505
2506     case PREINCREMENT_EXPR:
2507       return " ++";
2508
2509     case POSTDECREMENT_EXPR:
2510       return "-- ";
2511
2512     case POSTINCREMENT_EXPR:
2513       return "++ ";
2514
2515     case MAX_EXPR:
2516       return "max";
2517
2518     case MIN_EXPR:
2519       return "min";
2520
2521     default:
2522       return "<<< ??? >>>";
2523     }
2524 }
2525
2526 static const char *
2527 op_symbol (tree op)
2528 {
2529   return op_symbol_1 (TREE_CODE (op));
2530 }
2531
2532 /* Prints the name of a CALL_EXPR.  */
2533
2534 static void
2535 print_call_name (pretty_printer *buffer, tree node)
2536 {
2537   tree op0;
2538
2539   gcc_assert (TREE_CODE (node) == CALL_EXPR);
2540
2541   op0 = CALL_EXPR_FN (node);
2542
2543   if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2544     op0 = TREE_OPERAND (op0, 0);
2545
2546   switch (TREE_CODE (op0))
2547     {
2548     case VAR_DECL:
2549     case PARM_DECL:
2550       dump_function_name (buffer, op0);
2551       break;
2552
2553     case ADDR_EXPR:
2554     case INDIRECT_REF:
2555     case NOP_EXPR:
2556       dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2557       break;
2558
2559     case COND_EXPR:
2560       pp_string (buffer, "(");
2561       dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2562       pp_string (buffer, ") ? ");
2563       dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
2564       pp_string (buffer, " : ");
2565       dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
2566       break;
2567
2568     case COMPONENT_REF:
2569       /* The function is a pointer contained in a structure.  */
2570       if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
2571           TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2572         dump_function_name (buffer, TREE_OPERAND (op0, 1));
2573       else
2574         dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2575       /* else
2576          We can have several levels of structures and a function
2577          pointer inside.  This is not implemented yet...  */
2578       /*                  NIY;*/
2579       break;
2580
2581     case ARRAY_REF:
2582       if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2583         dump_function_name (buffer, TREE_OPERAND (op0, 0));
2584       else
2585         dump_generic_node (buffer, op0, 0, 0, false);
2586       break;
2587
2588     case SSA_NAME:
2589     case OBJ_TYPE_REF:
2590       dump_generic_node (buffer, op0, 0, 0, false);
2591       break;
2592
2593     default:
2594       NIY;
2595     }
2596 }
2597
2598 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ...  */
2599
2600 static void
2601 pretty_print_string (pretty_printer *buffer, const char *str)
2602 {
2603   if (str == NULL)
2604     return;
2605
2606   while (*str)
2607     {
2608       switch (str[0])
2609         {
2610         case '\b':
2611           pp_string (buffer, "\\b");
2612           break;
2613
2614         case '\f':
2615           pp_string (buffer, "\\f");
2616           break;
2617
2618         case '\n':
2619           pp_string (buffer, "\\n");
2620           break;
2621
2622         case '\r':
2623           pp_string (buffer, "\\r");
2624           break;
2625
2626         case '\t':
2627           pp_string (buffer, "\\t");
2628           break;
2629
2630         case '\v':
2631           pp_string (buffer, "\\v");
2632           break;
2633
2634         case '\\':
2635           pp_string (buffer, "\\\\");
2636           break;
2637
2638         case '\"':
2639           pp_string (buffer, "\\\"");
2640           break;
2641
2642         case '\'':
2643           pp_string (buffer, "\\'");
2644           break;
2645
2646           /* No need to handle \0; the loop terminates on \0.  */
2647
2648         case '\1':
2649           pp_string (buffer, "\\1");
2650           break;
2651
2652         case '\2':
2653           pp_string (buffer, "\\2");
2654           break;
2655
2656         case '\3':
2657           pp_string (buffer, "\\3");
2658           break;
2659
2660         case '\4':
2661           pp_string (buffer, "\\4");
2662           break;
2663
2664         case '\5':
2665           pp_string (buffer, "\\5");
2666           break;
2667
2668         case '\6':
2669           pp_string (buffer, "\\6");
2670           break;
2671
2672         case '\7':
2673           pp_string (buffer, "\\7");
2674           break;
2675
2676         default:
2677           pp_character (buffer, str[0]);
2678           break;
2679         }
2680       str++;
2681     }
2682 }
2683
2684 static void
2685 maybe_init_pretty_print (FILE *file)
2686 {
2687   if (!initialized)
2688     {
2689       pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2690       pp_needs_newline (&buffer) = true;
2691       initialized = 1;
2692     }
2693
2694   buffer.buffer->stream = file;
2695 }
2696
2697 static void
2698 newline_and_indent (pretty_printer *buffer, int spc)
2699 {
2700   pp_newline (buffer);
2701   INDENT (spc);
2702 }
2703
2704
2705 static void
2706 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2707 {
2708   struct voptype_d *vdefs;
2709   struct voptype_d *vuses;
2710   int i, n;
2711
2712   if (!ssa_operands_active () || !stmt_references_memory_p (stmt))
2713     return;
2714
2715   /* Even if the statement doesn't have virtual operators yet, it may
2716      contain symbol information (this happens before aliases have been
2717      computed).  */
2718   if ((flags & TDF_MEMSYMS)
2719       && VUSE_OPS (stmt) == NULL
2720       && VDEF_OPS (stmt) == NULL)
2721     {
2722       if (LOADED_SYMS (stmt))
2723         {
2724           pp_string (buffer, "# LOADS: ");
2725           dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2726           newline_and_indent (buffer, spc);
2727         }
2728
2729       if (STORED_SYMS (stmt))
2730         {
2731           pp_string (buffer, "# STORES: ");
2732           dump_symbols (buffer, STORED_SYMS (stmt), flags);
2733           newline_and_indent (buffer, spc);
2734         }
2735
2736       return;
2737     }
2738
2739   vuses = VUSE_OPS (stmt);
2740   while (vuses)
2741     {
2742       pp_string (buffer, "# VUSE <");
2743
2744       n = VUSE_NUM (vuses);
2745       for (i = 0; i < n; i++)
2746         {
2747           dump_generic_node (buffer, VUSE_OP (vuses, i), spc + 2, flags, false);
2748           if (i < n - 1)
2749             pp_string (buffer, ", ");
2750         }
2751
2752       pp_string (buffer, ">");
2753
2754       if (flags & TDF_MEMSYMS)
2755         dump_symbols (buffer, LOADED_SYMS (stmt), flags);
2756
2757       newline_and_indent (buffer, spc);
2758       vuses = vuses->next;
2759     }
2760
2761   vdefs = VDEF_OPS (stmt);
2762   while (vdefs)
2763     {
2764       pp_string (buffer, "# ");
2765       dump_generic_node (buffer, VDEF_RESULT (vdefs), spc + 2, flags, false);
2766       pp_string (buffer, " = VDEF <");
2767
2768       n = VDEF_NUM (vdefs);
2769       for (i = 0; i < n; i++)
2770         {
2771           dump_generic_node (buffer, VDEF_OP (vdefs, i), spc + 2, flags, 0);
2772           if (i < n - 1)
2773             pp_string (buffer, ", ");
2774         }
2775
2776       pp_string (buffer, ">");
2777
2778       if ((flags & TDF_MEMSYMS) && vdefs->next == NULL)
2779         dump_symbols (buffer, STORED_SYMS (stmt), flags);
2780
2781       newline_and_indent (buffer, spc);
2782       vdefs = vdefs->next;
2783     }
2784 }
2785
2786
2787 /* Dumps basic block BB to FILE with details described by FLAGS and
2788    indented by INDENT spaces.  */
2789
2790 void
2791 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2792 {
2793   maybe_init_pretty_print (file);
2794   dump_generic_bb_buff (&buffer, bb, indent, flags);
2795   pp_flush (&buffer);
2796 }
2797
2798 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2799    spaces and details described by flags.  */
2800
2801 static void
2802 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2803 {
2804   edge e;
2805   tree stmt;
2806   edge_iterator ei;
2807
2808   if (flags & TDF_BLOCKS)
2809     {
2810       INDENT (indent);
2811       pp_string (buffer, "# BLOCK ");
2812       pp_decimal_int (buffer, bb->index);
2813       if (bb->frequency)
2814         {
2815           pp_string (buffer, " freq:");
2816           pp_decimal_int (buffer, bb->frequency);
2817         }
2818       if (bb->count)
2819         {
2820           pp_string (buffer, " count:");
2821           pp_widest_integer (buffer, bb->count);
2822         }
2823
2824       if (flags & TDF_LINENO)
2825         {
2826           block_stmt_iterator bsi;
2827
2828           for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2829             if (get_lineno (bsi_stmt (bsi)) != -1)
2830               {
2831                 pp_string (buffer, ", starting at line ");
2832                 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2833                 break;
2834               }
2835         }
2836       newline_and_indent (buffer, indent);
2837
2838       pp_string (buffer, "# PRED:");
2839       pp_write_text_to_stream (buffer);
2840       FOR_EACH_EDGE (e, ei, bb->preds)
2841         if (flags & TDF_SLIM)
2842           {
2843             pp_string (buffer, " ");
2844             if (e->src == ENTRY_BLOCK_PTR)
2845               pp_string (buffer, "ENTRY");
2846             else
2847               pp_decimal_int (buffer, e->src->index);
2848           }
2849         else
2850           dump_edge_info (buffer->buffer->stream, e, 0);
2851       pp_newline (buffer);
2852     }
2853   else
2854     {
2855       stmt = first_stmt (bb);
2856       if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
2857         {
2858           INDENT (indent - 2);
2859           pp_string (buffer, "<bb ");
2860           pp_decimal_int (buffer, bb->index);
2861           pp_string (buffer, ">:");
2862           pp_newline (buffer);
2863         }
2864     }
2865   pp_write_text_to_stream (buffer);
2866   check_bb_profile (bb, buffer->buffer->stream);
2867 }
2868
2869 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2870    spaces.  */
2871
2872 static void
2873 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
2874 {
2875   edge e;
2876   edge_iterator ei;
2877
2878   INDENT (indent);
2879   pp_string (buffer, "# SUCC:");
2880   pp_write_text_to_stream (buffer);
2881   FOR_EACH_EDGE (e, ei, bb->succs)
2882     if (flags & TDF_SLIM)
2883       {
2884         pp_string (buffer, " ");
2885         if (e->dest == EXIT_BLOCK_PTR)
2886           pp_string (buffer, "EXIT");
2887         else
2888           pp_decimal_int (buffer, e->dest->index);
2889       }
2890     else
2891       dump_edge_info (buffer->buffer->stream, e, 1);
2892   pp_newline (buffer);
2893 }
2894
2895 /* Dump PHI nodes of basic block BB to BUFFER with details described
2896    by FLAGS and indented by INDENT spaces.  */
2897
2898 static void
2899 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2900 {
2901   tree phi = phi_nodes (bb);
2902   if (!phi)
2903     return;
2904
2905   for (; phi; phi = PHI_CHAIN (phi))
2906     {
2907       if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
2908         {
2909           INDENT (indent);
2910           pp_string (buffer, "# ");
2911           dump_generic_node (buffer, phi, indent, flags, false);
2912           pp_newline (buffer);
2913         }
2914     }
2915 }
2916
2917
2918 /* Dump jump to basic block BB that is represented implicitly in the cfg
2919    to BUFFER.  */
2920
2921 static void
2922 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
2923 {
2924   tree stmt;
2925
2926   stmt = first_stmt (bb);
2927
2928   pp_string (buffer, "goto <bb ");
2929   pp_decimal_int (buffer, bb->index);
2930   pp_string (buffer, ">");
2931   if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
2932     {
2933       pp_string (buffer, " (");
2934       dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
2935       pp_string (buffer, ")");
2936     }
2937   pp_semicolon (buffer);
2938 }
2939
2940 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2941    by INDENT spaces, with details given by FLAGS.  */
2942
2943 static void
2944 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2945                      int flags)
2946 {
2947   edge e;
2948   edge_iterator ei;
2949
2950   /* If there is a fallthru edge, we may need to add an artificial goto to the
2951      dump.  */
2952   FOR_EACH_EDGE (e, ei, bb->succs)
2953     if (e->flags & EDGE_FALLTHRU)
2954       break;
2955   if (e && e->dest != bb->next_bb)
2956     {
2957       INDENT (indent);
2958
2959       if ((flags & TDF_LINENO)
2960 #ifdef USE_MAPPED_LOCATION
2961           && e->goto_locus != UNKNOWN_LOCATION
2962 #else
2963           && e->goto_locus
2964 #endif
2965           )
2966         {
2967           expanded_location goto_xloc;
2968 #ifdef USE_MAPPED_LOCATION
2969           goto_xloc = expand_location (e->goto_locus);
2970 #else
2971           goto_xloc = *e->goto_locus;
2972 #endif
2973           pp_character (buffer, '[');
2974           if (goto_xloc.file)
2975             {
2976               pp_string (buffer, goto_xloc.file);
2977               pp_string (buffer, " : ");
2978             }
2979           pp_decimal_int (buffer, goto_xloc.line);
2980           pp_string (buffer, "] ");
2981         }
2982
2983       pp_cfg_jump (buffer, e->dest);
2984       pp_newline (buffer);
2985     }
2986 }
2987
2988 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2989    indented by INDENT spaces.  */
2990
2991 static void
2992 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
2993                       int indent, int flags)
2994 {
2995   block_stmt_iterator bsi;
2996   tree stmt;
2997   int label_indent = indent - 2;
2998
2999   if (label_indent < 0)
3000     label_indent = 0;
3001
3002   dump_bb_header (buffer, bb, indent, flags);
3003
3004   dump_phi_nodes (buffer, bb, indent, flags);
3005
3006   for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
3007     {
3008       int curr_indent;
3009
3010       stmt = bsi_stmt (bsi);
3011
3012       curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
3013
3014       INDENT (curr_indent);
3015       dump_generic_node (buffer, stmt, curr_indent, flags, true);
3016       pp_newline (buffer);
3017       dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
3018     }
3019
3020   dump_implicit_edges (buffer, bb, indent, flags);
3021
3022   if (flags & TDF_BLOCKS)
3023     dump_bb_end (buffer, bb, indent, flags);
3024 }