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