gcc/tree-pretty-print.c

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