gcc/tree-pretty-print.c

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