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