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