gcc/tree-pretty-print.c

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