gcc/tree-pretty-print.c

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