gcc/tree-pretty-print.c

   1 /* Pretty formatting of GENERIC trees in C syntax.
   2    Copyright (C) 2001-2015 Free Software Foundation, Inc.
   3    Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "hash-set.h"
  26 #include "machmode.h"
  27 #include "vec.h"
  28 #include "double-int.h"
  29 #include "input.h"
  30 #include "alias.h"
  31 #include "symtab.h"
  32 #include "wide-int.h"
  33 #include "inchash.h"
  34 #include "tree.h"
  35 #include "stor-layout.h"
  36 #include "expr.h"
  37 #include "tree-pretty-print.h"
  38 #include "gimple-expr.h"
  39 #include "predict.h"
  40 #include "hash-map.h"
  41 #include "is-a.h"
  42 #include "plugin-api.h"
  43 #include "hard-reg-set.h"
  44 #include "input.h"
  45 #include "function.h"
  46 #include "ipa-ref.h"
  47 #include "cgraph.h"
  48 #include "langhooks.h"
  49 #include "tree-iterator.h"
  50 #include "tree-chrec.h"
  51 #include "dumpfile.h"
  52 #include "value-prof.h"
  53 #include "wide-int-print.h"
  54 #include "internal-fn.h"
  55
  56 /* Local functions, macros and variables.  */
  57 static const char *op_symbol (const_tree);
  58 static void pretty_print_string (pretty_printer *, const char*);
  59 static void newline_and_indent (pretty_printer *, int);
  60 static void maybe_init_pretty_print (FILE *);
  61 static void print_struct_decl (pretty_printer *, const_tree, int, int);
  62 static void do_niy (pretty_printer *, const_tree);
  63
  64 #define INDENT(SPACE) do { \
  65   int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
  66
  67 #define NIY do_niy (pp, node)
  68
  69 static pretty_printer *tree_pp;
  70
  71 /* Try to print something for an unknown tree code.  */
  72
  73 static void
  74 do_niy (pretty_printer *pp, const_tree node)
  75 {
  76   int i, len;
  77
  78   pp_string (pp, "<<< Unknown tree: ");
  79   pp_string (pp, get_tree_code_name (TREE_CODE (node)));
  80
  81   if (EXPR_P (node))
  82     {
  83       len = TREE_OPERAND_LENGTH (node);
  84       for (i = 0; i < len; ++i)
  85         {
  86           newline_and_indent (pp, 2);
  87           dump_generic_node (pp, TREE_OPERAND (node, i), 2, 0, false);
  88         }
  89     }
  90
  91   pp_string (pp, " >>>");
  92 }
  93
  94 /* Debugging function to print out a generic expression.  */
  95
  96 DEBUG_FUNCTION void
  97 debug_generic_expr (tree t)
  98 {
  99   print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
 100   fprintf (stderr, "\n");
 101 }
 102
 103 /* Debugging function to print out a generic statement.  */
 104
 105 DEBUG_FUNCTION void
 106 debug_generic_stmt (tree t)
 107 {
 108   print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
 109   fprintf (stderr, "\n");
 110 }
 111
 112 /* Debugging function to print out a chain of trees .  */
 113
 114 DEBUG_FUNCTION void
 115 debug_tree_chain (tree t)
 116 {
 117   hash_set<tree> seen;
 118
 119   while (t)
 120     {
 121       print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
 122       fprintf (stderr, " ");
 123       t = TREE_CHAIN (t);
 124       if (seen.add (t))
 125         {
 126           fprintf (stderr, "... [cycled back to ");
 127           print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
 128           fprintf (stderr, "]");
 129           break;
 130         }
 131     }
 132   fprintf (stderr, "\n");
 133 }
 134
 135 /* Prints declaration DECL to the FILE with details specified by FLAGS.  */
 136 void
 137 print_generic_decl (FILE *file, tree decl, int flags)
 138 {
 139   maybe_init_pretty_print (file);
 140   print_declaration (tree_pp, decl, 2, flags);
 141   pp_write_text_to_stream (tree_pp);
 142 }
 143
 144 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
 145    to show in the dump.  See TDF_* in dumpfile.h.  */
 146
 147 void
 148 print_generic_stmt (FILE *file, tree t, int flags)
 149 {
 150   maybe_init_pretty_print (file);
 151   dump_generic_node (tree_pp, t, 0, flags, true);
 152   pp_newline_and_flush (tree_pp);
 153 }
 154
 155 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
 156    to show in the dump.  See TDF_* in dumpfile.h.  The output is indented by
 157    INDENT spaces.  */
 158
 159 void
 160 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
 161 {
 162   int i;
 163
 164   maybe_init_pretty_print (file);
 165
 166   for (i = 0; i < indent; i++)
 167     pp_space (tree_pp);
 168   dump_generic_node (tree_pp, t, indent, flags, true);
 169   pp_newline_and_flush (tree_pp);
 170 }
 171
 172 /* Print a single expression T on file FILE.  FLAGS specifies details to show
 173    in the dump.  See TDF_* in dumpfile.h.  */
 174
 175 void
 176 print_generic_expr (FILE *file, tree t, int flags)
 177 {
 178   maybe_init_pretty_print (file);
 179   dump_generic_node (tree_pp, t, 0, flags, false);
 180   pp_flush (tree_pp);
 181 }
 182
 183 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
 184    in FLAGS.  */
 185
 186 static void
 187 dump_decl_name (pretty_printer *pp, tree node, int flags)
 188 {
 189   if (DECL_NAME (node))
 190     {
 191       if ((flags & TDF_ASMNAME) && DECL_ASSEMBLER_NAME_SET_P (node))
 192         pp_tree_identifier (pp, DECL_ASSEMBLER_NAME (node));
 193       else
 194         pp_tree_identifier (pp, DECL_NAME (node));
 195     }
 196   if ((flags & TDF_UID) || DECL_NAME (node) == NULL_TREE)
 197     {
 198       if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)
 199         pp_printf (pp, "L.%d", (int) LABEL_DECL_UID (node));
 200       else if (TREE_CODE (node) == DEBUG_EXPR_DECL)
 201         {
 202           if (flags & TDF_NOUID)
 203             pp_string (pp, "D#xxxx");
 204           else
 205             pp_printf (pp, "D#%i", DEBUG_TEMP_UID (node));
 206         }
 207       else
 208         {
 209           char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
 210           if (flags & TDF_NOUID)
 211             pp_printf (pp, "%c.xxxx", c);
 212           else
 213             pp_printf (pp, "%c.%u", c, DECL_UID (node));
 214         }
 215     }
 216   if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node))
 217     {
 218       if (flags & TDF_NOUID)
 219         pp_printf (pp, "ptD.xxxx");
 220       else
 221         pp_printf (pp, "ptD.%u", DECL_PT_UID (node));
 222     }
 223 }
 224
 225 /* Like the above, but used for pretty printing function calls.  */
 226
 227 static void
 228 dump_function_name (pretty_printer *pp, tree node, int flags)
 229 {
 230   if (CONVERT_EXPR_P (node))
 231     node = TREE_OPERAND (node, 0);
 232   if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)
 233     pp_string (pp, lang_hooks.decl_printable_name (node, 1));
 234   else
 235     dump_decl_name (pp, node, flags);
 236 }
 237
 238 /* Dump a function declaration.  NODE is the FUNCTION_TYPE.  PP, SPC and
 239    FLAGS are as in dump_generic_node.  */
 240
 241 static void
 242 dump_function_declaration (pretty_printer *pp, tree node,
 243                            int spc, int flags)
 244 {
 245   bool wrote_arg = false;
 246   tree arg;
 247
 248   pp_space (pp);
 249   pp_left_paren (pp);
 250
 251   /* Print the argument types.  */
 252   arg = TYPE_ARG_TYPES (node);
 253   while (arg && arg != void_list_node && arg != error_mark_node)
 254     {
 255       if (wrote_arg)
 256         {
 257           pp_comma (pp);
 258           pp_space (pp);
 259         }
 260       wrote_arg = true;
 261       dump_generic_node (pp, TREE_VALUE (arg), spc, flags, false);
 262       arg = TREE_CHAIN (arg);
 263     }
 264
 265   /* Drop the trailing void_type_node if we had any previous argument.  */
 266   if (arg == void_list_node && !wrote_arg)
 267     pp_string (pp, "void");
 268   /* Properly dump vararg function types.  */
 269   else if (!arg && wrote_arg)
 270     pp_string (pp, ", ...");
 271   /* Avoid printing any arg for unprototyped functions.  */
 272
 273   pp_right_paren (pp);
 274 }
 275
 276 /* Dump the domain associated with an array.  */
 277
 278 static void
 279 dump_array_domain (pretty_printer *pp, tree domain, int spc, int flags)
 280 {
 281   pp_left_bracket (pp);
 282   if (domain)
 283     {
 284       tree min = TYPE_MIN_VALUE (domain);
 285       tree max = TYPE_MAX_VALUE (domain);
 286
 287       if (min && max
 288           && integer_zerop (min)
 289           && tree_fits_shwi_p (max))
 290         pp_wide_integer (pp, tree_to_shwi (max) + 1);
 291       else
 292         {
 293           if (min)
 294             dump_generic_node (pp, min, spc, flags, false);
 295           pp_colon (pp);
 296           if (max)
 297             dump_generic_node (pp, max, spc, flags, false);
 298         }
 299     }
 300   else
 301     pp_string (pp, "<unknown>");
 302   pp_right_bracket (pp);
 303 }
 304
 305
 306 /* Dump OpenMP clause CLAUSE.  PP, CLAUSE, SPC and FLAGS are as in
 307    dump_generic_node.  */
 308
 309 static void
 310 dump_omp_clause (pretty_printer *pp, tree clause, int spc, int flags)
 311 {
 312   const char *name;
 313
 314   switch (OMP_CLAUSE_CODE (clause))
 315     {
 316     case OMP_CLAUSE_PRIVATE:
 317       name = "private";
 318       goto print_remap;
 319     case OMP_CLAUSE_SHARED:
 320       name = "shared";
 321       goto print_remap;
 322     case OMP_CLAUSE_FIRSTPRIVATE:
 323       name = "firstprivate";
 324       goto print_remap;
 325     case OMP_CLAUSE_LASTPRIVATE:
 326       name = "lastprivate";
 327       goto print_remap;
 328     case OMP_CLAUSE_COPYIN:
 329       name = "copyin";
 330       goto print_remap;
 331     case OMP_CLAUSE_COPYPRIVATE:
 332       name = "copyprivate";
 333       goto print_remap;
 334     case OMP_CLAUSE_UNIFORM:
 335       name = "uniform";
 336       goto print_remap;
 337     case OMP_CLAUSE__LOOPTEMP_:
 338       name = "_looptemp_";
 339       goto print_remap;
 340     case OMP_CLAUSE_DEVICE_RESIDENT:
 341       name = "device_resident";
 342       goto print_remap;
 343     case OMP_CLAUSE_USE_DEVICE:
 344       name = "use_device";
 345       goto print_remap;
 346   print_remap:
 347       pp_string (pp, name);
 348       pp_left_paren (pp);
 349       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
 350                          spc, flags, false);
 351       pp_right_paren (pp);
 352       break;
 353
 354     case OMP_CLAUSE_REDUCTION:
 355       pp_string (pp, "reduction(");
 356       if (OMP_CLAUSE_REDUCTION_CODE (clause) != ERROR_MARK)
 357         {
 358           pp_string (pp,
 359                      op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
 360           pp_colon (pp);
 361         }
 362       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
 363                          spc, flags, false);
 364       pp_right_paren (pp);
 365       break;
 366
 367     case OMP_CLAUSE_IF:
 368       pp_string (pp, "if(");
 369       dump_generic_node (pp, OMP_CLAUSE_IF_EXPR (clause),
 370                          spc, flags, false);
 371       pp_right_paren (pp);
 372       break;
 373
 374     case OMP_CLAUSE_NUM_THREADS:
 375       pp_string (pp, "num_threads(");
 376       dump_generic_node (pp, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
 377                          spc, flags, false);
 378       pp_right_paren (pp);
 379       break;
 380
 381     case OMP_CLAUSE__CILK_FOR_COUNT_:
 382       pp_string (pp, "_Cilk_for_count_(");
 383       dump_generic_node (pp, OMP_CLAUSE_OPERAND (clause, 0),
 384                          spc, flags, false);
 385       pp_right_paren (pp);
 386       break;
 387
 388     case OMP_CLAUSE_NOWAIT:
 389       pp_string (pp, "nowait");
 390       break;
 391     case OMP_CLAUSE_ORDERED:
 392       pp_string (pp, "ordered");
 393       break;
 394
 395     case OMP_CLAUSE_DEFAULT:
 396       pp_string (pp, "default(");
 397       switch (OMP_CLAUSE_DEFAULT_KIND (clause))
 398         {
 399         case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
 400           break;
 401         case OMP_CLAUSE_DEFAULT_SHARED:
 402           pp_string (pp, "shared");
 403           break;
 404         case OMP_CLAUSE_DEFAULT_NONE:
 405           pp_string (pp, "none");
 406           break;
 407         case OMP_CLAUSE_DEFAULT_PRIVATE:
 408           pp_string (pp, "private");
 409           break;
 410         case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
 411           pp_string (pp, "firstprivate");
 412           break;
 413         default:
 414           gcc_unreachable ();
 415         }
 416       pp_right_paren (pp);
 417       break;
 418
 419     case OMP_CLAUSE_SCHEDULE:
 420       pp_string (pp, "schedule(");
 421       switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
 422         {
 423         case OMP_CLAUSE_SCHEDULE_STATIC:
 424           pp_string (pp, "static");
 425           break;
 426         case OMP_CLAUSE_SCHEDULE_DYNAMIC:
 427           pp_string (pp, "dynamic");
 428           break;
 429         case OMP_CLAUSE_SCHEDULE_GUIDED:
 430           pp_string (pp, "guided");
 431           break;
 432         case OMP_CLAUSE_SCHEDULE_RUNTIME:
 433           pp_string (pp, "runtime");
 434           break;
 435         case OMP_CLAUSE_SCHEDULE_AUTO:
 436           pp_string (pp, "auto");
 437           break;
 438         case OMP_CLAUSE_SCHEDULE_CILKFOR:
 439           pp_string (pp, "cilk-for grain");
 440           break;
 441         default:
 442           gcc_unreachable ();
 443         }
 444       if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
 445         {
 446           pp_comma (pp);
 447           dump_generic_node (pp, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
 448                              spc, flags, false);
 449         }
 450       pp_right_paren (pp);
 451       break;
 452
 453     case OMP_CLAUSE_UNTIED:
 454       pp_string (pp, "untied");
 455       break;
 456
 457     case OMP_CLAUSE_COLLAPSE:
 458       pp_string (pp, "collapse(");
 459       dump_generic_node (pp, OMP_CLAUSE_COLLAPSE_EXPR (clause),
 460                          spc, flags, false);
 461       pp_right_paren (pp);
 462       break;
 463
 464     case OMP_CLAUSE_FINAL:
 465       pp_string (pp, "final(");
 466       dump_generic_node (pp, OMP_CLAUSE_FINAL_EXPR (clause),
 467                          spc, flags, false);
 468       pp_right_paren (pp);
 469       break;
 470
 471     case OMP_CLAUSE_MERGEABLE:
 472       pp_string (pp, "mergeable");
 473       break;
 474
 475     case OMP_CLAUSE_LINEAR:
 476       pp_string (pp, "linear(");
 477       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
 478                          spc, flags, false);
 479       pp_colon (pp);
 480       dump_generic_node (pp, OMP_CLAUSE_LINEAR_STEP (clause),
 481                          spc, flags, false);
 482       pp_right_paren (pp);
 483       break;
 484
 485     case OMP_CLAUSE_ALIGNED:
 486       pp_string (pp, "aligned(");
 487       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
 488                          spc, flags, false);
 489       if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause))
 490         {
 491           pp_colon (pp);
 492           dump_generic_node (pp, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause),
 493                              spc, flags, false);
 494         }
 495       pp_right_paren (pp);
 496       break;
 497
 498     case OMP_CLAUSE_DEPEND:
 499       pp_string (pp, "depend(");
 500       switch (OMP_CLAUSE_DEPEND_KIND (clause))
 501         {
 502         case OMP_CLAUSE_DEPEND_IN:
 503           pp_string (pp, "in");
 504           break;
 505         case OMP_CLAUSE_DEPEND_OUT:
 506           pp_string (pp, "out");
 507           break;
 508         case OMP_CLAUSE_DEPEND_INOUT:
 509           pp_string (pp, "inout");
 510           break;
 511         default:
 512           gcc_unreachable ();
 513         }
 514       pp_colon (pp);
 515       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
 516                          spc, flags, false);
 517       pp_right_paren (pp);
 518       break;
 519
 520     case OMP_CLAUSE_MAP:
 521       pp_string (pp, "map(");
 522       switch (OMP_CLAUSE_MAP_KIND (clause))
 523         {
 524         case OMP_CLAUSE_MAP_ALLOC:
 525         case OMP_CLAUSE_MAP_POINTER:
 526           pp_string (pp, "alloc");
 527           break;
 528         case OMP_CLAUSE_MAP_TO:
 529         case OMP_CLAUSE_MAP_TO_PSET:
 530           pp_string (pp, "to");
 531           break;
 532         case OMP_CLAUSE_MAP_FROM:
 533           pp_string (pp, "from");
 534           break;
 535         case OMP_CLAUSE_MAP_TOFROM:
 536           pp_string (pp, "tofrom");
 537           break;
 538         case OMP_CLAUSE_MAP_FORCE_ALLOC:
 539           pp_string (pp, "force_alloc");
 540           break;
 541         case OMP_CLAUSE_MAP_FORCE_TO:
 542           pp_string (pp, "force_to");
 543           break;
 544         case OMP_CLAUSE_MAP_FORCE_FROM:
 545           pp_string (pp, "force_from");
 546           break;
 547         case OMP_CLAUSE_MAP_FORCE_TOFROM:
 548           pp_string (pp, "force_tofrom");
 549           break;
 550         case OMP_CLAUSE_MAP_FORCE_PRESENT:
 551           pp_string (pp, "force_present");
 552           break;
 553         case OMP_CLAUSE_MAP_FORCE_DEALLOC:
 554           pp_string (pp, "force_dealloc");
 555           break;
 556         case OMP_CLAUSE_MAP_FORCE_DEVICEPTR:
 557           pp_string (pp, "force_deviceptr");
 558           break;
 559         default:
 560           gcc_unreachable ();
 561         }
 562       pp_colon (pp);
 563       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
 564                          spc, flags, false);
 565      print_clause_size:
 566       if (OMP_CLAUSE_SIZE (clause))
 567         {
 568           if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
 569               && OMP_CLAUSE_MAP_KIND (clause) == OMP_CLAUSE_MAP_POINTER)
 570             pp_string (pp, " [pointer assign, bias: ");
 571           else if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
 572                    && OMP_CLAUSE_MAP_KIND (clause) == OMP_CLAUSE_MAP_TO_PSET)
 573             pp_string (pp, " [pointer set, len: ");
 574           else
 575             pp_string (pp, " [len: ");
 576           dump_generic_node (pp, OMP_CLAUSE_SIZE (clause),
 577                              spc, flags, false);
 578           pp_right_bracket (pp);
 579         }
 580       pp_right_paren (pp);
 581       break;
 582
 583     case OMP_CLAUSE_FROM:
 584       pp_string (pp, "from(");
 585       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
 586                          spc, flags, false);
 587       goto print_clause_size;
 588
 589     case OMP_CLAUSE_TO:
 590       pp_string (pp, "to(");
 591       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
 592                          spc, flags, false);
 593       goto print_clause_size;
 594
 595     case OMP_CLAUSE__CACHE_:
 596       pp_string (pp, "(");
 597       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
 598                          spc, flags, false);
 599       goto print_clause_size;
 600
 601     case OMP_CLAUSE_NUM_TEAMS:
 602       pp_string (pp, "num_teams(");
 603       dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_EXPR (clause),
 604                          spc, flags, false);
 605       pp_right_paren (pp);
 606       break;
 607
 608     case OMP_CLAUSE_THREAD_LIMIT:
 609       pp_string (pp, "thread_limit(");
 610       dump_generic_node (pp, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause),
 611                          spc, flags, false);
 612       pp_right_paren (pp);
 613       break;
 614
 615     case OMP_CLAUSE_DEVICE:
 616       pp_string (pp, "device(");
 617       dump_generic_node (pp, OMP_CLAUSE_DEVICE_ID (clause),
 618                          spc, flags, false);
 619       pp_right_paren (pp);
 620       break;
 621
 622     case OMP_CLAUSE_DIST_SCHEDULE:
 623       pp_string (pp, "dist_schedule(static");
 624       if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause))
 625         {
 626           pp_comma (pp);
 627           dump_generic_node (pp,
 628                              OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause),
 629                              spc, flags, false);
 630         }
 631       pp_right_paren (pp);
 632       break;
 633
 634     case OMP_CLAUSE_PROC_BIND:
 635       pp_string (pp, "proc_bind(");
 636       switch (OMP_CLAUSE_PROC_BIND_KIND (clause))
 637         {
 638         case OMP_CLAUSE_PROC_BIND_MASTER:
 639           pp_string (pp, "master");
 640           break;
 641         case OMP_CLAUSE_PROC_BIND_CLOSE:
 642           pp_string (pp, "close");
 643           break;
 644         case OMP_CLAUSE_PROC_BIND_SPREAD:
 645           pp_string (pp, "spread");
 646           break;
 647         default:
 648           gcc_unreachable ();
 649         }
 650       pp_right_paren (pp);
 651       break;
 652
 653     case OMP_CLAUSE_SAFELEN:
 654       pp_string (pp, "safelen(");
 655       dump_generic_node (pp, OMP_CLAUSE_SAFELEN_EXPR (clause),
 656                          spc, flags, false);
 657       pp_right_paren (pp);
 658       break;
 659
 660     case OMP_CLAUSE_SIMDLEN:
 661       pp_string (pp, "simdlen(");
 662       dump_generic_node (pp, OMP_CLAUSE_SIMDLEN_EXPR (clause),
 663                          spc, flags, false);
 664       pp_right_paren (pp);
 665       break;
 666
 667     case OMP_CLAUSE__SIMDUID_:
 668       pp_string (pp, "_simduid_(");
 669       dump_generic_node (pp, OMP_CLAUSE__SIMDUID__DECL (clause),
 670                          spc, flags, false);
 671       pp_right_paren (pp);
 672       break;
 673
 674     case OMP_CLAUSE_GANG:
 675       pp_string (pp, "gang");
 676       if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE)
 677         {
 678           pp_string (pp, "(num: ");
 679           dump_generic_node (pp, OMP_CLAUSE_GANG_EXPR (clause),
 680                              spc, flags, false);
 681         }
 682       if (OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE)
 683         {
 684           if (OMP_CLAUSE_GANG_EXPR (clause) == NULL_TREE)
 685             pp_left_paren (pp);
 686           else
 687             pp_space (pp);
 688           pp_string (pp, "static:");
 689           if (OMP_CLAUSE_GANG_STATIC_EXPR (clause)
 690               == integer_minus_one_node)
 691             pp_character (pp, '*');
 692           else
 693             dump_generic_node (pp, OMP_CLAUSE_GANG_STATIC_EXPR (clause),
 694                                spc, flags, false);
 695         }
 696       if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE
 697           || OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE)
 698         pp_right_paren (pp);
 699       break;
 700
 701     case OMP_CLAUSE_ASYNC:
 702       pp_string (pp, "async");
 703       if (OMP_CLAUSE_ASYNC_EXPR (clause))
 704         {
 705           pp_character(pp, '(');
 706           dump_generic_node (pp, OMP_CLAUSE_ASYNC_EXPR (clause),
 707                              spc, flags, false);
 708           pp_character(pp, ')');
 709         }
 710       break;
 711
 712     case OMP_CLAUSE_AUTO:
 713     case OMP_CLAUSE_SEQ:
 714       pp_string (pp, omp_clause_code_name[OMP_CLAUSE_CODE (clause)]);
 715       break;
 716
 717     case OMP_CLAUSE_WAIT:
 718       pp_string (pp, "wait(");
 719       dump_generic_node (pp, OMP_CLAUSE_WAIT_EXPR (clause),
 720                          spc, flags, false);
 721       pp_character(pp, ')');
 722       break;
 723
 724     case OMP_CLAUSE_WORKER:
 725       pp_string (pp, "worker");
 726       if (OMP_CLAUSE_WORKER_EXPR (clause) != NULL_TREE)
 727         {
 728           pp_left_paren (pp);
 729           dump_generic_node (pp, OMP_CLAUSE_WORKER_EXPR (clause),
 730                              spc, flags, false);
 731           pp_right_paren (pp);
 732         }
 733       break;
 734
 735     case OMP_CLAUSE_VECTOR:
 736       pp_string (pp, "vector");
 737       if (OMP_CLAUSE_VECTOR_EXPR (clause) != NULL_TREE)
 738         {
 739           pp_left_paren (pp);
 740           dump_generic_node (pp, OMP_CLAUSE_VECTOR_EXPR (clause),
 741                              spc, flags, false);
 742           pp_right_paren (pp);
 743         }
 744       break;
 745
 746     case OMP_CLAUSE_NUM_GANGS:
 747       pp_string (pp, "num_gangs(");
 748       dump_generic_node (pp, OMP_CLAUSE_NUM_GANGS_EXPR (clause),
 749                          spc, flags, false);
 750       pp_character (pp, ')');
 751       break;
 752
 753     case OMP_CLAUSE_NUM_WORKERS:
 754       pp_string (pp, "num_workers(");
 755       dump_generic_node (pp, OMP_CLAUSE_NUM_WORKERS_EXPR (clause),
 756                          spc, flags, false);
 757       pp_character (pp, ')');
 758       break;
 759
 760     case OMP_CLAUSE_VECTOR_LENGTH:
 761       pp_string (pp, "vector_length(");
 762       dump_generic_node (pp, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause),
 763                          spc, flags, false);
 764       pp_character (pp, ')');
 765       break;
 766
 767     case OMP_CLAUSE_INBRANCH:
 768       pp_string (pp, "inbranch");
 769       break;
 770     case OMP_CLAUSE_NOTINBRANCH:
 771       pp_string (pp, "notinbranch");
 772       break;
 773     case OMP_CLAUSE_FOR:
 774       pp_string (pp, "for");
 775       break;
 776     case OMP_CLAUSE_PARALLEL:
 777       pp_string (pp, "parallel");
 778       break;
 779     case OMP_CLAUSE_SECTIONS:
 780       pp_string (pp, "sections");
 781       break;
 782     case OMP_CLAUSE_TASKGROUP:
 783       pp_string (pp, "taskgroup");
 784       break;
 785     case OMP_CLAUSE_INDEPENDENT:
 786       pp_string (pp, "independent");
 787       break;
 788
 789     default:
 790       /* Should never happen.  */
 791       dump_generic_node (pp, clause, spc, flags, false);
 792       break;
 793     }
 794 }
 795
 796
 797 /* Dump the list of OpenMP clauses.  PP, SPC and FLAGS are as in
 798    dump_generic_node.  */
 799
 800 void
 801 dump_omp_clauses (pretty_printer *pp, tree clause, int spc, int flags)
 802 {
 803   if (clause == NULL)
 804     return;
 805
 806   pp_space (pp);
 807   while (1)
 808     {
 809       dump_omp_clause (pp, clause, spc, flags);
 810       clause = OMP_CLAUSE_CHAIN (clause);
 811       if (clause == NULL)
 812         return;
 813       pp_space (pp);
 814     }
 815 }
 816
 817
 818 /* Dump location LOC to PP.  */
 819
 820 void
 821 dump_location (pretty_printer *pp, location_t loc)
 822 {
 823   expanded_location xloc = expand_location (loc);
 824
 825   pp_left_bracket (pp);
 826   if (xloc.file)
 827     {
 828       pp_string (pp, xloc.file);
 829       pp_string (pp, ":");
 830     }
 831   pp_decimal_int (pp, xloc.line);
 832   pp_colon (pp);
 833   pp_decimal_int (pp, xloc.column);
 834   pp_string (pp, "] ");
 835 }
 836
 837
 838 /* Dump lexical block BLOCK.  PP, SPC and FLAGS are as in
 839    dump_generic_node.  */
 840
 841 static void
 842 dump_block_node (pretty_printer *pp, tree block, int spc, int flags)
 843 {
 844   tree t;
 845
 846   pp_printf (pp, "BLOCK #%d ", BLOCK_NUMBER (block));
 847
 848   if (flags & TDF_ADDRESS)
 849     pp_printf (pp, "[%p] ", (void *) block);
 850
 851   if (BLOCK_ABSTRACT (block))
 852     pp_string (pp, "[abstract] ");
 853
 854   if (TREE_ASM_WRITTEN (block))
 855     pp_string (pp, "[written] ");
 856
 857   if (flags & TDF_SLIM)
 858     return;
 859
 860   if (BLOCK_SOURCE_LOCATION (block))
 861     dump_location (pp, BLOCK_SOURCE_LOCATION (block));
 862
 863   newline_and_indent (pp, spc + 2);
 864
 865   if (BLOCK_SUPERCONTEXT (block))
 866     {
 867       pp_string (pp, "SUPERCONTEXT: ");
 868       dump_generic_node (pp, BLOCK_SUPERCONTEXT (block), 0,
 869                          flags | TDF_SLIM, false);
 870       newline_and_indent (pp, spc + 2);
 871     }
 872
 873   if (BLOCK_SUBBLOCKS (block))
 874     {
 875       pp_string (pp, "SUBBLOCKS: ");
 876       for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
 877         {
 878           dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
 879           pp_space (pp);
 880         }
 881       newline_and_indent (pp, spc + 2);
 882     }
 883
 884   if (BLOCK_CHAIN (block))
 885     {
 886       pp_string (pp, "SIBLINGS: ");
 887       for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))
 888         {
 889           dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
 890           pp_space (pp);
 891         }
 892       newline_and_indent (pp, spc + 2);
 893     }
 894
 895   if (BLOCK_VARS (block))
 896     {
 897       pp_string (pp, "VARS: ");
 898       for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
 899         {
 900           dump_generic_node (pp, t, 0, flags, false);
 901           pp_space (pp);
 902         }
 903       newline_and_indent (pp, spc + 2);
 904     }
 905
 906   if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block)) > 0)
 907     {
 908       unsigned i;
 909       vec<tree, va_gc> *nlv = BLOCK_NONLOCALIZED_VARS (block);
 910
 911       pp_string (pp, "NONLOCALIZED_VARS: ");
 912       FOR_EACH_VEC_ELT (*nlv, i, t)
 913         {
 914           dump_generic_node (pp, t, 0, flags, false);
 915           pp_space (pp);
 916         }
 917       newline_and_indent (pp, spc + 2);
 918     }
 919
 920   if (BLOCK_ABSTRACT_ORIGIN (block))
 921     {
 922       pp_string (pp, "ABSTRACT_ORIGIN: ");
 923       dump_generic_node (pp, BLOCK_ABSTRACT_ORIGIN (block), 0,
 924                          flags | TDF_SLIM, false);
 925       newline_and_indent (pp, spc + 2);
 926     }
 927
 928   if (BLOCK_FRAGMENT_ORIGIN (block))
 929     {
 930       pp_string (pp, "FRAGMENT_ORIGIN: ");
 931       dump_generic_node (pp, BLOCK_FRAGMENT_ORIGIN (block), 0,
 932                          flags | TDF_SLIM, false);
 933       newline_and_indent (pp, spc + 2);
 934     }
 935
 936   if (BLOCK_FRAGMENT_CHAIN (block))
 937     {
 938       pp_string (pp, "FRAGMENT_CHAIN: ");
 939       for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))
 940         {
 941           dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
 942           pp_space (pp);
 943         }
 944       newline_and_indent (pp, spc + 2);
 945     }
 946 }
 947
 948
 949 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
 950    indent.  FLAGS specifies details to show in the dump (see TDF_* in
 951    dumpfile.h).  If IS_STMT is true, the object printed is considered
 952    to be a statement and it is terminated by ';' if appropriate.  */
 953
 954 int
 955 dump_generic_node (pretty_printer *pp, tree node, int spc, int flags,
 956                    bool is_stmt)
 957 {
 958   tree type;
 959   tree op0, op1;
 960   const char *str;
 961   bool is_expr;
 962   enum tree_code code;
 963
 964   if (node == NULL_TREE)
 965     return spc;
 966
 967   is_expr = EXPR_P (node);
 968
 969   if (is_stmt && (flags & TDF_STMTADDR))
 970     pp_printf (pp, "<&%p> ", (void *)node);
 971
 972   if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
 973     dump_location (pp, EXPR_LOCATION (node));
 974
 975   code = TREE_CODE (node);
 976   switch (code)
 977     {
 978     case ERROR_MARK:
 979       pp_string (pp, "<<< error >>>");
 980       break;
 981
 982     case IDENTIFIER_NODE:
 983       pp_tree_identifier (pp, node);
 984       break;
 985
 986     case TREE_LIST:
 987       while (node && node != error_mark_node)
 988         {
 989           if (TREE_PURPOSE (node))
 990             {
 991               dump_generic_node (pp, TREE_PURPOSE (node), spc, flags, false);
 992               pp_space (pp);
 993             }
 994           dump_generic_node (pp, TREE_VALUE (node), spc, flags, false);
 995           node = TREE_CHAIN (node);
 996           if (node && TREE_CODE (node) == TREE_LIST)
 997             {
 998               pp_comma (pp);
 999               pp_space (pp);
1000             }
1001         }
1002       break;
1003
1004     case TREE_BINFO:
1005       dump_generic_node (pp, BINFO_TYPE (node), spc, flags, false);
1006       break;
1007
1008     case TREE_VEC:
1009       {
1010         size_t i;
1011         if (TREE_VEC_LENGTH (node) > 0)
1012           {
1013             size_t len = TREE_VEC_LENGTH (node);
1014             for (i = 0; i < len - 1; i++)
1015               {
1016                 dump_generic_node (pp, TREE_VEC_ELT (node, i), spc, flags,
1017                                    false);
1018                 pp_comma (pp);
1019                 pp_space (pp);
1020               }
1021             dump_generic_node (pp, TREE_VEC_ELT (node, len - 1), spc,
1022                                flags, false);
1023           }
1024       }
1025       break;
1026
1027     case VOID_TYPE:
1028     case POINTER_BOUNDS_TYPE:
1029     case INTEGER_TYPE:
1030     case REAL_TYPE:
1031     case FIXED_POINT_TYPE:
1032     case COMPLEX_TYPE:
1033     case VECTOR_TYPE:
1034     case ENUMERAL_TYPE:
1035     case BOOLEAN_TYPE:
1036       {
1037         unsigned int quals = TYPE_QUALS (node);
1038         enum tree_code_class tclass;
1039
1040         if (quals & TYPE_QUAL_ATOMIC)
1041           pp_string (pp, "atomic ");
1042         if (quals & TYPE_QUAL_CONST)
1043           pp_string (pp, "const ");
1044         else if (quals & TYPE_QUAL_VOLATILE)
1045           pp_string (pp, "volatile ");
1046         else if (quals & TYPE_QUAL_RESTRICT)
1047           pp_string (pp, "restrict ");
1048
1049         if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
1050           {
1051             pp_string (pp, "<address-space-");
1052             pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
1053             pp_string (pp, "> ");
1054           }
1055
1056         tclass = TREE_CODE_CLASS (TREE_CODE (node));
1057
1058         if (tclass == tcc_declaration)
1059           {
1060             if (DECL_NAME (node))
1061               dump_decl_name (pp, node, flags);
1062             else
1063               pp_string (pp, "<unnamed type decl>");
1064           }
1065         else if (tclass == tcc_type)
1066           {
1067             if (TYPE_NAME (node))
1068               {
1069                 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
1070                   pp_tree_identifier (pp, TYPE_NAME (node));
1071                 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
1072                          && DECL_NAME (TYPE_NAME (node)))
1073                   dump_decl_name (pp, TYPE_NAME (node), flags);
1074                 else
1075                   pp_string (pp, "<unnamed type>");
1076               }
1077             else if (TREE_CODE (node) == VECTOR_TYPE)
1078               {
1079                 pp_string (pp, "vector");
1080                 pp_left_paren (pp);
1081                 pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (node));
1082                 pp_string (pp, ") ");
1083                 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1084               }
1085             else if (TREE_CODE (node) == INTEGER_TYPE)
1086               {
1087                 if (TYPE_PRECISION (node) == CHAR_TYPE_SIZE)
1088                   pp_string (pp, (TYPE_UNSIGNED (node)
1089                                       ? "unsigned char"
1090                                       : "signed char"));
1091                 else if (TYPE_PRECISION (node) == SHORT_TYPE_SIZE)
1092                   pp_string (pp, (TYPE_UNSIGNED (node)
1093                                       ? "unsigned short"
1094                                       : "signed short"));
1095                 else if (TYPE_PRECISION (node) == INT_TYPE_SIZE)
1096                   pp_string (pp, (TYPE_UNSIGNED (node)
1097                                       ? "unsigned int"
1098                                       : "signed int"));
1099                 else if (TYPE_PRECISION (node) == LONG_TYPE_SIZE)
1100                   pp_string (pp, (TYPE_UNSIGNED (node)
1101                                       ? "unsigned long"
1102                                       : "signed long"));
1103                 else if (TYPE_PRECISION (node) == LONG_LONG_TYPE_SIZE)
1104                   pp_string (pp, (TYPE_UNSIGNED (node)
1105                                       ? "unsigned long long"
1106                                       : "signed long long"));
1107                 else if (TYPE_PRECISION (node) >= CHAR_TYPE_SIZE
1108                          && exact_log2 (TYPE_PRECISION (node)) != -1)
1109                   {
1110                     pp_string (pp, (TYPE_UNSIGNED (node) ? "uint" : "int"));
1111                     pp_decimal_int (pp, TYPE_PRECISION (node));
1112                     pp_string (pp, "_t");
1113                   }
1114                 else
1115                   {
1116                     pp_string (pp, (TYPE_UNSIGNED (node)
1117                                         ? "<unnamed-unsigned:"
1118                                         : "<unnamed-signed:"));
1119                     pp_decimal_int (pp, TYPE_PRECISION (node));
1120                     pp_greater (pp);
1121                   }
1122               }
1123             else if (TREE_CODE (node) == COMPLEX_TYPE)
1124               {
1125                 pp_string (pp, "__complex__ ");
1126                 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1127               }
1128             else if (TREE_CODE (node) == REAL_TYPE)
1129               {
1130                 pp_string (pp, "<float:");
1131                 pp_decimal_int (pp, TYPE_PRECISION (node));
1132                 pp_greater (pp);
1133               }
1134             else if (TREE_CODE (node) == FIXED_POINT_TYPE)
1135               {
1136                 pp_string (pp, "<fixed-point-");
1137                 pp_string (pp, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
1138                 pp_decimal_int (pp, TYPE_PRECISION (node));
1139                 pp_greater (pp);
1140               }
1141             else if (TREE_CODE (node) == VOID_TYPE)
1142               pp_string (pp, "void");
1143             else
1144               pp_string (pp, "<unnamed type>");
1145           }
1146         break;
1147       }
1148
1149     case POINTER_TYPE:
1150     case REFERENCE_TYPE:
1151       str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
1152
1153       if (TREE_TYPE (node) == NULL)
1154         {
1155           pp_string (pp, str);
1156           pp_string (pp, "<null type>");
1157         }
1158       else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
1159         {
1160           tree fnode = TREE_TYPE (node);
1161
1162           dump_generic_node (pp, TREE_TYPE (fnode), spc, flags, false);
1163           pp_space (pp);
1164           pp_left_paren (pp);
1165           pp_string (pp, str);
1166           if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
1167             dump_decl_name (pp, TYPE_NAME (node), flags);
1168           else if (flags & TDF_NOUID)
1169             pp_printf (pp, "<Txxxx>");
1170           else
1171             pp_printf (pp, "<T%x>", TYPE_UID (node));
1172
1173           pp_right_paren (pp);
1174           dump_function_declaration (pp, fnode, spc, flags);
1175         }
1176       else
1177         {
1178           unsigned int quals = TYPE_QUALS (node);
1179
1180           dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1181           pp_space (pp);
1182           pp_string (pp, str);
1183
1184           if (quals & TYPE_QUAL_CONST)
1185             pp_string (pp, " const");
1186           if (quals & TYPE_QUAL_VOLATILE)
1187             pp_string (pp, " volatile");
1188           if (quals & TYPE_QUAL_RESTRICT)
1189             pp_string (pp, " restrict");
1190
1191           if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
1192             {
1193               pp_string (pp, " <address-space-");
1194               pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
1195               pp_greater (pp);
1196             }
1197
1198           if (TYPE_REF_CAN_ALIAS_ALL (node))
1199             pp_string (pp, " {ref-all}");
1200         }
1201       break;
1202
1203     case OFFSET_TYPE:
1204       NIY;
1205       break;
1206
1207     case MEM_REF:
1208       {
1209         if (integer_zerop (TREE_OPERAND (node, 1))
1210             /* Dump the types of INTEGER_CSTs explicitly, for we can't
1211                infer them and MEM_ATTR caching will share MEM_REFs
1212                with differently-typed op0s.  */
1213             && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
1214             /* Released SSA_NAMES have no TREE_TYPE.  */
1215             && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
1216             /* Same pointer types, but ignoring POINTER_TYPE vs.
1217                REFERENCE_TYPE.  */
1218             && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
1219                 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
1220             && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
1221                 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
1222             && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
1223                 == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
1224             /* Same value types ignoring qualifiers.  */
1225             && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
1226                 == TYPE_MAIN_VARIANT
1227                     (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))
1228             && (!(flags & TDF_ALIAS)
1229                 || MR_DEPENDENCE_CLIQUE (node) == 0))
1230           {
1231             if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
1232               {
1233                 pp_star (pp);
1234                 dump_generic_node (pp, TREE_OPERAND (node, 0),
1235                                    spc, flags, false);
1236               }
1237             else
1238               dump_generic_node (pp,
1239                                  TREE_OPERAND (TREE_OPERAND (node, 0), 0),
1240                                  spc, flags, false);
1241           }
1242         else
1243           {
1244             tree ptype;
1245
1246             pp_string (pp, "MEM[");
1247             pp_left_paren (pp);
1248             ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1)));
1249             dump_generic_node (pp, ptype,
1250                                spc, flags | TDF_SLIM, false);
1251             pp_right_paren (pp);
1252             dump_generic_node (pp, TREE_OPERAND (node, 0),
1253                                spc, flags, false);
1254             if (!integer_zerop (TREE_OPERAND (node, 1)))
1255               {
1256                 pp_string (pp, " + ");
1257                 dump_generic_node (pp, TREE_OPERAND (node, 1),
1258                                    spc, flags, false);
1259               }
1260             if ((flags & TDF_ALIAS)
1261                 && MR_DEPENDENCE_CLIQUE (node) != 0)
1262               {
1263                 pp_string (pp, " clique ");
1264                 pp_unsigned_wide_integer (pp, MR_DEPENDENCE_CLIQUE (node));
1265                 pp_string (pp, " base ");
1266                 pp_unsigned_wide_integer (pp, MR_DEPENDENCE_BASE (node));
1267               }
1268             pp_right_bracket (pp);
1269           }
1270         break;
1271       }
1272
1273     case TARGET_MEM_REF:
1274       {
1275         const char *sep = "";
1276         tree tmp;
1277
1278         pp_string (pp, "MEM[");
1279
1280         if (TREE_CODE (TMR_BASE (node)) == ADDR_EXPR)
1281           {
1282             pp_string (pp, sep);
1283             sep = ", ";
1284             pp_string (pp, "symbol: ");
1285             dump_generic_node (pp, TREE_OPERAND (TMR_BASE (node), 0),
1286                                spc, flags, false);
1287           }
1288         else
1289           {
1290             pp_string (pp, sep);
1291             sep = ", ";
1292             pp_string (pp, "base: ");
1293             dump_generic_node (pp, TMR_BASE (node), spc, flags, false);
1294           }
1295         tmp = TMR_INDEX2 (node);
1296         if (tmp)
1297           {
1298             pp_string (pp, sep);
1299             sep = ", ";
1300             pp_string (pp, "base: ");
1301             dump_generic_node (pp, tmp, spc, flags, false);
1302           }
1303         tmp = TMR_INDEX (node);
1304         if (tmp)
1305           {
1306             pp_string (pp, sep);
1307             sep = ", ";
1308             pp_string (pp, "index: ");
1309             dump_generic_node (pp, tmp, spc, flags, false);
1310           }
1311         tmp = TMR_STEP (node);
1312         if (tmp)
1313           {
1314             pp_string (pp, sep);
1315             sep = ", ";
1316             pp_string (pp, "step: ");
1317             dump_generic_node (pp, tmp, spc, flags, false);
1318           }
1319         tmp = TMR_OFFSET (node);
1320         if (tmp)
1321           {
1322             pp_string (pp, sep);
1323             sep = ", ";
1324             pp_string (pp, "offset: ");
1325             dump_generic_node (pp, tmp, spc, flags, false);
1326           }
1327         pp_right_bracket (pp);
1328       }
1329       break;
1330
1331     case ARRAY_TYPE:
1332       {
1333         tree tmp;
1334
1335         /* Print the innermost component type.  */
1336         for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
1337              tmp = TREE_TYPE (tmp))
1338           ;
1339         dump_generic_node (pp, tmp, spc, flags, false);
1340
1341         /* Print the dimensions.  */
1342         for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
1343           dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
1344         break;
1345       }
1346
1347     case RECORD_TYPE:
1348     case UNION_TYPE:
1349     case QUAL_UNION_TYPE:
1350       {
1351         unsigned int quals = TYPE_QUALS (node);
1352
1353         if (quals & TYPE_QUAL_ATOMIC)
1354           pp_string (pp, "atomic ");
1355         if (quals & TYPE_QUAL_CONST)
1356           pp_string (pp, "const ");
1357         if (quals & TYPE_QUAL_VOLATILE)
1358           pp_string (pp, "volatile ");
1359
1360         /* Print the name of the structure.  */
1361         if (TREE_CODE (node) == RECORD_TYPE)
1362           pp_string (pp, "struct ");
1363         else if (TREE_CODE (node) == UNION_TYPE)
1364           pp_string (pp, "union ");
1365
1366         if (TYPE_NAME (node))
1367           dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
1368         else if (!(flags & TDF_SLIM))
1369           /* FIXME: If we eliminate the 'else' above and attempt
1370              to show the fields for named types, we may get stuck
1371              following a cycle of pointers to structs.  The alleged
1372              self-reference check in print_struct_decl will not detect
1373              cycles involving more than one pointer or struct type.  */
1374           print_struct_decl (pp, node, spc, flags);
1375         break;
1376       }
1377
1378     case LANG_TYPE:
1379       NIY;
1380       break;
1381
1382     case INTEGER_CST:
1383       if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
1384         {
1385           /* In the case of a pointer, one may want to divide by the
1386              size of the pointed-to type.  Unfortunately, this not
1387              straightforward.  The C front-end maps expressions
1388
1389              (int *) 5
1390              int *p; (p + 5)
1391
1392              in such a way that the two INTEGER_CST nodes for "5" have
1393              different values but identical types.  In the latter
1394              case, the 5 is multiplied by sizeof (int) in c-common.c
1395              (pointer_int_sum) to convert it to a byte address, and
1396              yet the type of the node is left unchanged.  Argh.  What
1397              is consistent though is that the number value corresponds
1398              to bytes (UNITS) offset.
1399
1400              NB: Neither of the following divisors can be trivially
1401              used to recover the original literal:
1402
1403              TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
1404              TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node)))  */
1405           pp_wide_integer (pp, TREE_INT_CST_LOW (node));
1406           pp_string (pp, "B"); /* pseudo-unit */
1407         }
1408       else if (tree_fits_shwi_p (node))
1409         pp_wide_integer (pp, tree_to_shwi (node));
1410       else if (tree_fits_uhwi_p (node))
1411         pp_unsigned_wide_integer (pp, tree_to_uhwi (node));
1412       else
1413         {
1414           wide_int val = node;
1415
1416           if (wi::neg_p (val, TYPE_SIGN (TREE_TYPE (node))))
1417             {
1418               pp_minus (pp);
1419               val = -val;
1420             }
1421           print_hex (val, pp_buffer (pp)->digit_buffer);
1422           pp_string (pp, pp_buffer (pp)->digit_buffer);
1423         }
1424       if (TREE_OVERFLOW (node))
1425         pp_string (pp, "(OVF)");
1426       break;
1427
1428     case REAL_CST:
1429       /* Code copied from print_node.  */
1430       {
1431         REAL_VALUE_TYPE d;
1432         if (TREE_OVERFLOW (node))
1433           pp_string (pp, " overflow");
1434
1435 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
1436         d = TREE_REAL_CST (node);
1437         if (REAL_VALUE_ISINF (d))
1438           pp_string (pp, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
1439         else if (REAL_VALUE_ISNAN (d))
1440           pp_string (pp, " Nan");
1441         else
1442           {
1443             char string[100];
1444             real_to_decimal (string, &d, sizeof (string), 0, 1);
1445             pp_string (pp, string);
1446           }
1447 #else
1448         {
1449           HOST_WIDE_INT i;
1450           unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
1451           pp_string (pp, "0x");
1452           for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
1453             output_formatted_integer (pp, "%02x", *p++);
1454         }
1455 #endif
1456         break;
1457       }
1458
1459     case FIXED_CST:
1460       {
1461         char string[100];
1462         fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
1463         pp_string (pp, string);
1464         break;
1465       }
1466
1467     case COMPLEX_CST:
1468       pp_string (pp, "__complex__ (");
1469       dump_generic_node (pp, TREE_REALPART (node), spc, flags, false);
1470       pp_string (pp, ", ");
1471       dump_generic_node (pp, TREE_IMAGPART (node), spc, flags, false);
1472       pp_right_paren (pp);
1473       break;
1474
1475     case STRING_CST:
1476       pp_string (pp, "\"");
1477       pretty_print_string (pp, TREE_STRING_POINTER (node));
1478       pp_string (pp, "\"");
1479       break;
1480
1481     case VECTOR_CST:
1482       {
1483         unsigned i;
1484         pp_string (pp, "{ ");
1485         for (i = 0; i < VECTOR_CST_NELTS (node); ++i)
1486           {
1487             if (i != 0)
1488               pp_string (pp, ", ");
1489             dump_generic_node (pp, VECTOR_CST_ELT (node, i),
1490                                spc, flags, false);
1491           }
1492         pp_string (pp, " }");
1493       }
1494       break;
1495
1496     case FUNCTION_TYPE:
1497     case METHOD_TYPE:
1498       dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1499       pp_space (pp);
1500       if (TREE_CODE (node) == METHOD_TYPE)
1501         {
1502           if (TYPE_METHOD_BASETYPE (node))
1503             dump_decl_name (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
1504                             flags);
1505           else
1506             pp_string (pp, "<null method basetype>");
1507           pp_colon_colon (pp);
1508         }
1509       if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
1510         dump_decl_name (pp, TYPE_NAME (node), flags);
1511       else if (flags & TDF_NOUID)
1512         pp_printf (pp, "<Txxxx>");
1513       else
1514         pp_printf (pp, "<T%x>", TYPE_UID (node));
1515       dump_function_declaration (pp, node, spc, flags);
1516       break;
1517
1518     case FUNCTION_DECL:
1519     case CONST_DECL:
1520       dump_decl_name (pp, node, flags);
1521       break;
1522
1523     case LABEL_DECL:
1524       if (DECL_NAME (node))
1525         dump_decl_name (pp, node, flags);
1526       else if (LABEL_DECL_UID (node) != -1)
1527         pp_printf (pp, "<L%d>", (int) LABEL_DECL_UID (node));
1528       else
1529         {
1530           if (flags & TDF_NOUID)
1531             pp_string (pp, "<D.xxxx>");
1532           else
1533             pp_printf (pp, "<D.%u>", DECL_UID (node));
1534         }
1535       break;
1536
1537     case TYPE_DECL:
1538       if (DECL_IS_BUILTIN (node))
1539         {
1540           /* Don't print the declaration of built-in types.  */
1541           break;
1542         }
1543       if (DECL_NAME (node))
1544         dump_decl_name (pp, node, flags);
1545       else if (TYPE_NAME (TREE_TYPE (node)) != node)
1546         {
1547           if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
1548                || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
1549               && TYPE_METHODS (TREE_TYPE (node)))
1550             {
1551               /* The type is a c++ class: all structures have at least
1552                  4 methods.  */
1553               pp_string (pp, "class ");
1554               dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1555             }
1556           else
1557             {
1558               pp_string (pp,
1559                          (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
1560                           ? "union" : "struct "));
1561               dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1562             }
1563         }
1564       else
1565         pp_string (pp, "<anon>");
1566       break;
1567
1568     case VAR_DECL:
1569     case PARM_DECL:
1570     case FIELD_DECL:
1571     case DEBUG_EXPR_DECL:
1572     case NAMESPACE_DECL:
1573     case NAMELIST_DECL:
1574       dump_decl_name (pp, node, flags);
1575       break;
1576
1577     case RESULT_DECL:
1578       pp_string (pp, "<retval>");
1579       break;
1580
1581     case COMPONENT_REF:
1582       op0 = TREE_OPERAND (node, 0);
1583       str = ".";
1584       if (op0
1585           && (TREE_CODE (op0) == INDIRECT_REF
1586               || (TREE_CODE (op0) == MEM_REF
1587                   && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
1588                   && integer_zerop (TREE_OPERAND (op0, 1))
1589                   /* Dump the types of INTEGER_CSTs explicitly, for we
1590                      can't infer them and MEM_ATTR caching will share
1591                      MEM_REFs with differently-typed op0s.  */
1592                   && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
1593                   /* Released SSA_NAMES have no TREE_TYPE.  */
1594                   && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE
1595                   /* Same pointer types, but ignoring POINTER_TYPE vs.
1596                      REFERENCE_TYPE.  */
1597                   && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
1598                       == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))
1599                   && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0)))
1600                       == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
1601                   && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
1602                       == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
1603                   /* Same value types ignoring qualifiers.  */
1604                   && (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
1605                       == TYPE_MAIN_VARIANT
1606                           (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))))
1607                   && MR_DEPENDENCE_CLIQUE (op0) == 0)))
1608         {
1609           op0 = TREE_OPERAND (op0, 0);
1610           str = "->";
1611         }
1612       if (op_prio (op0) < op_prio (node))
1613         pp_left_paren (pp);
1614       dump_generic_node (pp, op0, spc, flags, false);
1615       if (op_prio (op0) < op_prio (node))
1616         pp_right_paren (pp);
1617       pp_string (pp, str);
1618       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1619       op0 = component_ref_field_offset (node);
1620       if (op0 && TREE_CODE (op0) != INTEGER_CST)
1621         {
1622           pp_string (pp, "{off: ");
1623               dump_generic_node (pp, op0, spc, flags, false);
1624               pp_right_brace (pp);
1625         }
1626       break;
1627
1628     case BIT_FIELD_REF:
1629       pp_string (pp, "BIT_FIELD_REF <");
1630       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
1631       pp_string (pp, ", ");
1632       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1633       pp_string (pp, ", ");
1634       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
1635       pp_greater (pp);
1636       break;
1637
1638     case ARRAY_REF:
1639     case ARRAY_RANGE_REF:
1640       op0 = TREE_OPERAND (node, 0);
1641       if (op_prio (op0) < op_prio (node))
1642         pp_left_paren (pp);
1643       dump_generic_node (pp, op0, spc, flags, false);
1644       if (op_prio (op0) < op_prio (node))
1645         pp_right_paren (pp);
1646       pp_left_bracket (pp);
1647       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1648       if (TREE_CODE (node) == ARRAY_RANGE_REF)
1649         pp_string (pp, " ...");
1650       pp_right_bracket (pp);
1651
1652       op0 = array_ref_low_bound (node);
1653       op1 = array_ref_element_size (node);
1654
1655       if (!integer_zerop (op0)
1656           || TREE_OPERAND (node, 2)
1657           || TREE_OPERAND (node, 3))
1658         {
1659           pp_string (pp, "{lb: ");
1660           dump_generic_node (pp, op0, spc, flags, false);
1661           pp_string (pp, " sz: ");
1662           dump_generic_node (pp, op1, spc, flags, false);
1663           pp_right_brace (pp);
1664         }
1665       break;
1666
1667     case CONSTRUCTOR:
1668       {
1669         unsigned HOST_WIDE_INT ix;
1670         tree field, val;
1671         bool is_struct_init = false;
1672         bool is_array_init = false;
1673         widest_int curidx;
1674         pp_left_brace (pp);
1675         if (TREE_CLOBBER_P (node))
1676           pp_string (pp, "CLOBBER");
1677         else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
1678                  || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
1679           is_struct_init = true;
1680         else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE
1681                  && TYPE_DOMAIN (TREE_TYPE (node))
1682                  && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))
1683                  && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))))
1684                     == INTEGER_CST)
1685           {
1686             tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)));
1687             is_array_init = true;
1688             curidx = wi::to_widest (minv);
1689           }
1690         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
1691           {
1692             if (field)
1693               {
1694                 if (is_struct_init)
1695                   {
1696                     pp_dot (pp);
1697                     dump_generic_node (pp, field, spc, flags, false);
1698                     pp_equal (pp);
1699                   }
1700                 else if (is_array_init
1701                          && (TREE_CODE (field) != INTEGER_CST
1702                              || curidx != wi::to_widest (field)))
1703                   {
1704                     pp_left_bracket (pp);
1705                     if (TREE_CODE (field) == RANGE_EXPR)
1706                       {
1707                         dump_generic_node (pp, TREE_OPERAND (field, 0), spc,
1708                                            flags, false);
1709                         pp_string (pp, " ... ");
1710                         dump_generic_node (pp, TREE_OPERAND (field, 1), spc,
1711                                            flags, false);
1712                         if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST)
1713                           curidx = wi::to_widest (TREE_OPERAND (field, 1));
1714                       }
1715                     else
1716                       dump_generic_node (pp, field, spc, flags, false);
1717                     if (TREE_CODE (field) == INTEGER_CST)
1718                       curidx = wi::to_widest (field);
1719                     pp_string (pp, "]=");
1720                   }
1721               }
1722             if (is_array_init)
1723               curidx += 1;
1724             if (val && TREE_CODE (val) == ADDR_EXPR)
1725               if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
1726                 val = TREE_OPERAND (val, 0);
1727             if (val && TREE_CODE (val) == FUNCTION_DECL)
1728                 dump_decl_name (pp, val, flags);
1729             else
1730                 dump_generic_node (pp, val, spc, flags, false);
1731             if (ix != vec_safe_length (CONSTRUCTOR_ELTS (node)) - 1)
1732               {
1733                 pp_comma (pp);
1734                 pp_space (pp);
1735               }
1736           }
1737         pp_right_brace (pp);
1738       }
1739       break;
1740
1741     case COMPOUND_EXPR:
1742       {
1743         tree *tp;
1744         if (flags & TDF_SLIM)
1745           {
1746             pp_string (pp, "<COMPOUND_EXPR>");
1747             break;
1748           }
1749
1750         dump_generic_node (pp, TREE_OPERAND (node, 0),
1751                            spc, flags, !(flags & TDF_SLIM));
1752         if (flags & TDF_SLIM)
1753           newline_and_indent (pp, spc);
1754         else
1755           {
1756             pp_comma (pp);
1757             pp_space (pp);
1758           }
1759
1760         for (tp = &TREE_OPERAND (node, 1);
1761              TREE_CODE (*tp) == COMPOUND_EXPR;
1762              tp = &TREE_OPERAND (*tp, 1))
1763           {
1764             dump_generic_node (pp, TREE_OPERAND (*tp, 0),
1765                                spc, flags, !(flags & TDF_SLIM));
1766             if (flags & TDF_SLIM)
1767               newline_and_indent (pp, spc);
1768             else
1769               {
1770                 pp_comma (pp);
1771                 pp_space (pp);
1772               }
1773           }
1774
1775         dump_generic_node (pp, *tp, spc, flags, !(flags & TDF_SLIM));
1776       }
1777       break;
1778
1779     case STATEMENT_LIST:
1780       {
1781         tree_stmt_iterator si;
1782         bool first = true;
1783
1784         if (flags & TDF_SLIM)
1785           {
1786             pp_string (pp, "<STATEMENT_LIST>");
1787             break;
1788           }
1789
1790         for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1791           {
1792             if (!first)
1793               newline_and_indent (pp, spc);
1794             else
1795               first = false;
1796             dump_generic_node (pp, tsi_stmt (si), spc, flags, true);
1797           }
1798       }
1799       break;
1800
1801     case MODIFY_EXPR:
1802     case INIT_EXPR:
1803       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags,
1804                          false);
1805       pp_space (pp);
1806       pp_equal (pp);
1807       pp_space (pp);
1808       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags,
1809                          false);
1810       break;
1811
1812     case TARGET_EXPR:
1813       pp_string (pp, "TARGET_EXPR <");
1814       dump_generic_node (pp, TARGET_EXPR_SLOT (node), spc, flags, false);
1815       pp_comma (pp);
1816       pp_space (pp);
1817       dump_generic_node (pp, TARGET_EXPR_INITIAL (node), spc, flags, false);
1818       pp_greater (pp);
1819       break;
1820
1821     case DECL_EXPR:
1822       print_declaration (pp, DECL_EXPR_DECL (node), spc, flags);
1823       is_stmt = false;
1824       break;
1825
1826     case COND_EXPR:
1827       if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1828         {
1829           pp_string (pp, "if (");
1830           dump_generic_node (pp, COND_EXPR_COND (node), spc, flags, false);
1831           pp_right_paren (pp);
1832           /* The lowered cond_exprs should always be printed in full.  */
1833           if (COND_EXPR_THEN (node)
1834               && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1835                   || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1836               && COND_EXPR_ELSE (node)
1837               && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1838                   || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1839             {
1840               pp_space (pp);
1841               dump_generic_node (pp, COND_EXPR_THEN (node),
1842                                  0, flags, true);
1843               if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1844                 {
1845                   pp_string (pp, " else ");
1846                   dump_generic_node (pp, COND_EXPR_ELSE (node),
1847                                      0, flags, true);
1848                 }
1849             }
1850           else if (!(flags & TDF_SLIM))
1851             {
1852               /* Output COND_EXPR_THEN.  */
1853               if (COND_EXPR_THEN (node))
1854                 {
1855                   newline_and_indent (pp, spc+2);
1856                   pp_left_brace (pp);
1857                   newline_and_indent (pp, spc+4);
1858                   dump_generic_node (pp, COND_EXPR_THEN (node), spc+4,
1859                                      flags, true);
1860                   newline_and_indent (pp, spc+2);
1861                   pp_right_brace (pp);
1862                 }
1863
1864               /* Output COND_EXPR_ELSE.  */
1865               if (COND_EXPR_ELSE (node)
1866                   && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
1867                 {
1868                   newline_and_indent (pp, spc);
1869                   pp_string (pp, "else");
1870                   newline_and_indent (pp, spc+2);
1871                   pp_left_brace (pp);
1872                   newline_and_indent (pp, spc+4);
1873                   dump_generic_node (pp, COND_EXPR_ELSE (node), spc+4,
1874                                      flags, true);
1875                   newline_and_indent (pp, spc+2);
1876                   pp_right_brace (pp);
1877                 }
1878             }
1879           is_expr = false;
1880         }
1881       else
1882         {
1883           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
1884           pp_space (pp);
1885           pp_question (pp);
1886           pp_space (pp);
1887           dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
1888           pp_space (pp);
1889           pp_colon (pp);
1890           pp_space (pp);
1891           dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
1892         }
1893       break;
1894
1895     case BIND_EXPR:
1896       pp_left_brace (pp);
1897       if (!(flags & TDF_SLIM))
1898         {
1899           if (BIND_EXPR_VARS (node))
1900             {
1901               pp_newline (pp);
1902
1903               for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0))
1904                 {
1905                   print_declaration (pp, op0, spc+2, flags);
1906                   pp_newline (pp);
1907                 }
1908             }
1909
1910           newline_and_indent (pp, spc+2);
1911           dump_generic_node (pp, BIND_EXPR_BODY (node), spc+2, flags, true);
1912           newline_and_indent (pp, spc);
1913           pp_right_brace (pp);
1914         }
1915       is_expr = false;
1916       break;
1917
1918     case CALL_EXPR:
1919       if (CALL_EXPR_FN (node) != NULL_TREE)
1920         print_call_name (pp, CALL_EXPR_FN (node), flags);
1921       else
1922         pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node)));
1923
1924       /* Print parameters.  */
1925       pp_space (pp);
1926       pp_left_paren (pp);
1927       {
1928         tree arg;
1929         call_expr_arg_iterator iter;
1930         FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
1931           {
1932             dump_generic_node (pp, arg, spc, flags, false);
1933             if (more_call_expr_args_p (&iter))
1934               {
1935                 pp_comma (pp);
1936                 pp_space (pp);
1937               }
1938           }
1939       }
1940       if (CALL_EXPR_VA_ARG_PACK (node))
1941         {
1942           if (call_expr_nargs (node) > 0)
1943             {
1944               pp_comma (pp);
1945               pp_space (pp);
1946             }
1947           pp_string (pp, "__builtin_va_arg_pack ()");
1948         }
1949       pp_right_paren (pp);
1950
1951       op1 = CALL_EXPR_STATIC_CHAIN (node);
1952       if (op1)
1953         {
1954           pp_string (pp, " [static-chain: ");
1955           dump_generic_node (pp, op1, spc, flags, false);
1956           pp_right_bracket (pp);
1957         }
1958
1959       if (CALL_EXPR_RETURN_SLOT_OPT (node))
1960         pp_string (pp, " [return slot optimization]");
1961       if (CALL_EXPR_TAILCALL (node))
1962         pp_string (pp, " [tail call]");
1963       break;
1964
1965     case WITH_CLEANUP_EXPR:
1966       NIY;
1967       break;
1968
1969     case CLEANUP_POINT_EXPR:
1970       pp_string (pp, "<<cleanup_point ");
1971       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
1972       pp_string (pp, ">>");
1973       break;
1974
1975     case PLACEHOLDER_EXPR:
1976       pp_string (pp, "<PLACEHOLDER_EXPR ");
1977       dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1978       pp_greater (pp);
1979       break;
1980
1981       /* Binary arithmetic and logic expressions.  */
1982     case WIDEN_SUM_EXPR:
1983     case WIDEN_MULT_EXPR:
1984     case MULT_EXPR:
1985     case MULT_HIGHPART_EXPR:
1986     case PLUS_EXPR:
1987     case POINTER_PLUS_EXPR:
1988     case MINUS_EXPR:
1989     case TRUNC_DIV_EXPR:
1990     case CEIL_DIV_EXPR:
1991     case FLOOR_DIV_EXPR:
1992     case ROUND_DIV_EXPR:
1993     case TRUNC_MOD_EXPR:
1994     case CEIL_MOD_EXPR:
1995     case FLOOR_MOD_EXPR:
1996     case ROUND_MOD_EXPR:
1997     case RDIV_EXPR:
1998     case EXACT_DIV_EXPR:
1999     case LSHIFT_EXPR:
2000     case RSHIFT_EXPR:
2001     case LROTATE_EXPR:
2002     case RROTATE_EXPR:
2003     case WIDEN_LSHIFT_EXPR:
2004     case BIT_IOR_EXPR:
2005     case BIT_XOR_EXPR:
2006     case BIT_AND_EXPR:
2007     case TRUTH_ANDIF_EXPR:
2008     case TRUTH_ORIF_EXPR:
2009     case TRUTH_AND_EXPR:
2010     case TRUTH_OR_EXPR:
2011     case TRUTH_XOR_EXPR:
2012     case LT_EXPR:
2013     case LE_EXPR:
2014     case GT_EXPR:
2015     case GE_EXPR:
2016     case EQ_EXPR:
2017     case NE_EXPR:
2018     case UNLT_EXPR:
2019     case UNLE_EXPR:
2020     case UNGT_EXPR:
2021     case UNGE_EXPR:
2022     case UNEQ_EXPR:
2023     case LTGT_EXPR:
2024     case ORDERED_EXPR:
2025     case UNORDERED_EXPR:
2026       {
2027         const char *op = op_symbol (node);
2028         op0 = TREE_OPERAND (node, 0);
2029         op1 = TREE_OPERAND (node, 1);
2030
2031         /* When the operands are expressions with less priority,
2032            keep semantics of the tree representation.  */
2033         if (op_prio (op0) <= op_prio (node))
2034           {
2035             pp_left_paren (pp);
2036             dump_generic_node (pp, op0, spc, flags, false);
2037             pp_right_paren (pp);
2038           }
2039         else
2040           dump_generic_node (pp, op0, spc, flags, false);
2041
2042         pp_space (pp);
2043         pp_string (pp, op);
2044         pp_space (pp);
2045
2046         /* When the operands are expressions with less priority,
2047            keep semantics of the tree representation.  */
2048         if (op_prio (op1) <= op_prio (node))
2049           {
2050             pp_left_paren (pp);
2051             dump_generic_node (pp, op1, spc, flags, false);
2052             pp_right_paren (pp);
2053           }
2054         else
2055           dump_generic_node (pp, op1, spc, flags, false);
2056       }
2057       break;
2058
2059       /* Unary arithmetic and logic expressions.  */
2060     case NEGATE_EXPR:
2061     case BIT_NOT_EXPR:
2062     case TRUTH_NOT_EXPR:
2063     case ADDR_EXPR:
2064     case PREDECREMENT_EXPR:
2065     case PREINCREMENT_EXPR:
2066     case INDIRECT_REF:
2067       if (TREE_CODE (node) == ADDR_EXPR
2068           && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
2069               || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
2070         ;       /* Do not output '&' for strings and function pointers.  */
2071       else
2072         pp_string (pp, op_symbol (node));
2073
2074       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
2075         {
2076           pp_left_paren (pp);
2077           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2078           pp_right_paren (pp);
2079         }
2080       else
2081         dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2082       break;
2083
2084     case POSTDECREMENT_EXPR:
2085     case POSTINCREMENT_EXPR:
2086       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
2087         {
2088           pp_left_paren (pp);
2089           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2090           pp_right_paren (pp);
2091         }
2092       else
2093         dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2094       pp_string (pp, op_symbol (node));
2095       break;
2096
2097     case MIN_EXPR:
2098       pp_string (pp, "MIN_EXPR <");
2099       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2100       pp_string (pp, ", ");
2101       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2102       pp_greater (pp);
2103       break;
2104
2105     case MAX_EXPR:
2106       pp_string (pp, "MAX_EXPR <");
2107       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2108       pp_string (pp, ", ");
2109       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2110       pp_greater (pp);
2111       break;
2112
2113     case ABS_EXPR:
2114       pp_string (pp, "ABS_EXPR <");
2115       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2116       pp_greater (pp);
2117       break;
2118
2119     case RANGE_EXPR:
2120       NIY;
2121       break;
2122
2123     case ADDR_SPACE_CONVERT_EXPR:
2124     case FIXED_CONVERT_EXPR:
2125     case FIX_TRUNC_EXPR:
2126     case FLOAT_EXPR:
2127     CASE_CONVERT:
2128       type = TREE_TYPE (node);
2129       op0 = TREE_OPERAND (node, 0);
2130       if (type != TREE_TYPE (op0))
2131         {
2132           pp_left_paren (pp);
2133           dump_generic_node (pp, type, spc, flags, false);
2134           pp_string (pp, ") ");
2135         }
2136       if (op_prio (op0) < op_prio (node))
2137         pp_left_paren (pp);
2138       dump_generic_node (pp, op0, spc, flags, false);
2139       if (op_prio (op0) < op_prio (node))
2140         pp_right_paren (pp);
2141       break;
2142
2143     case VIEW_CONVERT_EXPR:
2144       pp_string (pp, "VIEW_CONVERT_EXPR<");
2145       dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2146       pp_string (pp, ">(");
2147       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2148       pp_right_paren (pp);
2149       break;
2150
2151     case PAREN_EXPR:
2152       pp_string (pp, "((");
2153       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2154       pp_string (pp, "))");
2155       break;
2156
2157     case NON_LVALUE_EXPR:
2158       pp_string (pp, "NON_LVALUE_EXPR <");
2159       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2160       pp_greater (pp);
2161       break;
2162
2163     case SAVE_EXPR:
2164       pp_string (pp, "SAVE_EXPR <");
2165       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2166       pp_greater (pp);
2167       break;
2168
2169     case COMPLEX_EXPR:
2170       pp_string (pp, "COMPLEX_EXPR <");
2171       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2172       pp_string (pp, ", ");
2173       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2174       pp_greater (pp);
2175       break;
2176
2177     case CONJ_EXPR:
2178       pp_string (pp, "CONJ_EXPR <");
2179       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2180       pp_greater (pp);
2181       break;
2182
2183     case REALPART_EXPR:
2184       pp_string (pp, "REALPART_EXPR <");
2185       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2186       pp_greater (pp);
2187       break;
2188
2189     case IMAGPART_EXPR:
2190       pp_string (pp, "IMAGPART_EXPR <");
2191       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2192       pp_greater (pp);
2193       break;
2194
2195     case VA_ARG_EXPR:
2196       pp_string (pp, "VA_ARG_EXPR <");
2197       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2198       pp_greater (pp);
2199       break;
2200
2201     case TRY_FINALLY_EXPR:
2202     case TRY_CATCH_EXPR:
2203       pp_string (pp, "try");
2204       newline_and_indent (pp, spc+2);
2205       pp_left_brace (pp);
2206       newline_and_indent (pp, spc+4);
2207       dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true);
2208       newline_and_indent (pp, spc+2);
2209       pp_right_brace (pp);
2210       newline_and_indent (pp, spc);
2211       pp_string (pp,
2212                          (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
2213       newline_and_indent (pp, spc+2);
2214       pp_left_brace (pp);
2215       newline_and_indent (pp, spc+4);
2216       dump_generic_node (pp, TREE_OPERAND (node, 1), spc+4, flags, true);
2217       newline_and_indent (pp, spc+2);
2218       pp_right_brace (pp);
2219       is_expr = false;
2220       break;
2221
2222     case CATCH_EXPR:
2223       pp_string (pp, "catch (");
2224       dump_generic_node (pp, CATCH_TYPES (node), spc+2, flags, false);
2225       pp_right_paren (pp);
2226       newline_and_indent (pp, spc+2);
2227       pp_left_brace (pp);
2228       newline_and_indent (pp, spc+4);
2229       dump_generic_node (pp, CATCH_BODY (node), spc+4, flags, true);
2230       newline_and_indent (pp, spc+2);
2231       pp_right_brace (pp);
2232       is_expr = false;
2233       break;
2234
2235     case EH_FILTER_EXPR:
2236       pp_string (pp, "<<<eh_filter (");
2237       dump_generic_node (pp, EH_FILTER_TYPES (node), spc+2, flags, false);
2238       pp_string (pp, ")>>>");
2239       newline_and_indent (pp, spc+2);
2240       pp_left_brace (pp);
2241       newline_and_indent (pp, spc+4);
2242       dump_generic_node (pp, EH_FILTER_FAILURE (node), spc+4, flags, true);
2243       newline_and_indent (pp, spc+2);
2244       pp_right_brace (pp);
2245       is_expr = false;
2246       break;
2247
2248     case LABEL_EXPR:
2249       op0 = TREE_OPERAND (node, 0);
2250       /* If this is for break or continue, don't bother printing it.  */
2251       if (DECL_NAME (op0))
2252         {
2253           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
2254           if (strcmp (name, "break") == 0
2255               || strcmp (name, "continue") == 0)
2256             break;
2257         }
2258       dump_generic_node (pp, op0, spc, flags, false);
2259       pp_colon (pp);
2260       if (DECL_NONLOCAL (op0))
2261         pp_string (pp, " [non-local]");
2262       break;
2263
2264     case LOOP_EXPR:
2265       pp_string (pp, "while (1)");
2266       if (!(flags & TDF_SLIM))
2267         {
2268           newline_and_indent (pp, spc+2);
2269           pp_left_brace (pp);
2270           newline_and_indent (pp, spc+4);
2271           dump_generic_node (pp, LOOP_EXPR_BODY (node), spc+4, flags, true);
2272           newline_and_indent (pp, spc+2);
2273           pp_right_brace (pp);
2274         }
2275       is_expr = false;
2276       break;
2277
2278     case PREDICT_EXPR:
2279       pp_string (pp, "// predicted ");
2280       if (PREDICT_EXPR_OUTCOME (node))
2281         pp_string (pp, "likely by ");
2282       else
2283         pp_string (pp, "unlikely by ");
2284       pp_string (pp, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
2285       pp_string (pp, " predictor.");
2286       break;
2287
2288     case ANNOTATE_EXPR:
2289       pp_string (pp, "ANNOTATE_EXPR <");
2290       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2291       switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1)))
2292         {
2293         case annot_expr_ivdep_kind:
2294           pp_string (pp, ", ivdep");
2295           break;
2296         case annot_expr_no_vector_kind:
2297           pp_string (pp, ", no-vector");
2298           break;
2299         case annot_expr_vector_kind:
2300           pp_string (pp, ", vector");
2301           break;
2302         default:
2303           gcc_unreachable ();
2304         }
2305       pp_greater (pp);
2306       break;
2307
2308     case RETURN_EXPR:
2309       pp_string (pp, "return");
2310       op0 = TREE_OPERAND (node, 0);
2311       if (op0)
2312         {
2313           pp_space (pp);
2314           if (TREE_CODE (op0) == MODIFY_EXPR)
2315             dump_generic_node (pp, TREE_OPERAND (op0, 1),
2316                                spc, flags, false);
2317           else
2318             dump_generic_node (pp, op0, spc, flags, false);
2319         }
2320       break;
2321
2322     case EXIT_EXPR:
2323       pp_string (pp, "if (");
2324       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2325       pp_string (pp, ") break");
2326       break;
2327
2328     case SWITCH_EXPR:
2329       pp_string (pp, "switch (");
2330       dump_generic_node (pp, SWITCH_COND (node), spc, flags, false);
2331       pp_right_paren (pp);
2332       if (!(flags & TDF_SLIM))
2333         {
2334           newline_and_indent (pp, spc+2);
2335           pp_left_brace (pp);
2336           if (SWITCH_BODY (node))
2337             {
2338               newline_and_indent (pp, spc+4);
2339               dump_generic_node (pp, SWITCH_BODY (node), spc+4, flags,
2340                                  true);
2341             }
2342           else
2343             {
2344               tree vec = SWITCH_LABELS (node);
2345               size_t i, n = TREE_VEC_LENGTH (vec);
2346               for (i = 0; i < n; ++i)
2347                 {
2348                   tree elt = TREE_VEC_ELT (vec, i);
2349                   newline_and_indent (pp, spc+4);
2350                   if (elt)
2351                     {
2352                       dump_generic_node (pp, elt, spc+4, flags, false);
2353                       pp_string (pp, " goto ");
2354                       dump_generic_node (pp, CASE_LABEL (elt), spc+4,
2355                                          flags, true);
2356                       pp_semicolon (pp);
2357                     }
2358                   else
2359                     pp_string (pp, "case ???: goto ???;");
2360                 }
2361             }
2362           newline_and_indent (pp, spc+2);
2363           pp_right_brace (pp);
2364         }
2365       is_expr = false;
2366       break;
2367
2368     case GOTO_EXPR:
2369       op0 = GOTO_DESTINATION (node);
2370       if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
2371         {
2372           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
2373           if (strcmp (name, "break") == 0
2374               || strcmp (name, "continue") == 0)
2375             {
2376               pp_string (pp, name);
2377               break;
2378             }
2379         }
2380       pp_string (pp, "goto ");
2381       dump_generic_node (pp, op0, spc, flags, false);
2382       break;
2383
2384     case ASM_EXPR:
2385       pp_string (pp, "__asm__");
2386       if (ASM_VOLATILE_P (node))
2387         pp_string (pp, " __volatile__");
2388       pp_left_paren (pp);
2389       dump_generic_node (pp, ASM_STRING (node), spc, flags, false);
2390       pp_colon (pp);
2391       dump_generic_node (pp, ASM_OUTPUTS (node), spc, flags, false);
2392       pp_colon (pp);
2393       dump_generic_node (pp, ASM_INPUTS (node), spc, flags, false);
2394       if (ASM_CLOBBERS (node))
2395         {
2396           pp_colon (pp);
2397           dump_generic_node (pp, ASM_CLOBBERS (node), spc, flags, false);
2398         }
2399       pp_right_paren (pp);
2400       break;
2401
2402     case CASE_LABEL_EXPR:
2403       if (CASE_LOW (node) && CASE_HIGH (node))
2404         {
2405           pp_string (pp, "case ");
2406           dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
2407           pp_string (pp, " ... ");
2408           dump_generic_node (pp, CASE_HIGH (node), spc, flags, false);
2409         }
2410       else if (CASE_LOW (node))
2411         {
2412           pp_string (pp, "case ");
2413           dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
2414         }
2415       else
2416         pp_string (pp, "default");
2417       pp_colon (pp);
2418       break;
2419
2420     case OBJ_TYPE_REF:
2421       pp_string (pp, "OBJ_TYPE_REF(");
2422       dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
2423       pp_semicolon (pp);
2424       if (!(flags & TDF_SLIM) && virtual_method_call_p (node))
2425         {
2426           pp_string (pp, "(");
2427           dump_generic_node (pp, obj_type_ref_class (node), spc, flags, false);
2428           pp_string (pp, ")");
2429         }
2430       dump_generic_node (pp, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
2431       pp_arrow (pp);
2432       dump_generic_node (pp, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
2433       pp_right_paren (pp);
2434       break;
2435
2436     case SSA_NAME:
2437       if (SSA_NAME_IDENTIFIER (node))
2438         dump_generic_node (pp, SSA_NAME_IDENTIFIER (node),
2439                            spc, flags, false);
2440       pp_underscore (pp);
2441       pp_decimal_int (pp, SSA_NAME_VERSION (node));
2442       if (SSA_NAME_IS_DEFAULT_DEF (node))
2443         pp_string (pp, "(D)");
2444       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
2445         pp_string (pp, "(ab)");
2446       break;
2447
2448     case WITH_SIZE_EXPR:
2449       pp_string (pp, "WITH_SIZE_EXPR <");
2450       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2451       pp_string (pp, ", ");
2452       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2453       pp_greater (pp);
2454       break;
2455
2456     case ASSERT_EXPR:
2457       pp_string (pp, "ASSERT_EXPR <");
2458       dump_generic_node (pp, ASSERT_EXPR_VAR (node), spc, flags, false);
2459       pp_string (pp, ", ");
2460       dump_generic_node (pp, ASSERT_EXPR_COND (node), spc, flags, false);
2461       pp_greater (pp);
2462       break;
2463
2464     case SCEV_KNOWN:
2465       pp_string (pp, "scev_known");
2466       break;
2467
2468     case SCEV_NOT_KNOWN:
2469       pp_string (pp, "scev_not_known");
2470       break;
2471
2472     case POLYNOMIAL_CHREC:
2473       pp_left_brace (pp);
2474       dump_generic_node (pp, CHREC_LEFT (node), spc, flags, false);
2475       pp_string (pp, ", +, ");
2476       dump_generic_node (pp, CHREC_RIGHT (node), spc, flags, false);
2477       pp_string (pp, "}_");
2478       dump_generic_node (pp, CHREC_VAR (node), spc, flags, false);
2479       is_stmt = false;
2480       break;
2481
2482     case REALIGN_LOAD_EXPR:
2483       pp_string (pp, "REALIGN_LOAD <");
2484       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2485       pp_string (pp, ", ");
2486       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2487       pp_string (pp, ", ");
2488       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2489       pp_greater (pp);
2490       break;
2491
2492     case VEC_COND_EXPR:
2493       pp_string (pp, " VEC_COND_EXPR < ");
2494       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2495       pp_string (pp, " , ");
2496       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2497       pp_string (pp, " , ");
2498       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2499       pp_string (pp, " > ");
2500       break;
2501
2502     case VEC_PERM_EXPR:
2503       pp_string (pp, " VEC_PERM_EXPR < ");
2504       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2505       pp_string (pp, " , ");
2506       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2507       pp_string (pp, " , ");
2508       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2509       pp_string (pp, " > ");
2510       break;
2511
2512     case DOT_PROD_EXPR:
2513       pp_string (pp, " DOT_PROD_EXPR < ");
2514       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2515       pp_string (pp, ", ");
2516       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2517       pp_string (pp, ", ");
2518       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2519       pp_string (pp, " > ");
2520       break;
2521
2522     case WIDEN_MULT_PLUS_EXPR:
2523       pp_string (pp, " WIDEN_MULT_PLUS_EXPR < ");
2524       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2525       pp_string (pp, ", ");
2526       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2527       pp_string (pp, ", ");
2528       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2529       pp_string (pp, " > ");
2530       break;
2531
2532     case WIDEN_MULT_MINUS_EXPR:
2533       pp_string (pp, " WIDEN_MULT_MINUS_EXPR < ");
2534       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2535       pp_string (pp, ", ");
2536       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2537       pp_string (pp, ", ");
2538       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2539       pp_string (pp, " > ");
2540       break;
2541
2542     case FMA_EXPR:
2543       pp_string (pp, " FMA_EXPR < ");
2544       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2545       pp_string (pp, ", ");
2546       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2547       pp_string (pp, ", ");
2548       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2549       pp_string (pp, " > ");
2550       break;
2551
2552     case OACC_PARALLEL:
2553       pp_string (pp, "#pragma acc parallel");
2554       dump_omp_clauses (pp, OACC_PARALLEL_CLAUSES (node), spc, flags);
2555       goto dump_omp_body;
2556
2557     case OACC_KERNELS:
2558       pp_string (pp, "#pragma acc kernels");
2559       dump_omp_clauses (pp, OACC_KERNELS_CLAUSES (node), spc, flags);
2560       goto dump_omp_body;
2561
2562     case OACC_DATA:
2563       pp_string (pp, "#pragma acc data");
2564       dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags);
2565       goto dump_omp_body;
2566
2567     case OACC_HOST_DATA:
2568       pp_string (pp, "#pragma acc host_data");
2569       dump_omp_clauses (pp, OACC_HOST_DATA_CLAUSES (node), spc, flags);
2570       goto dump_omp_body;
2571
2572     case OACC_DECLARE:
2573       pp_string (pp, "#pragma acc declare");
2574       dump_omp_clauses (pp, OACC_DECLARE_CLAUSES (node), spc, flags);
2575       break;
2576
2577     case OACC_UPDATE:
2578       pp_string (pp, "#pragma acc update");
2579       dump_omp_clauses (pp, OACC_UPDATE_CLAUSES (node), spc, flags);
2580       break;
2581
2582     case OACC_ENTER_DATA:
2583       pp_string (pp, "#pragma acc enter data");
2584       dump_omp_clauses (pp, OACC_ENTER_DATA_CLAUSES (node), spc, flags);
2585       break;
2586
2587     case OACC_EXIT_DATA:
2588       pp_string (pp, "#pragma acc exit data");
2589       dump_omp_clauses (pp, OACC_EXIT_DATA_CLAUSES (node), spc, flags);
2590       break;
2591
2592     case OACC_CACHE:
2593       pp_string (pp, "#pragma acc cache");
2594       dump_omp_clauses (pp, OACC_CACHE_CLAUSES (node), spc, flags);
2595       break;
2596
2597     case OMP_PARALLEL:
2598       pp_string (pp, "#pragma omp parallel");
2599       dump_omp_clauses (pp, OMP_PARALLEL_CLAUSES (node), spc, flags);
2600
2601     dump_omp_body:
2602       if (!(flags & TDF_SLIM) && OMP_BODY (node))
2603         {
2604           newline_and_indent (pp, spc + 2);
2605           pp_left_brace (pp);
2606           newline_and_indent (pp, spc + 4);
2607           dump_generic_node (pp, OMP_BODY (node), spc + 4, flags, false);
2608           newline_and_indent (pp, spc + 2);
2609           pp_right_brace (pp);
2610         }
2611       is_expr = false;
2612       break;
2613
2614     case OMP_TASK:
2615       pp_string (pp, "#pragma omp task");
2616       dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags);
2617       goto dump_omp_body;
2618
2619     case OMP_FOR:
2620       pp_string (pp, "#pragma omp for");
2621       goto dump_omp_loop;
2622
2623     case OMP_SIMD:
2624       pp_string (pp, "#pragma omp simd");
2625       goto dump_omp_loop;
2626
2627     case CILK_SIMD:
2628       pp_string (pp, "#pragma simd");
2629       goto dump_omp_loop;
2630
2631     case CILK_FOR:
2632       /* This label points one line after dumping the clauses.
2633          For _Cilk_for the clauses are dumped after the _Cilk_for (...)
2634          parameters are printed out.  */
2635       goto dump_omp_loop_cilk_for;
2636
2637     case OMP_DISTRIBUTE:
2638       pp_string (pp, "#pragma omp distribute");
2639       goto dump_omp_loop;
2640
2641     case OACC_LOOP:
2642       pp_string (pp, "#pragma acc loop");
2643       goto dump_omp_loop;
2644
2645     case OMP_TEAMS:
2646       pp_string (pp, "#pragma omp teams");
2647       dump_omp_clauses (pp, OMP_TEAMS_CLAUSES (node), spc, flags);
2648       goto dump_omp_body;
2649
2650     case OMP_TARGET_DATA:
2651       pp_string (pp, "#pragma omp target data");
2652       dump_omp_clauses (pp, OMP_TARGET_DATA_CLAUSES (node), spc, flags);
2653       goto dump_omp_body;
2654
2655     case OMP_TARGET:
2656       pp_string (pp, "#pragma omp target");
2657       dump_omp_clauses (pp, OMP_TARGET_CLAUSES (node), spc, flags);
2658       goto dump_omp_body;
2659
2660     case OMP_TARGET_UPDATE:
2661       pp_string (pp, "#pragma omp target update");
2662       dump_omp_clauses (pp, OMP_TARGET_UPDATE_CLAUSES (node), spc, flags);
2663       is_expr = false;
2664       break;
2665
2666     dump_omp_loop:
2667       dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
2668
2669     dump_omp_loop_cilk_for:
2670       if (!(flags & TDF_SLIM))
2671         {
2672           int i;
2673
2674           if (OMP_FOR_PRE_BODY (node))
2675             {
2676               if (TREE_CODE (node) == CILK_FOR)
2677                 pp_string (pp, "  ");
2678               else
2679                 newline_and_indent (pp, spc + 2);
2680               pp_left_brace (pp);
2681               spc += 4;
2682               newline_and_indent (pp, spc);
2683               dump_generic_node (pp, OMP_FOR_PRE_BODY (node),
2684                                  spc, flags, false);
2685             }
2686           if (OMP_FOR_INIT (node))
2687             {
2688               spc -= 2;
2689               for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
2690                 {
2691                   spc += 2;
2692                   if (TREE_CODE (node) != CILK_FOR || OMP_FOR_PRE_BODY (node))
2693                     newline_and_indent (pp, spc);
2694                   if (TREE_CODE (node) == CILK_FOR)
2695                     pp_string (pp, "_Cilk_for (");
2696                   else
2697                     pp_string (pp, "for (");
2698                   dump_generic_node (pp,
2699                                      TREE_VEC_ELT (OMP_FOR_INIT (node), i),
2700                                      spc, flags, false);
2701                   pp_string (pp, "; ");
2702                   dump_generic_node (pp,
2703                                      TREE_VEC_ELT (OMP_FOR_COND (node), i),
2704                                      spc, flags, false);
2705                   pp_string (pp, "; ");
2706                   dump_generic_node (pp,
2707                                      TREE_VEC_ELT (OMP_FOR_INCR (node), i),
2708                                      spc, flags, false);
2709                   pp_right_paren (pp);
2710                 }
2711               if (TREE_CODE (node) == CILK_FOR)
2712                 dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
2713             }
2714           if (OMP_FOR_BODY (node))
2715             {
2716               newline_and_indent (pp, spc + 2);
2717               pp_left_brace (pp);
2718               newline_and_indent (pp, spc + 4);
2719               dump_generic_node (pp, OMP_FOR_BODY (node), spc + 4, flags,
2720                   false);
2721               newline_and_indent (pp, spc + 2);
2722               pp_right_brace (pp);
2723             }
2724           if (OMP_FOR_INIT (node))
2725             spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
2726           if (OMP_FOR_PRE_BODY (node))
2727             {
2728               spc -= 4;
2729               newline_and_indent (pp, spc + 2);
2730               pp_right_brace (pp);
2731             }
2732         }
2733       is_expr = false;
2734       break;
2735
2736     case OMP_SECTIONS:
2737       pp_string (pp, "#pragma omp sections");
2738       dump_omp_clauses (pp, OMP_SECTIONS_CLAUSES (node), spc, flags);
2739       goto dump_omp_body;
2740
2741     case OMP_SECTION:
2742       pp_string (pp, "#pragma omp section");
2743       goto dump_omp_body;
2744
2745     case OMP_MASTER:
2746       pp_string (pp, "#pragma omp master");
2747       goto dump_omp_body;
2748
2749     case OMP_TASKGROUP:
2750       pp_string (pp, "#pragma omp taskgroup");
2751       goto dump_omp_body;
2752
2753     case OMP_ORDERED:
2754       pp_string (pp, "#pragma omp ordered");
2755       goto dump_omp_body;
2756
2757     case OMP_CRITICAL:
2758       pp_string (pp, "#pragma omp critical");
2759       if (OMP_CRITICAL_NAME (node))
2760         {
2761           pp_space (pp);
2762           pp_left_paren (pp);
2763           dump_generic_node (pp, OMP_CRITICAL_NAME (node), spc,
2764                              flags, false);
2765           pp_right_paren (pp);
2766         }
2767       goto dump_omp_body;
2768
2769     case OMP_ATOMIC:
2770       pp_string (pp, "#pragma omp atomic");
2771       if (OMP_ATOMIC_SEQ_CST (node))
2772         pp_string (pp, " seq_cst");
2773       newline_and_indent (pp, spc + 2);
2774       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2775       pp_space (pp);
2776       pp_equal (pp);
2777       pp_space (pp);
2778       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2779       break;
2780
2781     case OMP_ATOMIC_READ:
2782       pp_string (pp, "#pragma omp atomic read");
2783       if (OMP_ATOMIC_SEQ_CST (node))
2784         pp_string (pp, " seq_cst");
2785       newline_and_indent (pp, spc + 2);
2786       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2787       pp_space (pp);
2788       break;
2789
2790     case OMP_ATOMIC_CAPTURE_OLD:
2791     case OMP_ATOMIC_CAPTURE_NEW:
2792       pp_string (pp, "#pragma omp atomic capture");
2793       if (OMP_ATOMIC_SEQ_CST (node))
2794         pp_string (pp, " seq_cst");
2795       newline_and_indent (pp, spc + 2);
2796       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2797       pp_space (pp);
2798       pp_equal (pp);
2799       pp_space (pp);
2800       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2801       break;
2802
2803     case OMP_SINGLE:
2804       pp_string (pp, "#pragma omp single");
2805       dump_omp_clauses (pp, OMP_SINGLE_CLAUSES (node), spc, flags);
2806       goto dump_omp_body;
2807
2808     case OMP_CLAUSE:
2809       dump_omp_clause (pp, node, spc, flags);
2810       is_expr = false;
2811       break;
2812
2813     case TRANSACTION_EXPR:
2814       if (TRANSACTION_EXPR_OUTER (node))
2815         pp_string (pp, "__transaction_atomic [[outer]]");
2816       else if (TRANSACTION_EXPR_RELAXED (node))
2817         pp_string (pp, "__transaction_relaxed");
2818       else
2819         pp_string (pp, "__transaction_atomic");
2820       if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
2821         {
2822           newline_and_indent (pp, spc);
2823           pp_left_brace (pp);
2824           newline_and_indent (pp, spc + 2);
2825           dump_generic_node (pp, TRANSACTION_EXPR_BODY (node),
2826                              spc + 2, flags, false);
2827           newline_and_indent (pp, spc);
2828           pp_right_brace (pp);
2829         }
2830       is_expr = false;
2831       break;
2832
2833     case REDUC_MAX_EXPR:
2834       pp_string (pp, " REDUC_MAX_EXPR < ");
2835       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2836       pp_string (pp, " > ");
2837       break;
2838
2839     case REDUC_MIN_EXPR:
2840       pp_string (pp, " REDUC_MIN_EXPR < ");
2841       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2842       pp_string (pp, " > ");
2843       break;
2844
2845     case REDUC_PLUS_EXPR:
2846       pp_string (pp, " REDUC_PLUS_EXPR < ");
2847       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2848       pp_string (pp, " > ");
2849       break;
2850
2851     case VEC_WIDEN_MULT_HI_EXPR:
2852     case VEC_WIDEN_MULT_LO_EXPR:
2853     case VEC_WIDEN_MULT_EVEN_EXPR:
2854     case VEC_WIDEN_MULT_ODD_EXPR:
2855     case VEC_WIDEN_LSHIFT_HI_EXPR:
2856     case VEC_WIDEN_LSHIFT_LO_EXPR:
2857       pp_space (pp);
2858       for (str = get_tree_code_name (code); *str; str++)
2859         pp_character (pp, TOUPPER (*str));
2860       pp_string (pp, " < ");
2861       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2862       pp_string (pp, ", ");
2863       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2864       pp_string (pp, " > ");
2865       break;
2866
2867     case VEC_UNPACK_HI_EXPR:
2868       pp_string (pp, " VEC_UNPACK_HI_EXPR < ");
2869       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2870       pp_string (pp, " > ");
2871       break;
2872
2873     case VEC_UNPACK_LO_EXPR:
2874       pp_string (pp, " VEC_UNPACK_LO_EXPR < ");
2875       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2876       pp_string (pp, " > ");
2877       break;
2878
2879     case VEC_UNPACK_FLOAT_HI_EXPR:
2880       pp_string (pp, " VEC_UNPACK_FLOAT_HI_EXPR < ");
2881       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2882       pp_string (pp, " > ");
2883       break;
2884
2885     case VEC_UNPACK_FLOAT_LO_EXPR:
2886       pp_string (pp, " VEC_UNPACK_FLOAT_LO_EXPR < ");
2887       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2888       pp_string (pp, " > ");
2889       break;
2890
2891     case VEC_PACK_TRUNC_EXPR:
2892       pp_string (pp, " VEC_PACK_TRUNC_EXPR < ");
2893       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2894       pp_string (pp, ", ");
2895       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2896       pp_string (pp, " > ");
2897       break;
2898
2899     case VEC_PACK_SAT_EXPR:
2900       pp_string (pp, " VEC_PACK_SAT_EXPR < ");
2901       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2902       pp_string (pp, ", ");
2903       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2904       pp_string (pp, " > ");
2905       break;
2906
2907     case VEC_PACK_FIX_TRUNC_EXPR:
2908       pp_string (pp, " VEC_PACK_FIX_TRUNC_EXPR < ");
2909       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2910       pp_string (pp, ", ");
2911       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2912       pp_string (pp, " > ");
2913       break;
2914
2915     case BLOCK:
2916       dump_block_node (pp, node, spc, flags);
2917       break;
2918
2919     case CILK_SPAWN_STMT:
2920       pp_string (pp, "_Cilk_spawn ");
2921       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2922       break;
2923
2924     case CILK_SYNC_STMT:
2925       pp_string (pp, "_Cilk_sync");
2926       break;
2927
2928     default:
2929       NIY;
2930     }
2931
2932   if (is_stmt && is_expr)
2933     pp_semicolon (pp);
2934
2935   return spc;
2936 }
2937
2938 /* Print the declaration of a variable.  */
2939
2940 void
2941 print_declaration (pretty_printer *pp, tree t, int spc, int flags)
2942 {
2943   INDENT (spc);
2944
2945   if (TREE_CODE(t) == NAMELIST_DECL)
2946     {
2947       pp_string(pp, "namelist ");
2948       dump_decl_name (pp, t, flags);
2949       pp_semicolon (pp);
2950       return;
2951     }
2952
2953   if (TREE_CODE (t) == TYPE_DECL)
2954     pp_string (pp, "typedef ");
2955
2956   if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2957     pp_string (pp, "register ");
2958
2959   if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2960     pp_string (pp, "extern ");
2961   else if (TREE_STATIC (t))
2962     pp_string (pp, "static ");
2963
2964   /* Print the type and name.  */
2965   if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2966     {
2967       tree tmp;
2968
2969       /* Print array's type.  */
2970       tmp = TREE_TYPE (t);
2971       while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2972         tmp = TREE_TYPE (tmp);
2973       dump_generic_node (pp, TREE_TYPE (tmp), spc, flags, false);
2974
2975       /* Print variable's name.  */
2976       pp_space (pp);
2977       dump_generic_node (pp, t, spc, flags, false);
2978
2979       /* Print the dimensions.  */
2980       tmp = TREE_TYPE (t);
2981       while (TREE_CODE (tmp) == ARRAY_TYPE)
2982         {
2983           dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
2984           tmp = TREE_TYPE (tmp);
2985         }
2986     }
2987   else if (TREE_CODE (t) == FUNCTION_DECL)
2988     {
2989       dump_generic_node (pp, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2990       pp_space (pp);
2991       dump_decl_name (pp, t, flags);
2992       dump_function_declaration (pp, TREE_TYPE (t), spc, flags);
2993     }
2994   else
2995     {
2996       /* Print type declaration.  */
2997       dump_generic_node (pp, TREE_TYPE (t), spc, flags, false);
2998
2999       /* Print variable's name.  */
3000       pp_space (pp);
3001       dump_generic_node (pp, t, spc, flags, false);
3002     }
3003
3004   if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
3005     {
3006       pp_string (pp, " __asm__ ");
3007       pp_left_paren (pp);
3008       dump_generic_node (pp, DECL_ASSEMBLER_NAME (t), spc, flags, false);
3009       pp_right_paren (pp);
3010     }
3011
3012   /* The initial value of a function serves to determine whether the function
3013      is declared or defined.  So the following does not apply to function
3014      nodes.  */
3015   if (TREE_CODE (t) != FUNCTION_DECL)
3016     {
3017       /* Print the initial value.  */
3018       if (DECL_INITIAL (t))
3019         {
3020           pp_space (pp);
3021           pp_equal (pp);
3022           pp_space (pp);
3023           dump_generic_node (pp, DECL_INITIAL (t), spc, flags, false);
3024         }
3025     }
3026
3027   if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
3028     {
3029       pp_string (pp, " [value-expr: ");
3030       dump_generic_node (pp, DECL_VALUE_EXPR (t), spc, flags, false);
3031       pp_right_bracket (pp);
3032     }
3033
3034   pp_semicolon (pp);
3035 }
3036
3037
3038 /* Prints a structure: name, fields, and methods.
3039    FIXME: Still incomplete.  */
3040
3041 static void
3042 print_struct_decl (pretty_printer *pp, const_tree node, int spc, int flags)
3043 {
3044   /* Print the name of the structure.  */
3045   if (TYPE_NAME (node))
3046     {
3047       INDENT (spc);
3048       if (TREE_CODE (node) == RECORD_TYPE)
3049         pp_string (pp, "struct ");
3050       else if ((TREE_CODE (node) == UNION_TYPE
3051                 || TREE_CODE (node) == QUAL_UNION_TYPE))
3052         pp_string (pp, "union ");
3053
3054       dump_generic_node (pp, TYPE_NAME (node), spc, 0, false);
3055     }
3056
3057   /* Print the contents of the structure.  */
3058   pp_newline (pp);
3059   INDENT (spc);
3060   pp_left_brace (pp);
3061   pp_newline (pp);
3062
3063   /* Print the fields of the structure.  */
3064   {
3065     tree tmp;
3066     tmp = TYPE_FIELDS (node);
3067     while (tmp)
3068       {
3069         /* Avoid to print recursively the structure.  */
3070         /* FIXME : Not implemented correctly...,
3071            what about the case when we have a cycle in the contain graph? ...
3072            Maybe this could be solved by looking at the scope in which the
3073            structure was declared.  */
3074         if (TREE_TYPE (tmp) != node
3075             && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
3076                 || TREE_TYPE (TREE_TYPE (tmp)) != node))
3077           {
3078             print_declaration (pp, tmp, spc+2, flags);
3079             pp_newline (pp);
3080           }
3081         tmp = DECL_CHAIN (tmp);
3082       }
3083   }
3084   INDENT (spc);
3085   pp_right_brace (pp);
3086 }
3087
3088 /* Return the priority of the operator CODE.
3089
3090    From lowest to highest precedence with either left-to-right (L-R)
3091    or right-to-left (R-L) associativity]:
3092
3093      1  [L-R] ,
3094      2  [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3095      3  [R-L] ?:
3096      4  [L-R] ||
3097      5  [L-R] &&
3098      6  [L-R] |
3099      7  [L-R] ^
3100      8  [L-R] &
3101      9  [L-R] == !=
3102     10  [L-R] < <= > >=
3103     11  [L-R] << >>
3104     12  [L-R] + -
3105     13  [L-R] * / %
3106     14  [R-L] ! ~ ++ -- + - * & (type) sizeof
3107     15  [L-R] fn() [] -> .
3108
3109    unary +, - and * have higher precedence than the corresponding binary
3110    operators.  */
3111
3112 int
3113 op_code_prio (enum tree_code code)
3114 {
3115   switch (code)
3116     {
3117     case TREE_LIST:
3118     case COMPOUND_EXPR:
3119     case BIND_EXPR:
3120       return 1;
3121
3122     case MODIFY_EXPR:
3123     case INIT_EXPR:
3124       return 2;
3125
3126     case COND_EXPR:
3127       return 3;
3128
3129     case TRUTH_OR_EXPR:
3130     case TRUTH_ORIF_EXPR:
3131       return 4;
3132
3133     case TRUTH_AND_EXPR:
3134     case TRUTH_ANDIF_EXPR:
3135       return 5;
3136
3137     case BIT_IOR_EXPR:
3138       return 6;
3139
3140     case BIT_XOR_EXPR:
3141     case TRUTH_XOR_EXPR:
3142       return 7;
3143
3144     case BIT_AND_EXPR:
3145       return 8;
3146
3147     case EQ_EXPR:
3148     case NE_EXPR:
3149       return 9;
3150
3151     case UNLT_EXPR:
3152     case UNLE_EXPR:
3153     case UNGT_EXPR:
3154     case UNGE_EXPR:
3155     case UNEQ_EXPR:
3156     case LTGT_EXPR:
3157     case ORDERED_EXPR:
3158     case UNORDERED_EXPR:
3159     case LT_EXPR:
3160     case LE_EXPR:
3161     case GT_EXPR:
3162     case GE_EXPR:
3163       return 10;
3164
3165     case LSHIFT_EXPR:
3166     case RSHIFT_EXPR:
3167     case LROTATE_EXPR:
3168     case RROTATE_EXPR:
3169     case VEC_WIDEN_LSHIFT_HI_EXPR:
3170     case VEC_WIDEN_LSHIFT_LO_EXPR:
3171     case WIDEN_LSHIFT_EXPR:
3172       return 11;
3173
3174     case WIDEN_SUM_EXPR:
3175     case PLUS_EXPR:
3176     case POINTER_PLUS_EXPR:
3177     case MINUS_EXPR:
3178       return 12;
3179
3180     case VEC_WIDEN_MULT_HI_EXPR:
3181     case VEC_WIDEN_MULT_LO_EXPR:
3182     case WIDEN_MULT_EXPR:
3183     case DOT_PROD_EXPR:
3184     case WIDEN_MULT_PLUS_EXPR:
3185     case WIDEN_MULT_MINUS_EXPR:
3186     case MULT_EXPR:
3187     case MULT_HIGHPART_EXPR:
3188     case TRUNC_DIV_EXPR:
3189     case CEIL_DIV_EXPR:
3190     case FLOOR_DIV_EXPR:
3191     case ROUND_DIV_EXPR:
3192     case RDIV_EXPR:
3193     case EXACT_DIV_EXPR:
3194     case TRUNC_MOD_EXPR:
3195     case CEIL_MOD_EXPR:
3196     case FLOOR_MOD_EXPR:
3197     case ROUND_MOD_EXPR:
3198     case FMA_EXPR:
3199       return 13;
3200
3201     case TRUTH_NOT_EXPR:
3202     case BIT_NOT_EXPR:
3203     case POSTINCREMENT_EXPR:
3204     case POSTDECREMENT_EXPR:
3205     case PREINCREMENT_EXPR:
3206     case PREDECREMENT_EXPR:
3207     case NEGATE_EXPR:
3208     case INDIRECT_REF:
3209     case ADDR_EXPR:
3210     case FLOAT_EXPR:
3211     CASE_CONVERT:
3212     case FIX_TRUNC_EXPR:
3213     case TARGET_EXPR:
3214       return 14;
3215
3216     case CALL_EXPR:
3217     case ARRAY_REF:
3218     case ARRAY_RANGE_REF:
3219     case COMPONENT_REF:
3220       return 15;
3221
3222       /* Special expressions.  */
3223     case MIN_EXPR:
3224     case MAX_EXPR:
3225     case ABS_EXPR:
3226     case REALPART_EXPR:
3227     case IMAGPART_EXPR:
3228     case REDUC_MAX_EXPR:
3229     case REDUC_MIN_EXPR:
3230     case REDUC_PLUS_EXPR:
3231     case VEC_UNPACK_HI_EXPR:
3232     case VEC_UNPACK_LO_EXPR:
3233     case VEC_UNPACK_FLOAT_HI_EXPR:
3234     case VEC_UNPACK_FLOAT_LO_EXPR:
3235     case VEC_PACK_TRUNC_EXPR:
3236     case VEC_PACK_SAT_EXPR:
3237       return 16;
3238
3239     default:
3240       /* Return an arbitrarily high precedence to avoid surrounding single
3241          VAR_DECLs in ()s.  */
3242       return 9999;
3243     }
3244 }
3245
3246 /* Return the priority of the operator OP.  */
3247
3248 int
3249 op_prio (const_tree op)
3250 {
3251   enum tree_code code;
3252
3253   if (op == NULL)
3254     return 9999;
3255
3256   code = TREE_CODE (op);
3257   if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
3258     return op_prio (TREE_OPERAND (op, 0));
3259
3260   return op_code_prio (code);
3261 }
3262
3263 /* Return the symbol associated with operator CODE.  */
3264
3265 const char *
3266 op_symbol_code (enum tree_code code)
3267 {
3268   switch (code)
3269     {
3270     case MODIFY_EXPR:
3271       return "=";
3272
3273     case TRUTH_OR_EXPR:
3274     case TRUTH_ORIF_EXPR:
3275       return "||";
3276
3277     case TRUTH_AND_EXPR:
3278     case TRUTH_ANDIF_EXPR:
3279       return "&&";
3280
3281     case BIT_IOR_EXPR:
3282       return "|";
3283
3284     case TRUTH_XOR_EXPR:
3285     case BIT_XOR_EXPR:
3286       return "^";
3287
3288     case ADDR_EXPR:
3289     case BIT_AND_EXPR:
3290       return "&";
3291
3292     case ORDERED_EXPR:
3293       return "ord";
3294     case UNORDERED_EXPR:
3295       return "unord";
3296
3297     case EQ_EXPR:
3298       return "==";
3299     case UNEQ_EXPR:
3300       return "u==";
3301
3302     case NE_EXPR:
3303       return "!=";
3304
3305     case LT_EXPR:
3306       return "<";
3307     case UNLT_EXPR:
3308       return "u<";
3309
3310     case LE_EXPR:
3311       return "<=";
3312     case UNLE_EXPR:
3313       return "u<=";
3314
3315     case GT_EXPR:
3316       return ">";
3317     case UNGT_EXPR:
3318       return "u>";
3319
3320     case GE_EXPR:
3321       return ">=";
3322     case UNGE_EXPR:
3323       return "u>=";
3324
3325     case LTGT_EXPR:
3326       return "<>";
3327
3328     case LSHIFT_EXPR:
3329       return "<<";
3330
3331     case RSHIFT_EXPR:
3332       return ">>";
3333
3334     case LROTATE_EXPR:
3335       return "r<<";
3336
3337     case RROTATE_EXPR:
3338       return "r>>";
3339
3340     case WIDEN_LSHIFT_EXPR:
3341       return "w<<";
3342
3343     case POINTER_PLUS_EXPR:
3344       return "+";
3345
3346     case PLUS_EXPR:
3347       return "+";
3348
3349     case REDUC_PLUS_EXPR:
3350       return "r+";
3351
3352     case WIDEN_SUM_EXPR:
3353       return "w+";
3354
3355     case WIDEN_MULT_EXPR:
3356       return "w*";
3357
3358     case MULT_HIGHPART_EXPR:
3359       return "h*";
3360
3361     case NEGATE_EXPR:
3362     case MINUS_EXPR:
3363       return "-";
3364
3365     case BIT_NOT_EXPR:
3366       return "~";
3367
3368     case TRUTH_NOT_EXPR:
3369       return "!";
3370
3371     case MULT_EXPR:
3372     case INDIRECT_REF:
3373       return "*";
3374
3375     case TRUNC_DIV_EXPR:
3376     case RDIV_EXPR:
3377       return "/";
3378
3379     case CEIL_DIV_EXPR:
3380       return "/[cl]";
3381
3382     case FLOOR_DIV_EXPR:
3383       return "/[fl]";
3384
3385     case ROUND_DIV_EXPR:
3386       return "/[rd]";
3387
3388     case EXACT_DIV_EXPR:
3389       return "/[ex]";
3390
3391     case TRUNC_MOD_EXPR:
3392       return "%";
3393
3394     case CEIL_MOD_EXPR:
3395       return "%[cl]";
3396
3397     case FLOOR_MOD_EXPR:
3398       return "%[fl]";
3399
3400     case ROUND_MOD_EXPR:
3401       return "%[rd]";
3402
3403     case PREDECREMENT_EXPR:
3404       return " --";
3405
3406     case PREINCREMENT_EXPR:
3407       return " ++";
3408
3409     case POSTDECREMENT_EXPR:
3410       return "-- ";
3411
3412     case POSTINCREMENT_EXPR:
3413       return "++ ";
3414
3415     case MAX_EXPR:
3416       return "max";
3417
3418     case MIN_EXPR:
3419       return "min";
3420
3421     default:
3422       return "<<< ??? >>>";
3423     }
3424 }
3425
3426 /* Return the symbol associated with operator OP.  */
3427
3428 static const char *
3429 op_symbol (const_tree op)
3430 {
3431   return op_symbol_code (TREE_CODE (op));
3432 }
3433
3434 /* Prints the name of a call.  NODE is the CALL_EXPR_FN of a CALL_EXPR or
3435    the gimple_call_fn of a GIMPLE_CALL.  */
3436
3437 void
3438 print_call_name (pretty_printer *pp, tree node, int flags)
3439 {
3440   tree op0 = node;
3441
3442   if (TREE_CODE (op0) == NON_LVALUE_EXPR)
3443     op0 = TREE_OPERAND (op0, 0);
3444
3445  again:
3446   switch (TREE_CODE (op0))
3447     {
3448     case VAR_DECL:
3449     case PARM_DECL:
3450     case FUNCTION_DECL:
3451       dump_function_name (pp, op0, flags);
3452       break;
3453
3454     case ADDR_EXPR:
3455     case INDIRECT_REF:
3456     CASE_CONVERT:
3457       op0 = TREE_OPERAND (op0, 0);
3458       goto again;
3459
3460     case COND_EXPR:
3461       pp_left_paren (pp);
3462       dump_generic_node (pp, TREE_OPERAND (op0, 0), 0, flags, false);
3463       pp_string (pp, ") ? ");
3464       dump_generic_node (pp, TREE_OPERAND (op0, 1), 0, flags, false);
3465       pp_string (pp, " : ");
3466       dump_generic_node (pp, TREE_OPERAND (op0, 2), 0, flags, false);
3467       break;
3468
3469     case ARRAY_REF:
3470       if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
3471         dump_function_name (pp, TREE_OPERAND (op0, 0), flags);
3472       else
3473         dump_generic_node (pp, op0, 0, flags, false);
3474       break;
3475
3476     case MEM_REF:
3477       if (integer_zerop (TREE_OPERAND (op0, 1)))
3478         {
3479           op0 = TREE_OPERAND (op0, 0);
3480           goto again;
3481         }
3482       /* Fallthru.  */
3483     case COMPONENT_REF:
3484     case SSA_NAME:
3485     case OBJ_TYPE_REF:
3486       dump_generic_node (pp, op0, 0, flags, false);
3487       break;
3488
3489     default:
3490       NIY;
3491     }
3492 }
3493
3494 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ...  */
3495
3496 static void
3497 pretty_print_string (pretty_printer *pp, const char *str)
3498 {
3499   if (str == NULL)
3500     return;
3501
3502   while (*str)
3503     {
3504       switch (str[0])
3505         {
3506         case '\b':
3507           pp_string (pp, "\\b");
3508           break;
3509
3510         case '\f':
3511           pp_string (pp, "\\f");
3512           break;
3513
3514         case '\n':
3515           pp_string (pp, "\\n");
3516           break;
3517
3518         case '\r':
3519           pp_string (pp, "\\r");
3520           break;
3521
3522         case '\t':
3523           pp_string (pp, "\\t");
3524           break;
3525
3526         case '\v':
3527           pp_string (pp, "\\v");
3528           break;
3529
3530         case '\\':
3531           pp_string (pp, "\\\\");
3532           break;
3533
3534         case '\"':
3535           pp_string (pp, "\\\"");
3536           break;
3537
3538         case '\'':
3539           pp_string (pp, "\\'");
3540           break;
3541
3542           /* No need to handle \0; the loop terminates on \0.  */
3543
3544         case '\1':
3545           pp_string (pp, "\\1");
3546           break;
3547
3548         case '\2':
3549           pp_string (pp, "\\2");
3550           break;
3551
3552         case '\3':
3553           pp_string (pp, "\\3");
3554           break;
3555
3556         case '\4':
3557           pp_string (pp, "\\4");
3558           break;
3559
3560         case '\5':
3561           pp_string (pp, "\\5");
3562           break;
3563
3564         case '\6':
3565           pp_string (pp, "\\6");
3566           break;
3567
3568         case '\7':
3569           pp_string (pp, "\\7");
3570           break;
3571
3572         default:
3573           pp_character (pp, str[0]);
3574           break;
3575         }
3576       str++;
3577     }
3578 }
3579
3580 static void
3581 maybe_init_pretty_print (FILE *file)
3582 {
3583   if (!tree_pp)
3584     {
3585       tree_pp = new pretty_printer ();
3586       pp_needs_newline (tree_pp) = true;
3587       pp_translate_identifiers (tree_pp) = false;
3588     }
3589
3590   tree_pp->buffer->stream = file;
3591 }
3592
3593 static void
3594 newline_and_indent (pretty_printer *pp, int spc)
3595 {
3596   pp_newline (pp);
3597   INDENT (spc);
3598 }
3599
3600 /* Handle a %K format for TEXT.  Separate from default_tree_printer so
3601    it can also be used in front ends.
3602    %K: a statement, from which EXPR_LOCATION and TREE_BLOCK will be recorded.
3603 */
3604
3605 void
3606 percent_K_format (text_info *text)
3607 {
3608   tree t = va_arg (*text->args_ptr, tree), block;
3609   gcc_assert (text->locus != NULL);
3610   *text->locus = EXPR_LOCATION (t);
3611   gcc_assert (pp_ti_abstract_origin (text) != NULL);
3612   block = TREE_BLOCK (t);
3613   *pp_ti_abstract_origin (text) = NULL;
3614
3615   if (in_lto_p)
3616     {
3617       /* ???  LTO drops all BLOCK_ABSTRACT_ORIGINs apart from those
3618          representing the outermost block of an inlined function.
3619          So walk the BLOCK tree until we hit such a scope.  */
3620       while (block
3621              && TREE_CODE (block) == BLOCK)
3622         {
3623           if (inlined_function_outer_scope_p (block))
3624             {
3625               *pp_ti_abstract_origin (text) = block;
3626               break;
3627             }
3628           block = BLOCK_SUPERCONTEXT (block);
3629         }
3630       return;
3631     }
3632
3633   while (block
3634          && TREE_CODE (block) == BLOCK
3635          && BLOCK_ABSTRACT_ORIGIN (block))
3636     {
3637       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
3638
3639       while (TREE_CODE (ao) == BLOCK
3640              && BLOCK_ABSTRACT_ORIGIN (ao)
3641              && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
3642         ao = BLOCK_ABSTRACT_ORIGIN (ao);
3643
3644       if (TREE_CODE (ao) == FUNCTION_DECL)
3645         {
3646           *pp_ti_abstract_origin (text) = block;
3647           break;
3648         }
3649       block = BLOCK_SUPERCONTEXT (block);
3650     }
3651 }
3652
3653 /* Print the identifier ID to PRETTY-PRINTER.  */
3654
3655 void
3656 pp_tree_identifier (pretty_printer *pp, tree id)
3657 {
3658   if (pp_translate_identifiers (pp))
3659     {
3660       const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
3661       pp_append_text (pp, text, text + strlen (text));
3662     }
3663   else
3664     pp_append_text (pp, IDENTIFIER_POINTER (id),
3665                     IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
3666 }
3667
3668 /* A helper function that is used to dump function information before the
3669    function dump.  */
3670
3671 void
3672 dump_function_header (FILE *dump_file, tree fdecl, int flags)
3673 {
3674   const char *dname, *aname;
3675   struct cgraph_node *node = cgraph_node::get (fdecl);
3676   struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
3677
3678   dname = lang_hooks.decl_printable_name (fdecl, 2);
3679
3680   if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
3681     aname = (IDENTIFIER_POINTER
3682              (DECL_ASSEMBLER_NAME (fdecl)));
3683   else
3684     aname = "<unset-asm-name>";
3685
3686   fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
3687            dname, aname, fun->funcdef_no);
3688   if (!(flags & TDF_NOUID))
3689     fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
3690   if (node)
3691     {
3692       fprintf (dump_file, ", cgraph_uid=%d", node->uid);
3693       fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->order,
3694                node->frequency == NODE_FREQUENCY_HOT
3695                ? " (hot)"
3696                : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
3697                ? " (unlikely executed)"
3698                : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
3699                ? " (executed once)"
3700                : "");
3701     }
3702   else
3703     fprintf (dump_file, ")\n\n");
3704 }
3705
3706 /* Dump double_int D to pretty_printer PP.  UNS is true
3707    if D is unsigned and false otherwise.  */
3708 void
3709 pp_double_int (pretty_printer *pp, double_int d, bool uns)
3710 {
3711   if (d.fits_shwi ())
3712     pp_wide_integer (pp, d.low);
3713   else if (d.fits_uhwi ())
3714     pp_unsigned_wide_integer (pp, d.low);
3715   else
3716     {
3717       unsigned HOST_WIDE_INT low = d.low;
3718       HOST_WIDE_INT high = d.high;
3719       if (!uns && d.is_negative ())
3720         {
3721           pp_minus (pp);
3722           high = ~high + !low;
3723           low = -low;
3724         }
3725       /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
3726          systems?  */
3727       sprintf (pp_buffer (pp)->digit_buffer,
3728                HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3729                (unsigned HOST_WIDE_INT) high, low);
3730       pp_string (pp, pp_buffer (pp)->digit_buffer);
3731     }
3732 }