gcc/tree-pretty-print.c

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