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 /* Helper function for dump_generic_node.  Dump INIT or COND expression for
1574    OpenMP loop non-rectangular iterators.  */
1575
1576 void
1577 dump_omp_loop_non_rect_expr (pretty_printer *pp, tree node, int spc,
1578                              dump_flags_t flags)
1579 {
1580   gcc_assert (TREE_CODE (node) == TREE_VEC);
1581   dump_generic_node (pp, TREE_VEC_ELT (node, 0), spc, flags, false);
1582   pp_string (pp, " * ");
1583   if (op_prio (TREE_VEC_ELT (node, 1)) <= op_code_prio (MULT_EXPR))
1584     {
1585       pp_left_paren (pp);
1586       dump_generic_node (pp, TREE_VEC_ELT (node, 1), spc, flags, false);
1587       pp_right_paren (pp);
1588     }
1589   else
1590     dump_generic_node (pp, TREE_VEC_ELT (node, 1), spc, flags, false);
1591   pp_string (pp, " + ");
1592   if (op_prio (TREE_VEC_ELT (node, 1)) <= op_code_prio (PLUS_EXPR))
1593     {
1594       pp_left_paren (pp);
1595       dump_generic_node (pp, TREE_VEC_ELT (node, 2), spc, flags, false);
1596       pp_right_paren (pp);
1597     }
1598   else
1599     dump_generic_node (pp, TREE_VEC_ELT (node, 2), spc, flags, false);
1600 }
1601
1602 /* Dump the node NODE on the pretty_printer PP, SPC spaces of
1603    indent.  FLAGS specifies details to show in the dump (see TDF_* in
1604    dumpfile.h).  If IS_STMT is true, the object printed is considered
1605    to be a statement and it is terminated by ';' if appropriate.  */
1606
1607 int
1608 dump_generic_node (pretty_printer *pp, tree node, int spc, dump_flags_t flags,
1609                    bool is_stmt)
1610 {
1611   tree type;
1612   tree op0, op1;
1613   const char *str;
1614   bool is_expr;
1615   enum tree_code code;
1616
1617   if (node == NULL_TREE)
1618     return spc;
1619
1620   is_expr = EXPR_P (node);
1621
1622   if (is_stmt && (flags & TDF_STMTADDR))
1623     pp_printf (pp, "<&%p> ", (void *)node);
1624
1625   if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
1626     dump_location (pp, EXPR_LOCATION (node));
1627
1628   code = TREE_CODE (node);
1629   switch (code)
1630     {
1631     case ERROR_MARK:
1632       pp_string (pp, "<<< error >>>");
1633       break;
1634
1635     case IDENTIFIER_NODE:
1636       pp_tree_identifier (pp, node);
1637       break;
1638
1639     case TREE_LIST:
1640       while (node && node != error_mark_node)
1641         {
1642           if (TREE_PURPOSE (node))
1643             {
1644               dump_generic_node (pp, TREE_PURPOSE (node), spc, flags, false);
1645               pp_space (pp);
1646             }
1647           dump_generic_node (pp, TREE_VALUE (node), spc, flags, false);
1648           node = TREE_CHAIN (node);
1649           if (node && TREE_CODE (node) == TREE_LIST)
1650             {
1651               pp_comma (pp);
1652               pp_space (pp);
1653             }
1654         }
1655       break;
1656
1657     case TREE_BINFO:
1658       dump_generic_node (pp, BINFO_TYPE (node), spc, flags, false);
1659       break;
1660
1661     case TREE_VEC:
1662       {
1663         size_t i;
1664         if (TREE_VEC_LENGTH (node) > 0)
1665           {
1666             size_t len = TREE_VEC_LENGTH (node);
1667             for (i = 0; i < len - 1; i++)
1668               {
1669                 dump_generic_node (pp, TREE_VEC_ELT (node, i), spc, flags,
1670                                    false);
1671                 pp_comma (pp);
1672                 pp_space (pp);
1673               }
1674             dump_generic_node (pp, TREE_VEC_ELT (node, len - 1), spc,
1675                                flags, false);
1676           }
1677       }
1678       break;
1679
1680     case VOID_TYPE:
1681     case INTEGER_TYPE:
1682     case REAL_TYPE:
1683     case FIXED_POINT_TYPE:
1684     case COMPLEX_TYPE:
1685     case VECTOR_TYPE:
1686     case ENUMERAL_TYPE:
1687     case BOOLEAN_TYPE:
1688       {
1689         unsigned int quals = TYPE_QUALS (node);
1690         enum tree_code_class tclass;
1691
1692         if (quals & TYPE_QUAL_ATOMIC)
1693           pp_string (pp, "atomic ");
1694         if (quals & TYPE_QUAL_CONST)
1695           pp_string (pp, "const ");
1696         else if (quals & TYPE_QUAL_VOLATILE)
1697           pp_string (pp, "volatile ");
1698         else if (quals & TYPE_QUAL_RESTRICT)
1699           pp_string (pp, "restrict ");
1700
1701         if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
1702           {
1703             pp_string (pp, "<address-space-");
1704             pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
1705             pp_string (pp, "> ");
1706           }
1707
1708         tclass = TREE_CODE_CLASS (TREE_CODE (node));
1709
1710         if (tclass == tcc_declaration)
1711           {
1712             if (DECL_NAME (node))
1713               dump_decl_name (pp, node, flags);
1714             else
1715               pp_string (pp, "<unnamed type decl>");
1716           }
1717         else if (tclass == tcc_type)
1718           {
1719             if (TYPE_NAME (node))
1720               {
1721                 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
1722                   pp_tree_identifier (pp, TYPE_NAME (node));
1723                 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
1724                          && DECL_NAME (TYPE_NAME (node)))
1725                   dump_decl_name (pp, TYPE_NAME (node), flags);
1726                 else
1727                   pp_string (pp, "<unnamed type>");
1728               }
1729             else if (TREE_CODE (node) == VECTOR_TYPE)
1730               {
1731                 pp_string (pp, "vector");
1732                 pp_left_paren (pp);
1733                 pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (node));
1734                 pp_string (pp, ") ");
1735                 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1736               }
1737             else if (TREE_CODE (node) == INTEGER_TYPE)
1738               {
1739                 if (TYPE_PRECISION (node) == CHAR_TYPE_SIZE)
1740                   pp_string (pp, (TYPE_UNSIGNED (node)
1741                                       ? "unsigned char"
1742                                       : "signed char"));
1743                 else if (TYPE_PRECISION (node) == SHORT_TYPE_SIZE)
1744                   pp_string (pp, (TYPE_UNSIGNED (node)
1745                                       ? "unsigned short"
1746                                       : "signed short"));
1747                 else if (TYPE_PRECISION (node) == INT_TYPE_SIZE)
1748                   pp_string (pp, (TYPE_UNSIGNED (node)
1749                                       ? "unsigned int"
1750                                       : "signed int"));
1751                 else if (TYPE_PRECISION (node) == LONG_TYPE_SIZE)
1752                   pp_string (pp, (TYPE_UNSIGNED (node)
1753                                       ? "unsigned long"
1754                                       : "signed long"));
1755                 else if (TYPE_PRECISION (node) == LONG_LONG_TYPE_SIZE)
1756                   pp_string (pp, (TYPE_UNSIGNED (node)
1757                                       ? "unsigned long long"
1758                                       : "signed long long"));
1759                 else if (TYPE_PRECISION (node) >= CHAR_TYPE_SIZE
1760                          && pow2p_hwi (TYPE_PRECISION (node)))
1761                   {
1762                     pp_string (pp, (TYPE_UNSIGNED (node) ? "uint" : "int"));
1763                     pp_decimal_int (pp, TYPE_PRECISION (node));
1764                     pp_string (pp, "_t");
1765                   }
1766                 else
1767                   {
1768                     pp_string (pp, (TYPE_UNSIGNED (node)
1769                                         ? "<unnamed-unsigned:"
1770                                         : "<unnamed-signed:"));
1771                     pp_decimal_int (pp, TYPE_PRECISION (node));
1772                     pp_greater (pp);
1773                   }
1774               }
1775             else if (TREE_CODE (node) == COMPLEX_TYPE)
1776               {
1777                 pp_string (pp, "__complex__ ");
1778                 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1779               }
1780             else if (TREE_CODE (node) == REAL_TYPE)
1781               {
1782                 pp_string (pp, "<float:");
1783                 pp_decimal_int (pp, TYPE_PRECISION (node));
1784                 pp_greater (pp);
1785               }
1786             else if (TREE_CODE (node) == FIXED_POINT_TYPE)
1787               {
1788                 pp_string (pp, "<fixed-point-");
1789                 pp_string (pp, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
1790                 pp_decimal_int (pp, TYPE_PRECISION (node));
1791                 pp_greater (pp);
1792               }
1793             else if (TREE_CODE (node) == BOOLEAN_TYPE)
1794               {
1795                 pp_string (pp, (TYPE_UNSIGNED (node)
1796                                 ? "<unsigned-boolean:"
1797                                 : "<signed-boolean:"));
1798                 pp_decimal_int (pp, TYPE_PRECISION (node));
1799                 pp_greater (pp);
1800               }
1801             else if (TREE_CODE (node) == VOID_TYPE)
1802               pp_string (pp, "void");
1803             else
1804               pp_string (pp, "<unnamed type>");
1805           }
1806         break;
1807       }
1808
1809     case POINTER_TYPE:
1810     case REFERENCE_TYPE:
1811       str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
1812
1813       if (TREE_TYPE (node) == NULL)
1814         {
1815           pp_string (pp, str);
1816           pp_string (pp, "<null type>");
1817         }
1818       else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
1819         {
1820           tree fnode = TREE_TYPE (node);
1821
1822           dump_generic_node (pp, TREE_TYPE (fnode), spc, flags, false);
1823           pp_space (pp);
1824           pp_left_paren (pp);
1825           pp_string (pp, str);
1826           if (TYPE_IDENTIFIER (node))
1827             dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
1828           else if (flags & TDF_NOUID)
1829             pp_printf (pp, "<Txxxx>");
1830           else
1831             pp_printf (pp, "<T%x>", TYPE_UID (node));
1832
1833           pp_right_paren (pp);
1834           dump_function_declaration (pp, fnode, spc, flags);
1835         }
1836       else
1837         {
1838           unsigned int quals = TYPE_QUALS (node);
1839
1840           dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1841           pp_space (pp);
1842           pp_string (pp, str);
1843
1844           if (quals & TYPE_QUAL_CONST)
1845             pp_string (pp, " const");
1846           if (quals & TYPE_QUAL_VOLATILE)
1847             pp_string (pp, " volatile");
1848           if (quals & TYPE_QUAL_RESTRICT)
1849             pp_string (pp, " restrict");
1850
1851           if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
1852             {
1853               pp_string (pp, " <address-space-");
1854               pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
1855               pp_greater (pp);
1856             }
1857
1858           if (TYPE_REF_CAN_ALIAS_ALL (node))
1859             pp_string (pp, " {ref-all}");
1860         }
1861       break;
1862
1863     case OFFSET_TYPE:
1864       NIY;
1865       break;
1866
1867     case MEM_REF:
1868       dump_mem_ref (pp, node, spc, flags);
1869       break;
1870
1871     case TARGET_MEM_REF:
1872       {
1873         const char *sep = "";
1874         tree tmp;
1875
1876         pp_string (pp, "MEM[");
1877
1878         if (TREE_CODE (TMR_BASE (node)) == ADDR_EXPR)
1879           {
1880             pp_string (pp, sep);
1881             sep = ", ";
1882             pp_string (pp, "symbol: ");
1883             dump_generic_node (pp, TREE_OPERAND (TMR_BASE (node), 0),
1884                                spc, flags, false);
1885           }
1886         else
1887           {
1888             pp_string (pp, sep);
1889             sep = ", ";
1890             pp_string (pp, "base: ");
1891             dump_generic_node (pp, TMR_BASE (node), spc, flags, false);
1892           }
1893         tmp = TMR_INDEX2 (node);
1894         if (tmp)
1895           {
1896             pp_string (pp, sep);
1897             sep = ", ";
1898             pp_string (pp, "base: ");
1899             dump_generic_node (pp, tmp, spc, flags, false);
1900           }
1901         tmp = TMR_INDEX (node);
1902         if (tmp)
1903           {
1904             pp_string (pp, sep);
1905             sep = ", ";
1906             pp_string (pp, "index: ");
1907             dump_generic_node (pp, tmp, spc, flags, false);
1908           }
1909         tmp = TMR_STEP (node);
1910         if (tmp)
1911           {
1912             pp_string (pp, sep);
1913             sep = ", ";
1914             pp_string (pp, "step: ");
1915             dump_generic_node (pp, tmp, spc, flags, false);
1916           }
1917         tmp = TMR_OFFSET (node);
1918         if (tmp)
1919           {
1920             pp_string (pp, sep);
1921             sep = ", ";
1922             pp_string (pp, "offset: ");
1923             dump_generic_node (pp, tmp, spc, flags, false);
1924           }
1925         pp_right_bracket (pp);
1926       }
1927       break;
1928
1929     case ARRAY_TYPE:
1930       {
1931         unsigned int quals = TYPE_QUALS (node);
1932         tree tmp;
1933
1934         if (quals & TYPE_QUAL_ATOMIC)
1935           pp_string (pp, "atomic ");
1936         if (quals & TYPE_QUAL_CONST)
1937           pp_string (pp, "const ");
1938         if (quals & TYPE_QUAL_VOLATILE)
1939           pp_string (pp, "volatile ");
1940
1941         /* Print the innermost component type.  */
1942         for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
1943              tmp = TREE_TYPE (tmp))
1944           ;
1945         dump_generic_node (pp, tmp, spc, flags, false);
1946
1947         /* Print the dimensions.  */
1948         for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
1949           dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
1950         break;
1951       }
1952
1953     case RECORD_TYPE:
1954     case UNION_TYPE:
1955     case QUAL_UNION_TYPE:
1956       {
1957         unsigned int quals = TYPE_QUALS (node);
1958
1959         if (quals & TYPE_QUAL_ATOMIC)
1960           pp_string (pp, "atomic ");
1961         if (quals & TYPE_QUAL_CONST)
1962           pp_string (pp, "const ");
1963         if (quals & TYPE_QUAL_VOLATILE)
1964           pp_string (pp, "volatile ");
1965
1966         /* Print the name of the structure.  */
1967         if (TREE_CODE (node) == RECORD_TYPE)
1968           pp_string (pp, "struct ");
1969         else if (TREE_CODE (node) == UNION_TYPE)
1970           pp_string (pp, "union ");
1971
1972         if (TYPE_NAME (node))
1973           dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
1974         else if (!(flags & TDF_SLIM))
1975           /* FIXME: If we eliminate the 'else' above and attempt
1976              to show the fields for named types, we may get stuck
1977              following a cycle of pointers to structs.  The alleged
1978              self-reference check in print_struct_decl will not detect
1979              cycles involving more than one pointer or struct type.  */
1980           print_struct_decl (pp, node, spc, flags);
1981         break;
1982       }
1983
1984     case LANG_TYPE:
1985       NIY;
1986       break;
1987
1988     case INTEGER_CST:
1989       if (flags & TDF_GIMPLE
1990           && (POINTER_TYPE_P (TREE_TYPE (node))
1991               || (TYPE_PRECISION (TREE_TYPE (node))
1992                   < TYPE_PRECISION (integer_type_node))
1993               || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1
1994               || tree_int_cst_sgn (node) < 0))
1995         {
1996           pp_string (pp, "_Literal (");
1997           dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
1998           pp_string (pp, ") ");
1999         }
2000       if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE
2001           && ! (flags & TDF_GIMPLE))
2002         {
2003           /* In the case of a pointer, one may want to divide by the
2004              size of the pointed-to type.  Unfortunately, this not
2005              straightforward.  The C front-end maps expressions
2006
2007              (int *) 5
2008              int *p; (p + 5)
2009
2010              in such a way that the two INTEGER_CST nodes for "5" have
2011              different values but identical types.  In the latter
2012              case, the 5 is multiplied by sizeof (int) in c-common.c
2013              (pointer_int_sum) to convert it to a byte address, and
2014              yet the type of the node is left unchanged.  Argh.  What
2015              is consistent though is that the number value corresponds
2016              to bytes (UNITS) offset.
2017
2018              NB: Neither of the following divisors can be trivially
2019              used to recover the original literal:
2020
2021              TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
2022              TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node)))  */
2023           pp_wide_integer (pp, TREE_INT_CST_LOW (node));
2024           pp_string (pp, "B"); /* pseudo-unit */
2025         }
2026       else if (tree_fits_shwi_p (node))
2027         pp_wide_integer (pp, tree_to_shwi (node));
2028       else if (tree_fits_uhwi_p (node))
2029         pp_unsigned_wide_integer (pp, tree_to_uhwi (node));
2030       else
2031         {
2032           wide_int val = wi::to_wide (node);
2033
2034           if (wi::neg_p (val, TYPE_SIGN (TREE_TYPE (node))))
2035             {
2036               pp_minus (pp);
2037               val = -val;
2038             }
2039           print_hex (val, pp_buffer (pp)->digit_buffer);
2040           pp_string (pp, pp_buffer (pp)->digit_buffer);
2041         }
2042       if ((flags & TDF_GIMPLE)
2043           && ! (POINTER_TYPE_P (TREE_TYPE (node))
2044                 || (TYPE_PRECISION (TREE_TYPE (node))
2045                     < TYPE_PRECISION (integer_type_node))
2046                 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1))
2047         {
2048           if (TYPE_UNSIGNED (TREE_TYPE (node)))
2049             pp_character (pp, 'u');
2050           if (TYPE_PRECISION (TREE_TYPE (node))
2051               == TYPE_PRECISION (unsigned_type_node))
2052             ;
2053           else if (TYPE_PRECISION (TREE_TYPE (node))
2054                    == TYPE_PRECISION (long_unsigned_type_node))
2055             pp_character (pp, 'l');
2056           else if (TYPE_PRECISION (TREE_TYPE (node))
2057                    == TYPE_PRECISION (long_long_unsigned_type_node))
2058             pp_string (pp, "ll");
2059         }
2060       if (TREE_OVERFLOW (node))
2061         pp_string (pp, "(OVF)");
2062       break;
2063
2064     case POLY_INT_CST:
2065       pp_string (pp, "POLY_INT_CST [");
2066       dump_generic_node (pp, POLY_INT_CST_COEFF (node, 0), spc, flags, false);
2067       for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
2068         {
2069           pp_string (pp, ", ");
2070           dump_generic_node (pp, POLY_INT_CST_COEFF (node, i),
2071                              spc, flags, false);
2072         }
2073       pp_string (pp, "]");
2074       break;
2075
2076     case REAL_CST:
2077       /* Code copied from print_node.  */
2078       {
2079         REAL_VALUE_TYPE d;
2080         if (TREE_OVERFLOW (node))
2081           pp_string (pp, " overflow");
2082
2083         d = TREE_REAL_CST (node);
2084         if (REAL_VALUE_ISINF (d))
2085           pp_string (pp, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
2086         else if (REAL_VALUE_ISNAN (d))
2087           pp_string (pp, " Nan");
2088         else
2089           {
2090             char string[100];
2091             real_to_decimal (string, &d, sizeof (string), 0, 1);
2092             pp_string (pp, string);
2093           }
2094         break;
2095       }
2096
2097     case FIXED_CST:
2098       {
2099         char string[100];
2100         fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
2101         pp_string (pp, string);
2102         break;
2103       }
2104
2105     case COMPLEX_CST:
2106       pp_string (pp, "__complex__ (");
2107       dump_generic_node (pp, TREE_REALPART (node), spc, flags, false);
2108       pp_string (pp, ", ");
2109       dump_generic_node (pp, TREE_IMAGPART (node), spc, flags, false);
2110       pp_right_paren (pp);
2111       break;
2112
2113     case STRING_CST:
2114       {
2115         pp_string (pp, "\"");
2116         if (unsigned nbytes = TREE_STRING_LENGTH (node))
2117           pretty_print_string (pp, TREE_STRING_POINTER (node), nbytes);
2118         pp_string (pp, "\"");
2119         break;
2120       }
2121
2122     case VECTOR_CST:
2123       {
2124         unsigned i;
2125         if (flags & TDF_GIMPLE)
2126           {
2127             pp_string (pp, "_Literal (");
2128             dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2129             pp_string (pp, ") ");
2130           }
2131         pp_string (pp, "{ ");
2132         unsigned HOST_WIDE_INT nunits;
2133         if (!VECTOR_CST_NELTS (node).is_constant (&nunits))
2134           nunits = vector_cst_encoded_nelts (node);
2135         for (i = 0; i < nunits; ++i)
2136           {
2137             if (i != 0)
2138               pp_string (pp, ", ");
2139             dump_generic_node (pp, VECTOR_CST_ELT (node, i),
2140                                spc, flags, false);
2141           }
2142         if (!VECTOR_CST_NELTS (node).is_constant ())
2143           pp_string (pp, ", ...");
2144         pp_string (pp, " }");
2145       }
2146       break;
2147
2148     case FUNCTION_TYPE:
2149     case METHOD_TYPE:
2150       dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2151       pp_space (pp);
2152       if (TREE_CODE (node) == METHOD_TYPE)
2153         {
2154           if (TYPE_METHOD_BASETYPE (node))
2155             dump_generic_node (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
2156                                spc, flags, false);
2157           else
2158             pp_string (pp, "<null method basetype>");
2159           pp_colon_colon (pp);
2160         }
2161       if (TYPE_IDENTIFIER (node))
2162         dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
2163       else if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
2164         dump_decl_name (pp, TYPE_NAME (node), flags);
2165       else if (flags & TDF_NOUID)
2166         pp_printf (pp, "<Txxxx>");
2167       else
2168         pp_printf (pp, "<T%x>", TYPE_UID (node));
2169       dump_function_declaration (pp, node, spc, flags);
2170       break;
2171
2172     case FUNCTION_DECL:
2173     case CONST_DECL:
2174       dump_decl_name (pp, node, flags);
2175       break;
2176
2177     case LABEL_DECL:
2178       if (DECL_NAME (node))
2179         dump_decl_name (pp, node, flags);
2180       else if (LABEL_DECL_UID (node) != -1)
2181         {
2182           if (flags & TDF_GIMPLE)
2183             pp_printf (pp, "L%d", (int) LABEL_DECL_UID (node));
2184           else
2185             pp_printf (pp, "<L%d>", (int) LABEL_DECL_UID (node));
2186         }
2187       else
2188         {
2189           if (flags & TDF_NOUID)
2190             pp_string (pp, "<D.xxxx>");
2191           else
2192             {
2193               if (flags & TDF_GIMPLE)
2194                 pp_printf (pp, "<D%u>", DECL_UID (node));
2195               else
2196                 pp_printf (pp, "<D.%u>", DECL_UID (node));
2197             }
2198         }
2199       break;
2200
2201     case TYPE_DECL:
2202       if (DECL_IS_BUILTIN (node))
2203         {
2204           /* Don't print the declaration of built-in types.  */
2205           break;
2206         }
2207       if (DECL_NAME (node))
2208         dump_decl_name (pp, node, flags);
2209       else if (TYPE_NAME (TREE_TYPE (node)) != node)
2210         {
2211           pp_string (pp, (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
2212                           ? "union" : "struct "));
2213           dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2214         }
2215       else
2216         pp_string (pp, "<anon>");
2217       break;
2218
2219     case VAR_DECL:
2220     case PARM_DECL:
2221     case FIELD_DECL:
2222     case DEBUG_EXPR_DECL:
2223     case NAMESPACE_DECL:
2224     case NAMELIST_DECL:
2225       dump_decl_name (pp, node, flags);
2226       break;
2227
2228     case RESULT_DECL:
2229       pp_string (pp, "<retval>");
2230       break;
2231
2232     case COMPONENT_REF:
2233       op0 = TREE_OPERAND (node, 0);
2234       str = ".";
2235       if (op0
2236           && (TREE_CODE (op0) == INDIRECT_REF
2237               || (TREE_CODE (op0) == MEM_REF
2238                   && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
2239                   && integer_zerop (TREE_OPERAND (op0, 1))
2240                   /* Dump the types of INTEGER_CSTs explicitly, for we
2241                      can't infer them and MEM_ATTR caching will share
2242                      MEM_REFs with differently-typed op0s.  */
2243                   && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
2244                   /* Released SSA_NAMES have no TREE_TYPE.  */
2245                   && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE
2246                   /* Same pointer types, but ignoring POINTER_TYPE vs.
2247                      REFERENCE_TYPE.  */
2248                   && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
2249                       == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))
2250                   && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0)))
2251                       == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
2252                   && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
2253                       == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
2254                   /* Same value types ignoring qualifiers.  */
2255                   && (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
2256                       == TYPE_MAIN_VARIANT
2257                           (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))))
2258                   && MR_DEPENDENCE_CLIQUE (op0) == 0)))
2259         {
2260           op0 = TREE_OPERAND (op0, 0);
2261           str = "->";
2262         }
2263       if (op_prio (op0) < op_prio (node))
2264         pp_left_paren (pp);
2265       dump_generic_node (pp, op0, spc, flags, false);
2266       if (op_prio (op0) < op_prio (node))
2267         pp_right_paren (pp);
2268       pp_string (pp, str);
2269       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2270       op0 = component_ref_field_offset (node);
2271       if (op0 && TREE_CODE (op0) != INTEGER_CST)
2272         {
2273           pp_string (pp, "{off: ");
2274               dump_generic_node (pp, op0, spc, flags, false);
2275               pp_right_brace (pp);
2276         }
2277       break;
2278
2279     case BIT_FIELD_REF:
2280       if (flags & TDF_GIMPLE)
2281         {
2282           pp_string (pp, "__BIT_FIELD_REF <");
2283           dump_generic_node (pp, TREE_TYPE (node),
2284                              spc, flags | TDF_SLIM, false);
2285           if (TYPE_ALIGN (TREE_TYPE (node))
2286               != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
2287             {
2288               pp_string (pp, ", ");
2289               pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
2290             }
2291           pp_greater (pp);
2292           pp_string (pp, " (");
2293           dump_generic_node (pp, TREE_OPERAND (node, 0), spc,
2294                              flags | TDF_SLIM, false);
2295           pp_string (pp, ", ");
2296           dump_generic_node (pp, TREE_OPERAND (node, 1), spc,
2297                              flags | TDF_SLIM, false);
2298           pp_string (pp, ", ");
2299           dump_generic_node (pp, TREE_OPERAND (node, 2), spc,
2300                              flags | TDF_SLIM, false);
2301           pp_right_paren (pp);
2302         }
2303       else
2304         {
2305           pp_string (pp, "BIT_FIELD_REF <");
2306           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2307           pp_string (pp, ", ");
2308           dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2309           pp_string (pp, ", ");
2310           dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2311           pp_greater (pp);
2312         }
2313       break;
2314
2315     case BIT_INSERT_EXPR:
2316       pp_string (pp, "BIT_INSERT_EXPR <");
2317       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2318       pp_string (pp, ", ");
2319       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2320       pp_string (pp, ", ");
2321       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2322       pp_string (pp, " (");
2323       if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node, 1))))
2324         pp_decimal_int (pp,
2325                         TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node, 1))));
2326       else
2327         dump_generic_node (pp, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node, 1))),
2328                            spc, flags, false);
2329       pp_string (pp, " bits)>");
2330       break;
2331
2332     case ARRAY_REF:
2333     case ARRAY_RANGE_REF:
2334       op0 = TREE_OPERAND (node, 0);
2335       if (op_prio (op0) < op_prio (node))
2336         pp_left_paren (pp);
2337       dump_generic_node (pp, op0, spc, flags, false);
2338       if (op_prio (op0) < op_prio (node))
2339         pp_right_paren (pp);
2340       pp_left_bracket (pp);
2341       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2342       if (TREE_CODE (node) == ARRAY_RANGE_REF)
2343         pp_string (pp, " ...");
2344       pp_right_bracket (pp);
2345
2346       op0 = array_ref_low_bound (node);
2347       op1 = array_ref_element_size (node);
2348
2349       if (!integer_zerop (op0)
2350           || TREE_OPERAND (node, 2)
2351           || TREE_OPERAND (node, 3))
2352         {
2353           pp_string (pp, "{lb: ");
2354           dump_generic_node (pp, op0, spc, flags, false);
2355           pp_string (pp, " sz: ");
2356           dump_generic_node (pp, op1, spc, flags, false);
2357           pp_right_brace (pp);
2358         }
2359       break;
2360
2361     case CONSTRUCTOR:
2362       {
2363         unsigned HOST_WIDE_INT ix;
2364         tree field, val;
2365         bool is_struct_init = false;
2366         bool is_array_init = false;
2367         widest_int curidx;
2368         if (flags & TDF_GIMPLE)
2369           {
2370             pp_string (pp, "_Literal (");
2371             dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2372             pp_string (pp, ") ");
2373           }
2374         pp_left_brace (pp);
2375         if (TREE_CLOBBER_P (node))
2376           pp_string (pp, "CLOBBER");
2377         else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
2378                  || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
2379           is_struct_init = true;
2380         else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE
2381                  && TYPE_DOMAIN (TREE_TYPE (node))
2382                  && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))
2383                  && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))))
2384                     == INTEGER_CST)
2385           {
2386             tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)));
2387             is_array_init = true;
2388             curidx = wi::to_widest (minv);
2389           }
2390         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
2391           {
2392             if (field)
2393               {
2394                 if (is_struct_init)
2395                   {
2396                     pp_dot (pp);
2397                     dump_generic_node (pp, field, spc, flags, false);
2398                     pp_equal (pp);
2399                   }
2400                 else if (is_array_init
2401                          && (TREE_CODE (field) != INTEGER_CST
2402                              || curidx != wi::to_widest (field)))
2403                   {
2404                     pp_left_bracket (pp);
2405                     if (TREE_CODE (field) == RANGE_EXPR)
2406                       {
2407                         dump_generic_node (pp, TREE_OPERAND (field, 0), spc,
2408                                            flags, false);
2409                         pp_string (pp, " ... ");
2410                         dump_generic_node (pp, TREE_OPERAND (field, 1), spc,
2411                                            flags, false);
2412                         if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST)
2413                           curidx = wi::to_widest (TREE_OPERAND (field, 1));
2414                       }
2415                     else
2416                       dump_generic_node (pp, field, spc, flags, false);
2417                     if (TREE_CODE (field) == INTEGER_CST)
2418                       curidx = wi::to_widest (field);
2419                     pp_string (pp, "]=");
2420                   }
2421               }
2422             if (is_array_init)
2423               curidx += 1;
2424             if (val && TREE_CODE (val) == ADDR_EXPR)
2425               if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
2426                 val = TREE_OPERAND (val, 0);
2427             if (val && TREE_CODE (val) == FUNCTION_DECL)
2428                 dump_decl_name (pp, val, flags);
2429             else
2430                 dump_generic_node (pp, val, spc, flags, false);
2431             if (ix != CONSTRUCTOR_NELTS (node) - 1)
2432               {
2433                 pp_comma (pp);
2434                 pp_space (pp);
2435               }
2436           }
2437         pp_right_brace (pp);
2438       }
2439       break;
2440
2441     case COMPOUND_EXPR:
2442       {
2443         tree *tp;
2444         if (flags & TDF_SLIM)
2445           {
2446             pp_string (pp, "<COMPOUND_EXPR>");
2447             break;
2448           }
2449
2450         dump_generic_node (pp, TREE_OPERAND (node, 0),
2451                            spc, flags, !(flags & TDF_SLIM));
2452         if (flags & TDF_SLIM)
2453           newline_and_indent (pp, spc);
2454         else
2455           {
2456             pp_comma (pp);
2457             pp_space (pp);
2458           }
2459
2460         for (tp = &TREE_OPERAND (node, 1);
2461              TREE_CODE (*tp) == COMPOUND_EXPR;
2462              tp = &TREE_OPERAND (*tp, 1))
2463           {
2464             dump_generic_node (pp, TREE_OPERAND (*tp, 0),
2465                                spc, flags, !(flags & TDF_SLIM));
2466             if (flags & TDF_SLIM)
2467               newline_and_indent (pp, spc);
2468             else
2469               {
2470                 pp_comma (pp);
2471                 pp_space (pp);
2472               }
2473           }
2474
2475         dump_generic_node (pp, *tp, spc, flags, !(flags & TDF_SLIM));
2476       }
2477       break;
2478
2479     case STATEMENT_LIST:
2480       {
2481         tree_stmt_iterator si;
2482         bool first = true;
2483
2484         if (flags & TDF_SLIM)
2485           {
2486             pp_string (pp, "<STATEMENT_LIST>");
2487             break;
2488           }
2489
2490         for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
2491           {
2492             if (!first)
2493               newline_and_indent (pp, spc);
2494             else
2495               first = false;
2496             dump_generic_node (pp, tsi_stmt (si), spc, flags, true);
2497           }
2498       }
2499       break;
2500
2501     case MODIFY_EXPR:
2502     case INIT_EXPR:
2503       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags,
2504                          false);
2505       pp_space (pp);
2506       pp_equal (pp);
2507       pp_space (pp);
2508       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags,
2509                          false);
2510       break;
2511
2512     case TARGET_EXPR:
2513       pp_string (pp, "TARGET_EXPR <");
2514       dump_generic_node (pp, TARGET_EXPR_SLOT (node), spc, flags, false);
2515       pp_comma (pp);
2516       pp_space (pp);
2517       dump_generic_node (pp, TARGET_EXPR_INITIAL (node), spc, flags, false);
2518       pp_greater (pp);
2519       break;
2520
2521     case DECL_EXPR:
2522       print_declaration (pp, DECL_EXPR_DECL (node), spc, flags);
2523       is_stmt = false;
2524       break;
2525
2526     case COND_EXPR:
2527       if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
2528         {
2529           pp_string (pp, "if (");
2530           dump_generic_node (pp, COND_EXPR_COND (node), spc, flags, false);
2531           pp_right_paren (pp);
2532           /* The lowered cond_exprs should always be printed in full.  */
2533           if (COND_EXPR_THEN (node)
2534               && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
2535                   || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
2536               && COND_EXPR_ELSE (node)
2537               && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
2538                   || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
2539             {
2540               pp_space (pp);
2541               dump_generic_node (pp, COND_EXPR_THEN (node),
2542                                  0, flags, true);
2543               if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
2544                 {
2545                   pp_string (pp, " else ");
2546                   dump_generic_node (pp, COND_EXPR_ELSE (node),
2547                                      0, flags, true);
2548                 }
2549             }
2550           else if (!(flags & TDF_SLIM))
2551             {
2552               /* Output COND_EXPR_THEN.  */
2553               if (COND_EXPR_THEN (node))
2554                 {
2555                   newline_and_indent (pp, spc+2);
2556                   pp_left_brace (pp);
2557                   newline_and_indent (pp, spc+4);
2558                   dump_generic_node (pp, COND_EXPR_THEN (node), spc+4,
2559                                      flags, true);
2560                   newline_and_indent (pp, spc+2);
2561                   pp_right_brace (pp);
2562                 }
2563
2564               /* Output COND_EXPR_ELSE.  */
2565               if (COND_EXPR_ELSE (node)
2566                   && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
2567                 {
2568                   newline_and_indent (pp, spc);
2569                   pp_string (pp, "else");
2570                   newline_and_indent (pp, spc+2);
2571                   pp_left_brace (pp);
2572                   newline_and_indent (pp, spc+4);
2573                   dump_generic_node (pp, COND_EXPR_ELSE (node), spc+4,
2574                                      flags, true);
2575                   newline_and_indent (pp, spc+2);
2576                   pp_right_brace (pp);
2577                 }
2578             }
2579           is_expr = false;
2580         }
2581       else
2582         {
2583           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2584           pp_space (pp);
2585           pp_question (pp);
2586           pp_space (pp);
2587           dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2588           pp_space (pp);
2589           pp_colon (pp);
2590           pp_space (pp);
2591           dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
2592         }
2593       break;
2594
2595     case BIND_EXPR:
2596       pp_left_brace (pp);
2597       if (!(flags & TDF_SLIM))
2598         {
2599           if (BIND_EXPR_VARS (node))
2600             {
2601               pp_newline (pp);
2602
2603               for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0))
2604                 {
2605                   print_declaration (pp, op0, spc+2, flags);
2606                   pp_newline (pp);
2607                 }
2608             }
2609
2610           newline_and_indent (pp, spc+2);
2611           dump_generic_node (pp, BIND_EXPR_BODY (node), spc+2, flags, true);
2612           newline_and_indent (pp, spc);
2613           pp_right_brace (pp);
2614         }
2615       is_expr = false;
2616       break;
2617
2618     case CALL_EXPR:
2619       if (CALL_EXPR_FN (node) != NULL_TREE)
2620         print_call_name (pp, CALL_EXPR_FN (node), flags);
2621       else
2622         {
2623           pp_dot (pp);
2624           pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node)));
2625         }
2626
2627       /* Print parameters.  */
2628       pp_space (pp);
2629       pp_left_paren (pp);
2630       {
2631         tree arg;
2632         call_expr_arg_iterator iter;
2633         FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
2634           {
2635             dump_generic_node (pp, arg, spc, flags, false);
2636             if (more_call_expr_args_p (&iter))
2637               {
2638                 pp_comma (pp);
2639                 pp_space (pp);
2640               }
2641           }
2642       }
2643       if (CALL_EXPR_VA_ARG_PACK (node))
2644         {
2645           if (call_expr_nargs (node) > 0)
2646             {
2647               pp_comma (pp);
2648               pp_space (pp);
2649             }
2650           pp_string (pp, "__builtin_va_arg_pack ()");
2651         }
2652       pp_right_paren (pp);
2653
2654       op1 = CALL_EXPR_STATIC_CHAIN (node);
2655       if (op1)
2656         {
2657           pp_string (pp, " [static-chain: ");
2658           dump_generic_node (pp, op1, spc, flags, false);
2659           pp_right_bracket (pp);
2660         }
2661
2662       if (CALL_EXPR_RETURN_SLOT_OPT (node))
2663         pp_string (pp, " [return slot optimization]");
2664       if (CALL_EXPR_TAILCALL (node))
2665         pp_string (pp, " [tail call]");
2666       break;
2667
2668     case WITH_CLEANUP_EXPR:
2669       NIY;
2670       break;
2671
2672     case CLEANUP_POINT_EXPR:
2673       pp_string (pp, "<<cleanup_point ");
2674       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2675       pp_string (pp, ">>");
2676       break;
2677
2678     case PLACEHOLDER_EXPR:
2679       pp_string (pp, "<PLACEHOLDER_EXPR ");
2680       dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2681       pp_greater (pp);
2682       break;
2683
2684       /* Binary arithmetic and logic expressions.  */
2685     case WIDEN_SUM_EXPR:
2686     case WIDEN_MULT_EXPR:
2687     case MULT_EXPR:
2688     case MULT_HIGHPART_EXPR:
2689     case PLUS_EXPR:
2690     case POINTER_PLUS_EXPR:
2691     case POINTER_DIFF_EXPR:
2692     case MINUS_EXPR:
2693     case TRUNC_DIV_EXPR:
2694     case CEIL_DIV_EXPR:
2695     case FLOOR_DIV_EXPR:
2696     case ROUND_DIV_EXPR:
2697     case TRUNC_MOD_EXPR:
2698     case CEIL_MOD_EXPR:
2699     case FLOOR_MOD_EXPR:
2700     case ROUND_MOD_EXPR:
2701     case RDIV_EXPR:
2702     case EXACT_DIV_EXPR:
2703     case LSHIFT_EXPR:
2704     case RSHIFT_EXPR:
2705     case LROTATE_EXPR:
2706     case RROTATE_EXPR:
2707     case WIDEN_LSHIFT_EXPR:
2708     case BIT_IOR_EXPR:
2709     case BIT_XOR_EXPR:
2710     case BIT_AND_EXPR:
2711     case TRUTH_ANDIF_EXPR:
2712     case TRUTH_ORIF_EXPR:
2713     case TRUTH_AND_EXPR:
2714     case TRUTH_OR_EXPR:
2715     case TRUTH_XOR_EXPR:
2716     case LT_EXPR:
2717     case LE_EXPR:
2718     case GT_EXPR:
2719     case GE_EXPR:
2720     case EQ_EXPR:
2721     case NE_EXPR:
2722     case UNLT_EXPR:
2723     case UNLE_EXPR:
2724     case UNGT_EXPR:
2725     case UNGE_EXPR:
2726     case UNEQ_EXPR:
2727     case LTGT_EXPR:
2728     case ORDERED_EXPR:
2729     case UNORDERED_EXPR:
2730       {
2731         const char *op = op_symbol (node);
2732         op0 = TREE_OPERAND (node, 0);
2733         op1 = TREE_OPERAND (node, 1);
2734
2735         /* When the operands are expressions with less priority,
2736            keep semantics of the tree representation.  */
2737         if (op_prio (op0) <= op_prio (node))
2738           {
2739             pp_left_paren (pp);
2740             dump_generic_node (pp, op0, spc, flags, false);
2741             pp_right_paren (pp);
2742           }
2743         else
2744           dump_generic_node (pp, op0, spc, flags, false);
2745
2746         pp_space (pp);
2747         pp_string (pp, op);
2748         pp_space (pp);
2749
2750         /* When the operands are expressions with less priority,
2751            keep semantics of the tree representation.  */
2752         if (op_prio (op1) <= op_prio (node))
2753           {
2754             pp_left_paren (pp);
2755             dump_generic_node (pp, op1, spc, flags, false);
2756             pp_right_paren (pp);
2757           }
2758         else
2759           dump_generic_node (pp, op1, spc, flags, false);
2760       }
2761       break;
2762
2763       /* Unary arithmetic and logic expressions.  */
2764     case NEGATE_EXPR:
2765     case BIT_NOT_EXPR:
2766     case TRUTH_NOT_EXPR:
2767     case ADDR_EXPR:
2768     case PREDECREMENT_EXPR:
2769     case PREINCREMENT_EXPR:
2770     case INDIRECT_REF:
2771       if (TREE_CODE (node) == ADDR_EXPR
2772           && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
2773               || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
2774         ;       /* Do not output '&' for strings and function pointers.  */
2775       else
2776         pp_string (pp, op_symbol (node));
2777
2778       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
2779         {
2780           pp_left_paren (pp);
2781           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2782           pp_right_paren (pp);
2783         }
2784       else
2785         dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2786       break;
2787
2788     case POSTDECREMENT_EXPR:
2789     case POSTINCREMENT_EXPR:
2790       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
2791         {
2792           pp_left_paren (pp);
2793           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2794           pp_right_paren (pp);
2795         }
2796       else
2797         dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2798       pp_string (pp, op_symbol (node));
2799       break;
2800
2801     case MIN_EXPR:
2802       pp_string (pp, "MIN_EXPR <");
2803       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2804       pp_string (pp, ", ");
2805       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2806       pp_greater (pp);
2807       break;
2808
2809     case MAX_EXPR:
2810       pp_string (pp, "MAX_EXPR <");
2811       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2812       pp_string (pp, ", ");
2813       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2814       pp_greater (pp);
2815       break;
2816
2817     case ABS_EXPR:
2818       pp_string (pp, "ABS_EXPR <");
2819       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2820       pp_greater (pp);
2821       break;
2822
2823     case ABSU_EXPR:
2824       pp_string (pp, "ABSU_EXPR <");
2825       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2826       pp_greater (pp);
2827       break;
2828
2829     case RANGE_EXPR:
2830       NIY;
2831       break;
2832
2833     case ADDR_SPACE_CONVERT_EXPR:
2834     case FIXED_CONVERT_EXPR:
2835     case FIX_TRUNC_EXPR:
2836     case FLOAT_EXPR:
2837     CASE_CONVERT:
2838       type = TREE_TYPE (node);
2839       op0 = TREE_OPERAND (node, 0);
2840       if (type != TREE_TYPE (op0))
2841         {
2842           pp_left_paren (pp);
2843           dump_generic_node (pp, type, spc, flags, false);
2844           pp_string (pp, ") ");
2845         }
2846       if (op_prio (op0) < op_prio (node))
2847         pp_left_paren (pp);
2848       dump_generic_node (pp, op0, spc, flags, false);
2849       if (op_prio (op0) < op_prio (node))
2850         pp_right_paren (pp);
2851       break;
2852
2853     case VIEW_CONVERT_EXPR:
2854       if (flags & TDF_GIMPLE)
2855         pp_string (pp, "__VIEW_CONVERT <");
2856       else
2857         pp_string (pp, "VIEW_CONVERT_EXPR<");
2858       dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
2859       pp_string (pp, ">(");
2860       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2861       pp_right_paren (pp);
2862       break;
2863
2864     case PAREN_EXPR:
2865       pp_string (pp, "((");
2866       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2867       pp_string (pp, "))");
2868       break;
2869
2870     case NON_LVALUE_EXPR:
2871       pp_string (pp, "NON_LVALUE_EXPR <");
2872       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2873       pp_greater (pp);
2874       break;
2875
2876     case SAVE_EXPR:
2877       pp_string (pp, "SAVE_EXPR <");
2878       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2879       pp_greater (pp);
2880       break;
2881
2882     case COMPLEX_EXPR:
2883       pp_string (pp, "COMPLEX_EXPR <");
2884       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2885       pp_string (pp, ", ");
2886       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
2887       pp_greater (pp);
2888       break;
2889
2890     case CONJ_EXPR:
2891       pp_string (pp, "CONJ_EXPR <");
2892       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2893       pp_greater (pp);
2894       break;
2895
2896     case REALPART_EXPR:
2897       if (flags & TDF_GIMPLE)
2898         {
2899           pp_string (pp, "__real ");
2900           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2901         }
2902       else
2903         {
2904           pp_string (pp, "REALPART_EXPR <");
2905           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2906           pp_greater (pp);
2907         }
2908       break;
2909
2910     case IMAGPART_EXPR:
2911       if (flags & TDF_GIMPLE)
2912         {
2913           pp_string (pp, "__imag ");
2914           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2915         }
2916       else
2917         {
2918           pp_string (pp, "IMAGPART_EXPR <");
2919           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2920           pp_greater (pp);
2921         }
2922       break;
2923
2924     case VA_ARG_EXPR:
2925       pp_string (pp, "VA_ARG_EXPR <");
2926       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
2927       pp_greater (pp);
2928       break;
2929
2930     case TRY_FINALLY_EXPR:
2931     case TRY_CATCH_EXPR:
2932       pp_string (pp, "try");
2933       newline_and_indent (pp, spc+2);
2934       pp_left_brace (pp);
2935       newline_and_indent (pp, spc+4);
2936       dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true);
2937       newline_and_indent (pp, spc+2);
2938       pp_right_brace (pp);
2939       newline_and_indent (pp, spc);
2940       if (TREE_CODE (node) == TRY_CATCH_EXPR)
2941         {
2942           node = TREE_OPERAND (node, 1);
2943           pp_string (pp, "catch");
2944         }
2945       else
2946         {
2947           gcc_assert (TREE_CODE (node) == TRY_FINALLY_EXPR);
2948           node = TREE_OPERAND (node, 1);
2949           pp_string (pp, "finally");
2950           if (TREE_CODE (node) == EH_ELSE_EXPR)
2951             {
2952               newline_and_indent (pp, spc+2);
2953               pp_left_brace (pp);
2954               newline_and_indent (pp, spc+4);
2955               dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4,
2956                                  flags, true);
2957               newline_and_indent (pp, spc+2);
2958               pp_right_brace (pp);
2959               newline_and_indent (pp, spc);
2960               node = TREE_OPERAND (node, 1);
2961               pp_string (pp, "else");
2962             }
2963         }
2964       newline_and_indent (pp, spc+2);
2965       pp_left_brace (pp);
2966       newline_and_indent (pp, spc+4);
2967       dump_generic_node (pp, node, spc+4, flags, true);
2968       newline_and_indent (pp, spc+2);
2969       pp_right_brace (pp);
2970       is_expr = false;
2971       break;
2972
2973     case CATCH_EXPR:
2974       pp_string (pp, "catch (");
2975       dump_generic_node (pp, CATCH_TYPES (node), spc+2, flags, false);
2976       pp_right_paren (pp);
2977       newline_and_indent (pp, spc+2);
2978       pp_left_brace (pp);
2979       newline_and_indent (pp, spc+4);
2980       dump_generic_node (pp, CATCH_BODY (node), spc+4, flags, true);
2981       newline_and_indent (pp, spc+2);
2982       pp_right_brace (pp);
2983       is_expr = false;
2984       break;
2985
2986     case EH_FILTER_EXPR:
2987       pp_string (pp, "<<<eh_filter (");
2988       dump_generic_node (pp, EH_FILTER_TYPES (node), spc+2, flags, false);
2989       pp_string (pp, ")>>>");
2990       newline_and_indent (pp, spc+2);
2991       pp_left_brace (pp);
2992       newline_and_indent (pp, spc+4);
2993       dump_generic_node (pp, EH_FILTER_FAILURE (node), spc+4, flags, true);
2994       newline_and_indent (pp, spc+2);
2995       pp_right_brace (pp);
2996       is_expr = false;
2997       break;
2998
2999     case LABEL_EXPR:
3000       op0 = TREE_OPERAND (node, 0);
3001       /* If this is for break or continue, don't bother printing it.  */
3002       if (DECL_NAME (op0))
3003         {
3004           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
3005           if (strcmp (name, "break") == 0
3006               || strcmp (name, "continue") == 0)
3007             break;
3008         }
3009       dump_generic_node (pp, op0, spc, flags, false);
3010       pp_colon (pp);
3011       if (DECL_NONLOCAL (op0))
3012         pp_string (pp, " [non-local]");
3013       break;
3014
3015     case LOOP_EXPR:
3016       pp_string (pp, "while (1)");
3017       if (!(flags & TDF_SLIM))
3018         {
3019           newline_and_indent (pp, spc+2);
3020           pp_left_brace (pp);
3021           newline_and_indent (pp, spc+4);
3022           dump_generic_node (pp, LOOP_EXPR_BODY (node), spc+4, flags, true);
3023           newline_and_indent (pp, spc+2);
3024           pp_right_brace (pp);
3025         }
3026       is_expr = false;
3027       break;
3028
3029     case PREDICT_EXPR:
3030       pp_string (pp, "// predicted ");
3031       if (PREDICT_EXPR_OUTCOME (node))
3032         pp_string (pp, "likely by ");
3033       else
3034         pp_string (pp, "unlikely by ");
3035       pp_string (pp, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
3036       pp_string (pp, " predictor.");
3037       break;
3038
3039     case ANNOTATE_EXPR:
3040       pp_string (pp, "ANNOTATE_EXPR <");
3041       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3042       switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1)))
3043         {
3044         case annot_expr_ivdep_kind:
3045           pp_string (pp, ", ivdep");
3046           break;
3047         case annot_expr_unroll_kind:
3048           pp_printf (pp, ", unroll %d",
3049                      (int) TREE_INT_CST_LOW (TREE_OPERAND (node, 2)));
3050           break;
3051         case annot_expr_no_vector_kind:
3052           pp_string (pp, ", no-vector");
3053           break;
3054         case annot_expr_vector_kind:
3055           pp_string (pp, ", vector");
3056           break;
3057         case annot_expr_parallel_kind:
3058           pp_string (pp, ", parallel");
3059           break;
3060         default:
3061           gcc_unreachable ();
3062         }
3063       pp_greater (pp);
3064       break;
3065
3066     case RETURN_EXPR:
3067       pp_string (pp, "return");
3068       op0 = TREE_OPERAND (node, 0);
3069       if (op0)
3070         {
3071           pp_space (pp);
3072           if (TREE_CODE (op0) == MODIFY_EXPR)
3073             dump_generic_node (pp, TREE_OPERAND (op0, 1),
3074                                spc, flags, false);
3075           else
3076             dump_generic_node (pp, op0, spc, flags, false);
3077         }
3078       break;
3079
3080     case EXIT_EXPR:
3081       pp_string (pp, "if (");
3082       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3083       pp_string (pp, ") break");
3084       break;
3085
3086     case SWITCH_EXPR:
3087       pp_string (pp, "switch (");
3088       dump_generic_node (pp, SWITCH_COND (node), spc, flags, false);
3089       pp_right_paren (pp);
3090       if (!(flags & TDF_SLIM))
3091         {
3092           newline_and_indent (pp, spc+2);
3093           pp_left_brace (pp);
3094           if (SWITCH_BODY (node))
3095             {
3096               newline_and_indent (pp, spc+4);
3097               dump_generic_node (pp, SWITCH_BODY (node), spc+4, flags,
3098                                  true);
3099             }
3100           newline_and_indent (pp, spc+2);
3101           pp_right_brace (pp);
3102         }
3103       is_expr = false;
3104       break;
3105
3106     case GOTO_EXPR:
3107       op0 = GOTO_DESTINATION (node);
3108       if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
3109         {
3110           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
3111           if (strcmp (name, "break") == 0
3112               || strcmp (name, "continue") == 0)
3113             {
3114               pp_string (pp, name);
3115               break;
3116             }
3117         }
3118       pp_string (pp, "goto ");
3119       dump_generic_node (pp, op0, spc, flags, false);
3120       break;
3121
3122     case ASM_EXPR:
3123       pp_string (pp, "__asm__");
3124       if (ASM_VOLATILE_P (node))
3125         pp_string (pp, " __volatile__");
3126       pp_left_paren (pp);
3127       dump_generic_node (pp, ASM_STRING (node), spc, flags, false);
3128       pp_colon (pp);
3129       dump_generic_node (pp, ASM_OUTPUTS (node), spc, flags, false);
3130       pp_colon (pp);
3131       dump_generic_node (pp, ASM_INPUTS (node), spc, flags, false);
3132       if (ASM_CLOBBERS (node))
3133         {
3134           pp_colon (pp);
3135           dump_generic_node (pp, ASM_CLOBBERS (node), spc, flags, false);
3136         }
3137       pp_right_paren (pp);
3138       break;
3139
3140     case CASE_LABEL_EXPR:
3141       if (CASE_LOW (node) && CASE_HIGH (node))
3142         {
3143           pp_string (pp, "case ");
3144           dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
3145           pp_string (pp, " ... ");
3146           dump_generic_node (pp, CASE_HIGH (node), spc, flags, false);
3147         }
3148       else if (CASE_LOW (node))
3149         {
3150           pp_string (pp, "case ");
3151           dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
3152         }
3153       else
3154         pp_string (pp, "default");
3155       pp_colon (pp);
3156       break;
3157
3158     case OBJ_TYPE_REF:
3159       pp_string (pp, "OBJ_TYPE_REF(");
3160       dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
3161       pp_semicolon (pp);
3162       /* We omit the class type for -fcompare-debug because we may
3163          drop TYPE_BINFO early depending on debug info, and then
3164          virtual_method_call_p would return false, whereas when
3165          TYPE_BINFO is preserved it may still return true and then
3166          we'd print the class type.  Compare tree and rtl dumps for
3167          libstdc++-prettyprinters/shared_ptr.cc with and without -g,
3168          for example, at occurrences of OBJ_TYPE_REF.  */
3169       if (!(flags & (TDF_SLIM | TDF_COMPARE_DEBUG))
3170           && virtual_method_call_p (node))
3171         {
3172           pp_string (pp, "(");
3173           dump_generic_node (pp, obj_type_ref_class (node), spc, flags, false);
3174           pp_string (pp, ")");
3175         }
3176       dump_generic_node (pp, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
3177       pp_arrow (pp);
3178       dump_generic_node (pp, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
3179       pp_right_paren (pp);
3180       break;
3181
3182     case SSA_NAME:
3183       if (SSA_NAME_IDENTIFIER (node))
3184         {
3185           if ((flags & TDF_NOUID)
3186               && SSA_NAME_VAR (node)
3187               && DECL_NAMELESS (SSA_NAME_VAR (node)))
3188             dump_fancy_name (pp, SSA_NAME_IDENTIFIER (node));
3189           else if (! (flags & TDF_GIMPLE)
3190                    || SSA_NAME_VAR (node))
3191             dump_generic_node (pp, SSA_NAME_IDENTIFIER (node),
3192                                spc, flags, false);
3193         }
3194       pp_underscore (pp);
3195       pp_decimal_int (pp, SSA_NAME_VERSION (node));
3196       if (SSA_NAME_IS_DEFAULT_DEF (node))
3197         pp_string (pp, "(D)");
3198       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
3199         pp_string (pp, "(ab)");
3200       break;
3201
3202     case WITH_SIZE_EXPR:
3203       pp_string (pp, "WITH_SIZE_EXPR <");
3204       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3205       pp_string (pp, ", ");
3206       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3207       pp_greater (pp);
3208       break;
3209
3210     case ASSERT_EXPR:
3211       pp_string (pp, "ASSERT_EXPR <");
3212       dump_generic_node (pp, ASSERT_EXPR_VAR (node), spc, flags, false);
3213       pp_string (pp, ", ");
3214       dump_generic_node (pp, ASSERT_EXPR_COND (node), spc, flags, false);
3215       pp_greater (pp);
3216       break;
3217
3218     case SCEV_KNOWN:
3219       pp_string (pp, "scev_known");
3220       break;
3221
3222     case SCEV_NOT_KNOWN:
3223       pp_string (pp, "scev_not_known");
3224       break;
3225
3226     case POLYNOMIAL_CHREC:
3227       pp_left_brace (pp);
3228       dump_generic_node (pp, CHREC_LEFT (node), spc, flags, false);
3229       pp_string (pp, ", +, ");
3230       dump_generic_node (pp, CHREC_RIGHT (node), spc, flags, false);
3231       pp_printf (pp, "}_%u", CHREC_VARIABLE (node));
3232       is_stmt = false;
3233       break;
3234
3235     case REALIGN_LOAD_EXPR:
3236       pp_string (pp, "REALIGN_LOAD <");
3237       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3238       pp_string (pp, ", ");
3239       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3240       pp_string (pp, ", ");
3241       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3242       pp_greater (pp);
3243       break;
3244
3245     case VEC_COND_EXPR:
3246       pp_string (pp, " VEC_COND_EXPR < ");
3247       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3248       pp_string (pp, " , ");
3249       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3250       pp_string (pp, " , ");
3251       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3252       pp_string (pp, " > ");
3253       break;
3254
3255     case VEC_PERM_EXPR:
3256       pp_string (pp, " VEC_PERM_EXPR < ");
3257       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3258       pp_string (pp, " , ");
3259       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3260       pp_string (pp, " , ");
3261       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3262       pp_string (pp, " > ");
3263       break;
3264
3265     case DOT_PROD_EXPR:
3266       pp_string (pp, " DOT_PROD_EXPR < ");
3267       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3268       pp_string (pp, ", ");
3269       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3270       pp_string (pp, ", ");
3271       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3272       pp_string (pp, " > ");
3273       break;
3274
3275     case WIDEN_MULT_PLUS_EXPR:
3276       pp_string (pp, " WIDEN_MULT_PLUS_EXPR < ");
3277       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3278       pp_string (pp, ", ");
3279       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3280       pp_string (pp, ", ");
3281       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3282       pp_string (pp, " > ");
3283       break;
3284
3285     case WIDEN_MULT_MINUS_EXPR:
3286       pp_string (pp, " WIDEN_MULT_MINUS_EXPR < ");
3287       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3288       pp_string (pp, ", ");
3289       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3290       pp_string (pp, ", ");
3291       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
3292       pp_string (pp, " > ");
3293       break;
3294
3295     case OACC_PARALLEL:
3296       pp_string (pp, "#pragma acc parallel");
3297       goto dump_omp_clauses_body;
3298
3299     case OACC_KERNELS:
3300       pp_string (pp, "#pragma acc kernels");
3301       goto dump_omp_clauses_body;
3302
3303     case OACC_SERIAL:
3304       pp_string (pp, "#pragma acc serial");
3305       goto dump_omp_clauses_body;
3306
3307     case OACC_DATA:
3308       pp_string (pp, "#pragma acc data");
3309       dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags);
3310       goto dump_omp_body;
3311
3312     case OACC_HOST_DATA:
3313       pp_string (pp, "#pragma acc host_data");
3314       dump_omp_clauses (pp, OACC_HOST_DATA_CLAUSES (node), spc, flags);
3315       goto dump_omp_body;
3316
3317     case OACC_DECLARE:
3318       pp_string (pp, "#pragma acc declare");
3319       dump_omp_clauses (pp, OACC_DECLARE_CLAUSES (node), spc, flags);
3320       break;
3321
3322     case OACC_UPDATE:
3323       pp_string (pp, "#pragma acc update");
3324       dump_omp_clauses (pp, OACC_UPDATE_CLAUSES (node), spc, flags);
3325       break;
3326
3327     case OACC_ENTER_DATA:
3328       pp_string (pp, "#pragma acc enter data");
3329       dump_omp_clauses (pp, OACC_ENTER_DATA_CLAUSES (node), spc, flags);
3330       break;
3331
3332     case OACC_EXIT_DATA:
3333       pp_string (pp, "#pragma acc exit data");
3334       dump_omp_clauses (pp, OACC_EXIT_DATA_CLAUSES (node), spc, flags);
3335       break;
3336
3337     case OACC_CACHE:
3338       pp_string (pp, "#pragma acc cache");
3339       dump_omp_clauses (pp, OACC_CACHE_CLAUSES (node), spc, flags);
3340       break;
3341
3342     case OMP_PARALLEL:
3343       pp_string (pp, "#pragma omp parallel");
3344       dump_omp_clauses (pp, OMP_PARALLEL_CLAUSES (node), spc, flags);
3345       goto dump_omp_body;
3346
3347     dump_omp_clauses_body:
3348       dump_omp_clauses (pp, OMP_CLAUSES (node), spc, flags);
3349       goto dump_omp_body;
3350
3351     dump_omp_body:
3352       if (!(flags & TDF_SLIM) && OMP_BODY (node))
3353         {
3354           newline_and_indent (pp, spc + 2);
3355           pp_left_brace (pp);
3356           newline_and_indent (pp, spc + 4);
3357           dump_generic_node (pp, OMP_BODY (node), spc + 4, flags, false);
3358           newline_and_indent (pp, spc + 2);
3359           pp_right_brace (pp);
3360         }
3361       is_expr = false;
3362       break;
3363
3364     case OMP_TASK:
3365       pp_string (pp, OMP_TASK_BODY (node) ? "#pragma omp task"
3366                                           : "#pragma omp taskwait");
3367       dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags);
3368       goto dump_omp_body;
3369
3370     case OMP_FOR:
3371       pp_string (pp, "#pragma omp for");
3372       goto dump_omp_loop;
3373
3374     case OMP_SIMD:
3375       pp_string (pp, "#pragma omp simd");
3376       goto dump_omp_loop;
3377
3378     case OMP_DISTRIBUTE:
3379       pp_string (pp, "#pragma omp distribute");
3380       goto dump_omp_loop;
3381
3382     case OMP_TASKLOOP:
3383       pp_string (pp, "#pragma omp taskloop");
3384       goto dump_omp_loop;
3385
3386     case OMP_LOOP:
3387       pp_string (pp, "#pragma omp loop");
3388       goto dump_omp_loop;
3389
3390     case OACC_LOOP:
3391       pp_string (pp, "#pragma acc loop");
3392       goto dump_omp_loop;
3393
3394     case OMP_TEAMS:
3395       pp_string (pp, "#pragma omp teams");
3396       dump_omp_clauses (pp, OMP_TEAMS_CLAUSES (node), spc, flags);
3397       goto dump_omp_body;
3398
3399     case OMP_TARGET_DATA:
3400       pp_string (pp, "#pragma omp target data");
3401       dump_omp_clauses (pp, OMP_TARGET_DATA_CLAUSES (node), spc, flags);
3402       goto dump_omp_body;
3403
3404     case OMP_TARGET_ENTER_DATA:
3405       pp_string (pp, "#pragma omp target enter data");
3406       dump_omp_clauses (pp, OMP_TARGET_ENTER_DATA_CLAUSES (node), spc, flags);
3407       is_expr = false;
3408       break;
3409
3410     case OMP_TARGET_EXIT_DATA:
3411       pp_string (pp, "#pragma omp target exit data");
3412       dump_omp_clauses (pp, OMP_TARGET_EXIT_DATA_CLAUSES (node), spc, flags);
3413       is_expr = false;
3414       break;
3415
3416     case OMP_TARGET:
3417       pp_string (pp, "#pragma omp target");
3418       dump_omp_clauses (pp, OMP_TARGET_CLAUSES (node), spc, flags);
3419       goto dump_omp_body;
3420
3421     case OMP_TARGET_UPDATE:
3422       pp_string (pp, "#pragma omp target update");
3423       dump_omp_clauses (pp, OMP_TARGET_UPDATE_CLAUSES (node), spc, flags);
3424       is_expr = false;
3425       break;
3426
3427     dump_omp_loop:
3428       dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
3429       if (!(flags & TDF_SLIM))
3430         {
3431           int i;
3432
3433           if (OMP_FOR_PRE_BODY (node))
3434             {
3435               newline_and_indent (pp, spc + 2);
3436               pp_left_brace (pp);
3437               spc += 4;
3438               newline_and_indent (pp, spc);
3439               dump_generic_node (pp, OMP_FOR_PRE_BODY (node),
3440                                  spc, flags, false);
3441             }
3442           if (OMP_FOR_INIT (node))
3443             {
3444               spc -= 2;
3445               for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
3446                 {
3447                   spc += 2;
3448                   newline_and_indent (pp, spc);
3449                   pp_string (pp, "for (");
3450                   tree init = TREE_VEC_ELT (OMP_FOR_INIT (node), i);
3451                   if (TREE_CODE (init) != MODIFY_EXPR
3452                       || TREE_CODE (TREE_OPERAND (init, 1)) != TREE_VEC)
3453                     dump_generic_node (pp, init, spc, flags, false);
3454                   else
3455                     {
3456                       dump_generic_node (pp, TREE_OPERAND (init, 0),
3457                                          spc, flags, false);
3458                       pp_string (pp, " = ");
3459                       dump_omp_loop_non_rect_expr (pp, TREE_OPERAND (init, 1),
3460                                                    spc, flags);
3461                     }
3462                   pp_string (pp, "; ");
3463                   tree cond = TREE_VEC_ELT (OMP_FOR_COND (node), i);
3464                   if (!COMPARISON_CLASS_P (cond)
3465                       || TREE_CODE (TREE_OPERAND (cond, 1)) != TREE_VEC)
3466                     dump_generic_node (pp, cond, spc, flags, false);
3467                   else
3468                     {
3469                       dump_generic_node (pp, TREE_OPERAND (cond, 0),
3470                                          spc, flags, false);
3471                       const char *op = op_symbol (cond);
3472                       pp_space (pp);
3473                       pp_string (pp, op);
3474                       pp_space (pp);
3475                       dump_omp_loop_non_rect_expr (pp, TREE_OPERAND (cond, 1),
3476                                                    spc, flags);
3477                     }
3478                   pp_string (pp, "; ");
3479                   dump_generic_node (pp,
3480                                      TREE_VEC_ELT (OMP_FOR_INCR (node), i),
3481                                      spc, flags, false);
3482                   pp_right_paren (pp);
3483                 }
3484             }
3485           if (OMP_FOR_BODY (node))
3486             {
3487               newline_and_indent (pp, spc + 2);
3488               pp_left_brace (pp);
3489               newline_and_indent (pp, spc + 4);
3490               dump_generic_node (pp, OMP_FOR_BODY (node), spc + 4, flags,
3491                   false);
3492               newline_and_indent (pp, spc + 2);
3493               pp_right_brace (pp);
3494             }
3495           if (OMP_FOR_INIT (node))
3496             spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
3497           if (OMP_FOR_PRE_BODY (node))
3498             {
3499               spc -= 4;
3500               newline_and_indent (pp, spc + 2);
3501               pp_right_brace (pp);
3502             }
3503         }
3504       is_expr = false;
3505       break;
3506
3507     case OMP_SECTIONS:
3508       pp_string (pp, "#pragma omp sections");
3509       dump_omp_clauses (pp, OMP_SECTIONS_CLAUSES (node), spc, flags);
3510       goto dump_omp_body;
3511
3512     case OMP_SECTION:
3513       pp_string (pp, "#pragma omp section");
3514       goto dump_omp_body;
3515
3516     case OMP_SCAN:
3517       if (OMP_SCAN_CLAUSES (node))
3518         {
3519           pp_string (pp, "#pragma omp scan");
3520           dump_omp_clauses (pp, OMP_SCAN_CLAUSES (node), spc, flags);
3521         }
3522       goto dump_omp_body;
3523
3524     case OMP_MASTER:
3525       pp_string (pp, "#pragma omp master");
3526       goto dump_omp_body;
3527
3528     case OMP_TASKGROUP:
3529       pp_string (pp, "#pragma omp taskgroup");
3530       dump_omp_clauses (pp, OMP_TASKGROUP_CLAUSES (node), spc, flags);
3531       goto dump_omp_body;
3532
3533     case OMP_ORDERED:
3534       pp_string (pp, "#pragma omp ordered");
3535       dump_omp_clauses (pp, OMP_ORDERED_CLAUSES (node), spc, flags);
3536       goto dump_omp_body;
3537
3538     case OMP_CRITICAL:
3539       pp_string (pp, "#pragma omp critical");
3540       if (OMP_CRITICAL_NAME (node))
3541         {
3542           pp_space (pp);
3543           pp_left_paren (pp);
3544           dump_generic_node (pp, OMP_CRITICAL_NAME (node), spc,
3545                              flags, false);
3546           pp_right_paren (pp);
3547         }
3548       dump_omp_clauses (pp, OMP_CRITICAL_CLAUSES (node), spc, flags);
3549       goto dump_omp_body;
3550
3551     case OMP_ATOMIC:
3552       pp_string (pp, "#pragma omp atomic");
3553       dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
3554       newline_and_indent (pp, spc + 2);
3555       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3556       pp_space (pp);
3557       pp_equal (pp);
3558       pp_space (pp);
3559       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3560       break;
3561
3562     case OMP_ATOMIC_READ:
3563       pp_string (pp, "#pragma omp atomic read");
3564       dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
3565       newline_and_indent (pp, spc + 2);
3566       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3567       pp_space (pp);
3568       break;
3569
3570     case OMP_ATOMIC_CAPTURE_OLD:
3571     case OMP_ATOMIC_CAPTURE_NEW:
3572       pp_string (pp, "#pragma omp atomic capture");
3573       dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
3574       newline_and_indent (pp, spc + 2);
3575       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3576       pp_space (pp);
3577       pp_equal (pp);
3578       pp_space (pp);
3579       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3580       break;
3581
3582     case OMP_SINGLE:
3583       pp_string (pp, "#pragma omp single");
3584       dump_omp_clauses (pp, OMP_SINGLE_CLAUSES (node), spc, flags);
3585       goto dump_omp_body;
3586
3587     case OMP_CLAUSE:
3588       dump_omp_clause (pp, node, spc, flags);
3589       is_expr = false;
3590       break;
3591
3592     case TRANSACTION_EXPR:
3593       if (TRANSACTION_EXPR_OUTER (node))
3594         pp_string (pp, "__transaction_atomic [[outer]]");
3595       else if (TRANSACTION_EXPR_RELAXED (node))
3596         pp_string (pp, "__transaction_relaxed");
3597       else
3598         pp_string (pp, "__transaction_atomic");
3599       if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
3600         {
3601           newline_and_indent (pp, spc);
3602           pp_left_brace (pp);
3603           newline_and_indent (pp, spc + 2);
3604           dump_generic_node (pp, TRANSACTION_EXPR_BODY (node),
3605                              spc + 2, flags, false);
3606           newline_and_indent (pp, spc);
3607           pp_right_brace (pp);
3608         }
3609       is_expr = false;
3610       break;
3611
3612     case VEC_SERIES_EXPR:
3613     case VEC_WIDEN_MULT_HI_EXPR:
3614     case VEC_WIDEN_MULT_LO_EXPR:
3615     case VEC_WIDEN_MULT_EVEN_EXPR:
3616     case VEC_WIDEN_MULT_ODD_EXPR:
3617     case VEC_WIDEN_LSHIFT_HI_EXPR:
3618     case VEC_WIDEN_LSHIFT_LO_EXPR:
3619       pp_space (pp);
3620       for (str = get_tree_code_name (code); *str; str++)
3621         pp_character (pp, TOUPPER (*str));
3622       pp_string (pp, " < ");
3623       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3624       pp_string (pp, ", ");
3625       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3626       pp_string (pp, " > ");
3627       break;
3628
3629     case VEC_DUPLICATE_EXPR:
3630       pp_space (pp);
3631       for (str = get_tree_code_name (code); *str; str++)
3632         pp_character (pp, TOUPPER (*str));
3633       pp_string (pp, " < ");
3634       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3635       pp_string (pp, " > ");
3636       break;
3637
3638     case VEC_UNPACK_HI_EXPR:
3639       pp_string (pp, " VEC_UNPACK_HI_EXPR < ");
3640       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3641       pp_string (pp, " > ");
3642       break;
3643
3644     case VEC_UNPACK_LO_EXPR:
3645       pp_string (pp, " VEC_UNPACK_LO_EXPR < ");
3646       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3647       pp_string (pp, " > ");
3648       break;
3649
3650     case VEC_UNPACK_FLOAT_HI_EXPR:
3651       pp_string (pp, " VEC_UNPACK_FLOAT_HI_EXPR < ");
3652       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3653       pp_string (pp, " > ");
3654       break;
3655
3656     case VEC_UNPACK_FLOAT_LO_EXPR:
3657       pp_string (pp, " VEC_UNPACK_FLOAT_LO_EXPR < ");
3658       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3659       pp_string (pp, " > ");
3660       break;
3661
3662     case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
3663       pp_string (pp, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
3664       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3665       pp_string (pp, " > ");
3666       break;
3667
3668     case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
3669       pp_string (pp, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
3670       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3671       pp_string (pp, " > ");
3672       break;
3673
3674     case VEC_PACK_TRUNC_EXPR:
3675       pp_string (pp, " VEC_PACK_TRUNC_EXPR < ");
3676       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3677       pp_string (pp, ", ");
3678       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3679       pp_string (pp, " > ");
3680       break;
3681
3682     case VEC_PACK_SAT_EXPR:
3683       pp_string (pp, " VEC_PACK_SAT_EXPR < ");
3684       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3685       pp_string (pp, ", ");
3686       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3687       pp_string (pp, " > ");
3688       break;
3689
3690     case VEC_PACK_FIX_TRUNC_EXPR:
3691       pp_string (pp, " VEC_PACK_FIX_TRUNC_EXPR < ");
3692       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3693       pp_string (pp, ", ");
3694       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3695       pp_string (pp, " > ");
3696       break;
3697
3698     case VEC_PACK_FLOAT_EXPR:
3699       pp_string (pp, " VEC_PACK_FLOAT_EXPR < ");
3700       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
3701       pp_string (pp, ", ");
3702       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
3703       pp_string (pp, " > ");
3704       break;
3705
3706     case BLOCK:
3707       dump_block_node (pp, node, spc, flags);
3708       break;
3709
3710     case DEBUG_BEGIN_STMT:
3711       pp_string (pp, "# DEBUG BEGIN STMT");
3712       break;
3713
3714     default:
3715       NIY;
3716     }
3717
3718   if (is_stmt && is_expr)
3719     pp_semicolon (pp);
3720
3721   return spc;
3722 }
3723
3724 /* Print the declaration of a variable.  */
3725
3726 void
3727 print_declaration (pretty_printer *pp, tree t, int spc, dump_flags_t flags)
3728 {
3729   INDENT (spc);
3730
3731   if (TREE_CODE(t) == NAMELIST_DECL)
3732     {
3733       pp_string(pp, "namelist ");
3734       dump_decl_name (pp, t, flags);
3735       pp_semicolon (pp);
3736       return;
3737     }
3738
3739   if (TREE_CODE (t) == TYPE_DECL)
3740     pp_string (pp, "typedef ");
3741
3742   if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
3743     pp_string (pp, "register ");
3744
3745   if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
3746     pp_string (pp, "extern ");
3747   else if (TREE_STATIC (t))
3748     pp_string (pp, "static ");
3749
3750   /* Print the type and name.  */
3751   if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
3752     {
3753       tree tmp;
3754
3755       /* Print array's type.  */
3756       tmp = TREE_TYPE (t);
3757       while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
3758         tmp = TREE_TYPE (tmp);
3759       dump_generic_node (pp, TREE_TYPE (tmp), spc, flags, false);
3760
3761       /* Print variable's name.  */
3762       pp_space (pp);
3763       dump_generic_node (pp, t, spc, flags, false);
3764
3765       /* Print the dimensions.  */
3766       tmp = TREE_TYPE (t);
3767       while (TREE_CODE (tmp) == ARRAY_TYPE)
3768         {
3769           dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
3770           tmp = TREE_TYPE (tmp);
3771         }
3772     }
3773   else if (TREE_CODE (t) == FUNCTION_DECL)
3774     {
3775       dump_generic_node (pp, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
3776       pp_space (pp);
3777       dump_decl_name (pp, t, flags);
3778       dump_function_declaration (pp, TREE_TYPE (t), spc, flags);
3779     }
3780   else
3781     {
3782       /* Print type declaration.  */
3783       dump_generic_node (pp, TREE_TYPE (t), spc, flags, false);
3784
3785       /* Print variable's name.  */
3786       pp_space (pp);
3787       dump_generic_node (pp, t, spc, flags, false);
3788     }
3789
3790   if (VAR_P (t) && DECL_HARD_REGISTER (t))
3791     {
3792       pp_string (pp, " __asm__ ");
3793       pp_left_paren (pp);
3794       dump_generic_node (pp, DECL_ASSEMBLER_NAME (t), spc, flags, false);
3795       pp_right_paren (pp);
3796     }
3797
3798   /* The initial value of a function serves to determine whether the function
3799      is declared or defined.  So the following does not apply to function
3800      nodes.  */
3801   if (TREE_CODE (t) != FUNCTION_DECL)
3802     {
3803       /* Print the initial value.  */
3804       if (DECL_INITIAL (t))
3805         {
3806           pp_space (pp);
3807           pp_equal (pp);
3808           pp_space (pp);
3809           if (!(flags & TDF_SLIM))
3810             dump_generic_node (pp, DECL_INITIAL (t), spc, flags, false);
3811           else
3812             pp_string (pp, "<<< omitted >>>");
3813         }
3814     }
3815
3816   if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
3817     {
3818       pp_string (pp, " [value-expr: ");
3819       dump_generic_node (pp, DECL_VALUE_EXPR (t), spc, flags, false);
3820       pp_right_bracket (pp);
3821     }
3822
3823   pp_semicolon (pp);
3824 }
3825
3826
3827 /* Prints a structure: name, fields, and methods.
3828    FIXME: Still incomplete.  */
3829
3830 static void
3831 print_struct_decl (pretty_printer *pp, const_tree node, int spc,
3832                    dump_flags_t flags)
3833 {
3834   /* Print the name of the structure.  */
3835   if (TYPE_NAME (node))
3836     {
3837       INDENT (spc);
3838       if (TREE_CODE (node) == RECORD_TYPE)
3839         pp_string (pp, "struct ");
3840       else if ((TREE_CODE (node) == UNION_TYPE
3841                 || TREE_CODE (node) == QUAL_UNION_TYPE))
3842         pp_string (pp, "union ");
3843
3844       dump_generic_node (pp, TYPE_NAME (node), spc, TDF_NONE, false);
3845     }
3846
3847   /* Print the contents of the structure.  */
3848   pp_newline (pp);
3849   INDENT (spc);
3850   pp_left_brace (pp);
3851   pp_newline (pp);
3852
3853   /* Print the fields of the structure.  */
3854   {
3855     tree tmp;
3856     tmp = TYPE_FIELDS (node);
3857     while (tmp)
3858       {
3859         /* Avoid to print recursively the structure.  */
3860         /* FIXME : Not implemented correctly...,
3861            what about the case when we have a cycle in the contain graph? ...
3862            Maybe this could be solved by looking at the scope in which the
3863            structure was declared.  */
3864         if (TREE_TYPE (tmp) != node
3865             && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
3866                 || TREE_TYPE (TREE_TYPE (tmp)) != node))
3867           {
3868             print_declaration (pp, tmp, spc+2, flags);
3869             pp_newline (pp);
3870           }
3871         tmp = DECL_CHAIN (tmp);
3872       }
3873   }
3874   INDENT (spc);
3875   pp_right_brace (pp);
3876 }
3877
3878 /* Return the priority of the operator CODE.
3879
3880    From lowest to highest precedence with either left-to-right (L-R)
3881    or right-to-left (R-L) associativity]:
3882
3883      1  [L-R] ,
3884      2  [R-L] = += -= *= /= %= &= ^= |= <<= >>=
3885      3  [R-L] ?:
3886      4  [L-R] ||
3887      5  [L-R] &&
3888      6  [L-R] |
3889      7  [L-R] ^
3890      8  [L-R] &
3891      9  [L-R] == !=
3892     10  [L-R] < <= > >=
3893     11  [L-R] << >>
3894     12  [L-R] + -
3895     13  [L-R] * / %
3896     14  [R-L] ! ~ ++ -- + - * & (type) sizeof
3897     15  [L-R] fn() [] -> .
3898
3899    unary +, - and * have higher precedence than the corresponding binary
3900    operators.  */
3901
3902 int
3903 op_code_prio (enum tree_code code)
3904 {
3905   switch (code)
3906     {
3907     case TREE_LIST:
3908     case COMPOUND_EXPR:
3909     case BIND_EXPR:
3910       return 1;
3911
3912     case MODIFY_EXPR:
3913     case INIT_EXPR:
3914       return 2;
3915
3916     case COND_EXPR:
3917       return 3;
3918
3919     case TRUTH_OR_EXPR:
3920     case TRUTH_ORIF_EXPR:
3921       return 4;
3922
3923     case TRUTH_AND_EXPR:
3924     case TRUTH_ANDIF_EXPR:
3925       return 5;
3926
3927     case BIT_IOR_EXPR:
3928       return 6;
3929
3930     case BIT_XOR_EXPR:
3931     case TRUTH_XOR_EXPR:
3932       return 7;
3933
3934     case BIT_AND_EXPR:
3935       return 8;
3936
3937     case EQ_EXPR:
3938     case NE_EXPR:
3939       return 9;
3940
3941     case UNLT_EXPR:
3942     case UNLE_EXPR:
3943     case UNGT_EXPR:
3944     case UNGE_EXPR:
3945     case UNEQ_EXPR:
3946     case LTGT_EXPR:
3947     case ORDERED_EXPR:
3948     case UNORDERED_EXPR:
3949     case LT_EXPR:
3950     case LE_EXPR:
3951     case GT_EXPR:
3952     case GE_EXPR:
3953       return 10;
3954
3955     case LSHIFT_EXPR:
3956     case RSHIFT_EXPR:
3957     case LROTATE_EXPR:
3958     case RROTATE_EXPR:
3959     case VEC_WIDEN_LSHIFT_HI_EXPR:
3960     case VEC_WIDEN_LSHIFT_LO_EXPR:
3961     case WIDEN_LSHIFT_EXPR:
3962       return 11;
3963
3964     case WIDEN_SUM_EXPR:
3965     case PLUS_EXPR:
3966     case POINTER_PLUS_EXPR:
3967     case POINTER_DIFF_EXPR:
3968     case MINUS_EXPR:
3969       return 12;
3970
3971     case VEC_WIDEN_MULT_HI_EXPR:
3972     case VEC_WIDEN_MULT_LO_EXPR:
3973     case WIDEN_MULT_EXPR:
3974     case DOT_PROD_EXPR:
3975     case WIDEN_MULT_PLUS_EXPR:
3976     case WIDEN_MULT_MINUS_EXPR:
3977     case MULT_EXPR:
3978     case MULT_HIGHPART_EXPR:
3979     case TRUNC_DIV_EXPR:
3980     case CEIL_DIV_EXPR:
3981     case FLOOR_DIV_EXPR:
3982     case ROUND_DIV_EXPR:
3983     case RDIV_EXPR:
3984     case EXACT_DIV_EXPR:
3985     case TRUNC_MOD_EXPR:
3986     case CEIL_MOD_EXPR:
3987     case FLOOR_MOD_EXPR:
3988     case ROUND_MOD_EXPR:
3989       return 13;
3990
3991     case TRUTH_NOT_EXPR:
3992     case BIT_NOT_EXPR:
3993     case POSTINCREMENT_EXPR:
3994     case POSTDECREMENT_EXPR:
3995     case PREINCREMENT_EXPR:
3996     case PREDECREMENT_EXPR:
3997     case NEGATE_EXPR:
3998     case INDIRECT_REF:
3999     case ADDR_EXPR:
4000     case FLOAT_EXPR:
4001     CASE_CONVERT:
4002     case FIX_TRUNC_EXPR:
4003     case TARGET_EXPR:
4004       return 14;
4005
4006     case CALL_EXPR:
4007     case ARRAY_REF:
4008     case ARRAY_RANGE_REF:
4009     case COMPONENT_REF:
4010       return 15;
4011
4012       /* Special expressions.  */
4013     case MIN_EXPR:
4014     case MAX_EXPR:
4015     case ABS_EXPR:
4016     case REALPART_EXPR:
4017     case IMAGPART_EXPR:
4018     case VEC_UNPACK_HI_EXPR:
4019     case VEC_UNPACK_LO_EXPR:
4020     case VEC_UNPACK_FLOAT_HI_EXPR:
4021     case VEC_UNPACK_FLOAT_LO_EXPR:
4022     case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
4023     case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
4024     case VEC_PACK_TRUNC_EXPR:
4025     case VEC_PACK_SAT_EXPR:
4026       return 16;
4027
4028     default:
4029       /* Return an arbitrarily high precedence to avoid surrounding single
4030          VAR_DECLs in ()s.  */
4031       return 9999;
4032     }
4033 }
4034
4035 /* Return the priority of the operator OP.  */
4036
4037 int
4038 op_prio (const_tree op)
4039 {
4040   enum tree_code code;
4041
4042   if (op == NULL)
4043     return 9999;
4044
4045   code = TREE_CODE (op);
4046   if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
4047     return op_prio (TREE_OPERAND (op, 0));
4048
4049   return op_code_prio (code);
4050 }
4051
4052 /* Return the symbol associated with operator CODE.  */
4053
4054 const char *
4055 op_symbol_code (enum tree_code code)
4056 {
4057   switch (code)
4058     {
4059     case MODIFY_EXPR:
4060       return "=";
4061
4062     case TRUTH_OR_EXPR:
4063     case TRUTH_ORIF_EXPR:
4064       return "||";
4065
4066     case TRUTH_AND_EXPR:
4067     case TRUTH_ANDIF_EXPR:
4068       return "&&";
4069
4070     case BIT_IOR_EXPR:
4071       return "|";
4072
4073     case TRUTH_XOR_EXPR:
4074     case BIT_XOR_EXPR:
4075       return "^";
4076
4077     case ADDR_EXPR:
4078     case BIT_AND_EXPR:
4079       return "&";
4080
4081     case ORDERED_EXPR:
4082       return "ord";
4083     case UNORDERED_EXPR:
4084       return "unord";
4085
4086     case EQ_EXPR:
4087       return "==";
4088     case UNEQ_EXPR:
4089       return "u==";
4090
4091     case NE_EXPR:
4092       return "!=";
4093
4094     case LT_EXPR:
4095       return "<";
4096     case UNLT_EXPR:
4097       return "u<";
4098
4099     case LE_EXPR:
4100       return "<=";
4101     case UNLE_EXPR:
4102       return "u<=";
4103
4104     case GT_EXPR:
4105       return ">";
4106     case UNGT_EXPR:
4107       return "u>";
4108
4109     case GE_EXPR:
4110       return ">=";
4111     case UNGE_EXPR:
4112       return "u>=";
4113
4114     case LTGT_EXPR:
4115       return "<>";
4116
4117     case LSHIFT_EXPR:
4118       return "<<";
4119
4120     case RSHIFT_EXPR:
4121       return ">>";
4122
4123     case LROTATE_EXPR:
4124       return "r<<";
4125
4126     case RROTATE_EXPR:
4127       return "r>>";
4128
4129     case WIDEN_LSHIFT_EXPR:
4130       return "w<<";
4131
4132     case POINTER_PLUS_EXPR:
4133       return "+";
4134
4135     case PLUS_EXPR:
4136       return "+";
4137
4138     case WIDEN_SUM_EXPR:
4139       return "w+";
4140
4141     case WIDEN_MULT_EXPR:
4142       return "w*";
4143
4144     case MULT_HIGHPART_EXPR:
4145       return "h*";
4146
4147     case NEGATE_EXPR:
4148     case MINUS_EXPR:
4149     case POINTER_DIFF_EXPR:
4150       return "-";
4151
4152     case BIT_NOT_EXPR:
4153       return "~";
4154
4155     case TRUTH_NOT_EXPR:
4156       return "!";
4157
4158     case MULT_EXPR:
4159     case INDIRECT_REF:
4160       return "*";
4161
4162     case TRUNC_DIV_EXPR:
4163     case RDIV_EXPR:
4164       return "/";
4165
4166     case CEIL_DIV_EXPR:
4167       return "/[cl]";
4168
4169     case FLOOR_DIV_EXPR:
4170       return "/[fl]";
4171
4172     case ROUND_DIV_EXPR:
4173       return "/[rd]";
4174
4175     case EXACT_DIV_EXPR:
4176       return "/[ex]";
4177
4178     case TRUNC_MOD_EXPR:
4179       return "%";
4180
4181     case CEIL_MOD_EXPR:
4182       return "%[cl]";
4183
4184     case FLOOR_MOD_EXPR:
4185       return "%[fl]";
4186
4187     case ROUND_MOD_EXPR:
4188       return "%[rd]";
4189
4190     case PREDECREMENT_EXPR:
4191       return " --";
4192
4193     case PREINCREMENT_EXPR:
4194       return " ++";
4195
4196     case POSTDECREMENT_EXPR:
4197       return "-- ";
4198
4199     case POSTINCREMENT_EXPR:
4200       return "++ ";
4201
4202     case MAX_EXPR:
4203       return "max";
4204
4205     case MIN_EXPR:
4206       return "min";
4207
4208     default:
4209       return "<<< ??? >>>";
4210     }
4211 }
4212
4213 /* Return the symbol associated with operator OP.  */
4214
4215 static const char *
4216 op_symbol (const_tree op)
4217 {
4218   return op_symbol_code (TREE_CODE (op));
4219 }
4220
4221 /* Prints the name of a call.  NODE is the CALL_EXPR_FN of a CALL_EXPR or
4222    the gimple_call_fn of a GIMPLE_CALL.  */
4223
4224 void
4225 print_call_name (pretty_printer *pp, tree node, dump_flags_t flags)
4226 {
4227   tree op0 = node;
4228
4229   if (TREE_CODE (op0) == NON_LVALUE_EXPR)
4230     op0 = TREE_OPERAND (op0, 0);
4231
4232  again:
4233   switch (TREE_CODE (op0))
4234     {
4235     case VAR_DECL:
4236     case PARM_DECL:
4237     case FUNCTION_DECL:
4238       dump_function_name (pp, op0, flags);
4239       break;
4240
4241     case ADDR_EXPR:
4242     case INDIRECT_REF:
4243     CASE_CONVERT:
4244       op0 = TREE_OPERAND (op0, 0);
4245       goto again;
4246
4247     case COND_EXPR:
4248       pp_left_paren (pp);
4249       dump_generic_node (pp, TREE_OPERAND (op0, 0), 0, flags, false);
4250       pp_string (pp, ") ? ");
4251       dump_generic_node (pp, TREE_OPERAND (op0, 1), 0, flags, false);
4252       pp_string (pp, " : ");
4253       dump_generic_node (pp, TREE_OPERAND (op0, 2), 0, flags, false);
4254       break;
4255
4256     case ARRAY_REF:
4257       if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
4258         dump_function_name (pp, TREE_OPERAND (op0, 0), flags);
4259       else
4260         dump_generic_node (pp, op0, 0, flags, false);
4261       break;
4262
4263     case MEM_REF:
4264       if (integer_zerop (TREE_OPERAND (op0, 1)))
4265         {
4266           op0 = TREE_OPERAND (op0, 0);
4267           goto again;
4268         }
4269       /* Fallthru.  */
4270     case COMPONENT_REF:
4271     case SSA_NAME:
4272     case OBJ_TYPE_REF:
4273       dump_generic_node (pp, op0, 0, flags, false);
4274       break;
4275
4276     default:
4277       NIY;
4278     }
4279 }
4280
4281 /* Print the first N characters in the array STR, replacing non-printable
4282    characters (including embedded nuls) with unambiguous escape sequences.  */
4283
4284 void
4285 pretty_print_string (pretty_printer *pp, const char *str, size_t n)
4286 {
4287   if (str == NULL)
4288     return;
4289
4290   for ( ; n; --n, ++str)
4291     {
4292       switch (str[0])
4293         {
4294         case '\b':
4295           pp_string (pp, "\\b");
4296           break;
4297
4298         case '\f':
4299           pp_string (pp, "\\f");
4300           break;
4301
4302         case '\n':
4303           pp_string (pp, "\\n");
4304           break;
4305
4306         case '\r':
4307           pp_string (pp, "\\r");
4308           break;
4309
4310         case '\t':
4311           pp_string (pp, "\\t");
4312           break;
4313
4314         case '\v':
4315           pp_string (pp, "\\v");
4316           break;
4317
4318         case '\\':
4319           pp_string (pp, "\\\\");
4320           break;
4321
4322         case '\"':
4323           pp_string (pp, "\\\"");
4324           break;
4325
4326         case '\'':
4327           pp_string (pp, "\\'");
4328           break;
4329
4330         default:
4331           if (str[0] || n > 1)
4332             {
4333               if (!ISPRINT (str[0]))
4334                 {
4335                   char buf[5];
4336                   sprintf (buf, "\\x%02x", (unsigned char)str[0]);
4337                   pp_string (pp, buf);
4338                 }
4339               else
4340                 pp_character (pp, str[0]);
4341               break;
4342             }
4343         }
4344     }
4345 }
4346
4347 static void
4348 maybe_init_pretty_print (FILE *file)
4349 {
4350   if (!tree_pp)
4351     {
4352       tree_pp = new pretty_printer ();
4353       pp_needs_newline (tree_pp) = true;
4354       pp_translate_identifiers (tree_pp) = false;
4355     }
4356
4357   tree_pp->buffer->stream = file;
4358 }
4359
4360 static void
4361 newline_and_indent (pretty_printer *pp, int spc)
4362 {
4363   pp_newline (pp);
4364   INDENT (spc);
4365 }
4366
4367 /* Handle the %K format for TEXT.  Separate from default_tree_printer
4368    so it can also be used in front ends.
4369    The location LOC and BLOCK are expected to be extracted by the caller
4370    from the %K argument arg via EXPR_LOCATION(arg) and TREE_BLOCK(arg).  */
4371
4372 void
4373 percent_K_format (text_info *text, location_t loc, tree block)
4374 {
4375   text->set_location (0, loc, SHOW_RANGE_WITH_CARET);
4376   gcc_assert (pp_ti_abstract_origin (text) != NULL);
4377   *pp_ti_abstract_origin (text) = NULL;
4378
4379   while (block
4380          && TREE_CODE (block) == BLOCK
4381          && BLOCK_ABSTRACT_ORIGIN (block))
4382     {
4383       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
4384       if (TREE_CODE (ao) == FUNCTION_DECL)
4385         {
4386           *pp_ti_abstract_origin (text) = block;
4387           break;
4388         }
4389       block = BLOCK_SUPERCONTEXT (block);
4390     }
4391 }
4392
4393 /* Print the identifier ID to PRETTY-PRINTER.  */
4394
4395 void
4396 pp_tree_identifier (pretty_printer *pp, tree id)
4397 {
4398   if (pp_translate_identifiers (pp))
4399     {
4400       const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
4401       pp_append_text (pp, text, text + strlen (text));
4402     }
4403   else
4404     pp_append_text (pp, IDENTIFIER_POINTER (id),
4405                     IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
4406 }
4407
4408 /* A helper function that is used to dump function information before the
4409    function dump.  */
4410
4411 void
4412 dump_function_header (FILE *dump_file, tree fdecl, dump_flags_t flags)
4413 {
4414   const char *dname, *aname;
4415   struct cgraph_node *node = cgraph_node::get (fdecl);
4416   struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
4417
4418   dname = lang_hooks.decl_printable_name (fdecl, 1);
4419
4420   if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
4421     aname = (IDENTIFIER_POINTER
4422              (DECL_ASSEMBLER_NAME (fdecl)));
4423   else
4424     aname = "<unset-asm-name>";
4425
4426   fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
4427            dname, aname, fun->funcdef_no);
4428   if (!(flags & TDF_NOUID))
4429     fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
4430   if (node)
4431     {
4432       fprintf (dump_file, ", cgraph_uid=%d", node->get_uid ());
4433       fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->order,
4434                node->frequency == NODE_FREQUENCY_HOT
4435                ? " (hot)"
4436                : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
4437                ? " (unlikely executed)"
4438                : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
4439                ? " (executed once)"
4440                : "");
4441     }
4442   else
4443     fprintf (dump_file, ")\n\n");
4444 }
4445
4446 /* Dump double_int D to pretty_printer PP.  UNS is true
4447    if D is unsigned and false otherwise.  */
4448 void
4449 pp_double_int (pretty_printer *pp, double_int d, bool uns)
4450 {
4451   if (d.fits_shwi ())
4452     pp_wide_integer (pp, d.low);
4453   else if (d.fits_uhwi ())
4454     pp_unsigned_wide_integer (pp, d.low);
4455   else
4456     {
4457       unsigned HOST_WIDE_INT low = d.low;
4458       HOST_WIDE_INT high = d.high;
4459       if (!uns && d.is_negative ())
4460         {
4461           pp_minus (pp);
4462           high = ~high + !low;
4463           low = -low;
4464         }
4465       /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
4466          systems?  */
4467       sprintf (pp_buffer (pp)->digit_buffer,
4468                HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4469                (unsigned HOST_WIDE_INT) high, low);
4470       pp_string (pp, pp_buffer (pp)->digit_buffer);
4471     }
4472 }
4473
4474 #if __GNUC__ >= 10
4475 #  pragma GCC diagnostic pop
4476 #endif