gcc/tree-pretty-print.c

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