gcc/tree-pretty-print.c

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