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