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