gcc/tree-pretty-print.c

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