gcc/tree-pretty-print.c

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