gcc/tree-pretty-print.c

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