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