gcc/tree-pretty-print.c

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