gcc/tree-pretty-print.c

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