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