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