gcc/tree-pretty-print.c

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