gcc/tree-pretty-print.c

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