gcc/tree-pretty-print.c

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