gcc/tree-pretty-print.c

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