gcc/tree-pretty-print.c

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