gcc/tree-pretty-print.c

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