gcc/tree-pretty-print.c

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