gcc/gimple-pretty-print.c

   1 /* Pretty formatting of GIMPLE statements and expressions.
   2    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   3    Free Software Foundation, Inc.
   4    Contributed by Aldy Hernandez <aldyh@redhat.com> and
   5    Diego Novillo <dnovillo@google.com>
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "tree.h"
  28 #include "diagnostic.h"
  29 #include "tree-pretty-print.h"
  30 #include "gimple-pretty-print.h"
  31 #include "hashtab.h"
  32 #include "tree-flow.h"
  33 #include "tree-pass.h"
  34 #include "gimple.h"
  35 #include "value-prof.h"
  36
  37 #define INDENT(SPACE)                                                   \
  38   do { int i; for (i = 0; i < SPACE; i++) pp_space (buffer); } while (0)
  39
  40 static pretty_printer buffer;
  41 static bool initialized = false;
  42
  43 #define GIMPLE_NIY do_niy (buffer,gs)
  44
  45 /* Try to print on BUFFER a default message for the unrecognized
  46    gimple statement GS.  */
  47
  48 static void
  49 do_niy (pretty_printer *buffer, gimple gs)
  50 {
  51   pp_printf (buffer, "<<< Unknown GIMPLE statement: %s >>>\n",
  52              gimple_code_name[(int) gimple_code (gs)]);
  53 }
  54
  55
  56 /* Initialize the pretty printer on FILE if needed.  */
  57
  58 static void
  59 maybe_init_pretty_print (FILE *file)
  60 {
  61   if (!initialized)
  62     {
  63       pp_construct (&buffer, NULL, 0);
  64       pp_needs_newline (&buffer) = true;
  65       initialized = true;
  66     }
  67
  68   buffer.buffer->stream = file;
  69 }
  70
  71
  72 /* Emit a newline and SPC indentantion spaces to BUFFER.  */
  73
  74 static void
  75 newline_and_indent (pretty_printer *buffer, int spc)
  76 {
  77   pp_newline (buffer);
  78   INDENT (spc);
  79 }
  80
  81
  82 /* Print the GIMPLE statement GS on stderr.  */
  83
  84 DEBUG_FUNCTION void
  85 debug_gimple_stmt (gimple gs)
  86 {
  87   print_gimple_stmt (stderr, gs, 0, TDF_VOPS|TDF_MEMSYMS);
  88   fprintf (stderr, "\n");
  89 }
  90
  91
  92 /* Dump GIMPLE statement G to FILE using SPC indentantion spaces and
  93    FLAGS as in dump_gimple_stmt.  */
  94
  95 void
  96 print_gimple_stmt (FILE *file, gimple g, int spc, int flags)
  97 {
  98   maybe_init_pretty_print (file);
  99   dump_gimple_stmt (&buffer, g, spc, flags);
 100   pp_flush (&buffer);
 101 }
 102
 103
 104 /* Dump GIMPLE statement G to FILE using SPC indentantion spaces and
 105    FLAGS as in dump_gimple_stmt.  Print only the right-hand side
 106    of the statement.  */
 107
 108 void
 109 print_gimple_expr (FILE *file, gimple g, int spc, int flags)
 110 {
 111   flags |= TDF_RHS_ONLY;
 112   maybe_init_pretty_print (file);
 113   dump_gimple_stmt (&buffer, g, spc, flags);
 114 }
 115
 116
 117 /* Print the GIMPLE sequence SEQ on BUFFER using SPC indentantion
 118    spaces and FLAGS as in dump_gimple_stmt.  */
 119
 120 static void
 121 dump_gimple_seq (pretty_printer *buffer, gimple_seq seq, int spc, int flags)
 122 {
 123   gimple_stmt_iterator i;
 124
 125   for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
 126     {
 127       gimple gs = gsi_stmt (i);
 128       INDENT (spc);
 129       dump_gimple_stmt (buffer, gs, spc, flags);
 130       if (!gsi_one_before_end_p (i))
 131         pp_newline (buffer);
 132     }
 133 }
 134
 135
 136 /* Dump GIMPLE sequence SEQ to FILE using SPC indentantion spaces and
 137    FLAGS as in dump_gimple_stmt.  */
 138
 139 void
 140 print_gimple_seq (FILE *file, gimple_seq seq, int spc, int flags)
 141 {
 142   maybe_init_pretty_print (file);
 143   dump_gimple_seq (&buffer, seq, spc, flags);
 144   pp_flush (&buffer);
 145 }
 146
 147
 148 /* Print the GIMPLE sequence SEQ on stderr.  */
 149
 150 DEBUG_FUNCTION void
 151 debug_gimple_seq (gimple_seq seq)
 152 {
 153   print_gimple_seq (stderr, seq, 0, TDF_VOPS|TDF_MEMSYMS);
 154 }
 155
 156
 157 /* A simple helper to pretty-print some of the gimple tuples in the printf
 158    style. The format modifiers are preceeded by '%' and are:
 159      'G' - outputs a string corresponding to the code of the given gimple,
 160      'S' - outputs a gimple_seq with indent of spc + 2,
 161      'T' - outputs the tree t,
 162      'd' - outputs an int as a decimal,
 163      's' - outputs a string,
 164      'n' - outputs a newline,
 165      '+' - increases indent by 2 then outputs a newline,
 166      '-' - decreases indent by 2 then outputs a newline.   */
 167
 168 static void
 169 dump_gimple_fmt (pretty_printer *buffer, int spc, int flags,
 170                  const char *fmt, ...)
 171 {
 172   va_list args;
 173   const char *c;
 174   const char *tmp;
 175
 176   va_start (args, fmt);
 177   for (c = fmt; *c; c++)
 178     {
 179       if (*c == '%')
 180         {
 181           gimple_seq seq;
 182           tree t;
 183           gimple g;
 184           switch (*++c)
 185             {
 186               case 'G':
 187                 g = va_arg (args, gimple);
 188                 tmp = gimple_code_name[gimple_code (g)];
 189                 pp_string (buffer, tmp);
 190                 break;
 191
 192               case 'S':
 193                 seq = va_arg (args, gimple_seq);
 194                 pp_newline (buffer);
 195                 dump_gimple_seq (buffer, seq, spc + 2, flags);
 196                 newline_and_indent (buffer, spc);
 197                 break;
 198
 199               case 'T':
 200                 t = va_arg (args, tree);
 201                 if (t == NULL_TREE)
 202                   pp_string (buffer, "NULL");
 203                 else
 204                   dump_generic_node (buffer, t, spc, flags, false);
 205                 break;
 206
 207               case 'd':
 208                 pp_decimal_int (buffer, va_arg (args, int));
 209                 break;
 210
 211               case 's':
 212                 pp_string (buffer, va_arg (args, char *));
 213                 break;
 214
 215               case 'n':
 216                 newline_and_indent (buffer, spc);
 217                 break;
 218
 219               case '+':
 220                 spc += 2;
 221                 newline_and_indent (buffer, spc);
 222                 break;
 223
 224               case '-':
 225                 spc -= 2;
 226                 newline_and_indent (buffer, spc);
 227                 break;
 228
 229               default:
 230                 gcc_unreachable ();
 231             }
 232         }
 233       else
 234         pp_character (buffer, *c);
 235     }
 236   va_end (args);
 237 }
 238
 239
 240 /* Helper for dump_gimple_assign.  Print the unary RHS of the
 241    assignment GS.  BUFFER, SPC and FLAGS are as in dump_gimple_stmt.  */
 242
 243 static void
 244 dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
 245 {
 246   enum tree_code rhs_code = gimple_assign_rhs_code (gs);
 247   tree lhs = gimple_assign_lhs (gs);
 248   tree rhs = gimple_assign_rhs1 (gs);
 249
 250   switch (rhs_code)
 251     {
 252     case VIEW_CONVERT_EXPR:
 253     case ASSERT_EXPR:
 254       dump_generic_node (buffer, rhs, spc, flags, false);
 255       break;
 256
 257     case FIXED_CONVERT_EXPR:
 258     case ADDR_SPACE_CONVERT_EXPR:
 259     case FIX_TRUNC_EXPR:
 260     case FLOAT_EXPR:
 261     CASE_CONVERT:
 262       pp_character (buffer, '(');
 263       dump_generic_node (buffer, TREE_TYPE (lhs), spc, flags, false);
 264       pp_string (buffer, ") ");
 265       if (op_prio (rhs) < op_code_prio (rhs_code))
 266         {
 267           pp_character (buffer, '(');
 268           dump_generic_node (buffer, rhs, spc, flags, false);
 269           pp_character (buffer, ')');
 270         }
 271       else
 272         dump_generic_node (buffer, rhs, spc, flags, false);
 273       break;
 274
 275     case PAREN_EXPR:
 276       pp_string (buffer, "((");
 277       dump_generic_node (buffer, rhs, spc, flags, false);
 278       pp_string (buffer, "))");
 279       break;
 280
 281     case ABS_EXPR:
 282       pp_string (buffer, "ABS_EXPR <");
 283       dump_generic_node (buffer, rhs, spc, flags, false);
 284       pp_character (buffer, '>');
 285       break;
 286
 287     default:
 288       if (TREE_CODE_CLASS (rhs_code) == tcc_declaration
 289           || TREE_CODE_CLASS (rhs_code) == tcc_constant
 290           || TREE_CODE_CLASS (rhs_code) == tcc_reference
 291           || rhs_code == SSA_NAME
 292           || rhs_code == ADDR_EXPR
 293           || rhs_code == CONSTRUCTOR)
 294         {
 295           dump_generic_node (buffer, rhs, spc, flags, false);
 296           break;
 297         }
 298       else if (rhs_code == BIT_NOT_EXPR)
 299         pp_character (buffer, '~');
 300       else if (rhs_code == TRUTH_NOT_EXPR)
 301         pp_character (buffer, '!');
 302       else if (rhs_code == NEGATE_EXPR)
 303         pp_character (buffer, '-');
 304       else
 305         {
 306           pp_character (buffer, '[');
 307           pp_string (buffer, tree_code_name [rhs_code]);
 308           pp_string (buffer, "] ");
 309         }
 310
 311       if (op_prio (rhs) < op_code_prio (rhs_code))
 312         {
 313           pp_character (buffer, '(');
 314           dump_generic_node (buffer, rhs, spc, flags, false);
 315           pp_character (buffer, ')');
 316         }
 317       else
 318         dump_generic_node (buffer, rhs, spc, flags, false);
 319       break;
 320     }
 321 }
 322
 323
 324 /* Helper for dump_gimple_assign.  Print the binary RHS of the
 325    assignment GS.  BUFFER, SPC and FLAGS are as in dump_gimple_stmt.  */
 326
 327 static void
 328 dump_binary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
 329 {
 330   const char *p;
 331   enum tree_code code = gimple_assign_rhs_code (gs);
 332   switch (code)
 333     {
 334     case COMPLEX_EXPR:
 335     case MIN_EXPR:
 336     case MAX_EXPR:
 337     case VEC_WIDEN_MULT_HI_EXPR:
 338     case VEC_WIDEN_MULT_LO_EXPR:
 339     case VEC_PACK_TRUNC_EXPR:
 340     case VEC_PACK_SAT_EXPR:
 341     case VEC_PACK_FIX_TRUNC_EXPR:
 342     case VEC_EXTRACT_EVEN_EXPR:
 343     case VEC_EXTRACT_ODD_EXPR:
 344     case VEC_INTERLEAVE_HIGH_EXPR:
 345     case VEC_INTERLEAVE_LOW_EXPR:
 346       for (p = tree_code_name [(int) code]; *p; p++)
 347         pp_character (buffer, TOUPPER (*p));
 348       pp_string (buffer, " <");
 349       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 350       pp_string (buffer, ", ");
 351       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 352       pp_character (buffer, '>');
 353       break;
 354
 355     default:
 356       if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code))
 357         {
 358           pp_character (buffer, '(');
 359           dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags,
 360                              false);
 361           pp_character (buffer, ')');
 362         }
 363       else
 364         dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 365       pp_space (buffer);
 366       pp_string (buffer, op_symbol_code (gimple_assign_rhs_code (gs)));
 367       pp_space (buffer);
 368       if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code))
 369         {
 370           pp_character (buffer, '(');
 371           dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags,
 372                              false);
 373           pp_character (buffer, ')');
 374         }
 375       else
 376         dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 377     }
 378 }
 379
 380 /* Helper for dump_gimple_assign.  Print the ternary RHS of the
 381    assignment GS.  BUFFER, SPC and FLAGS are as in dump_gimple_stmt.  */
 382
 383 static void
 384 dump_ternary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
 385 {
 386   const char *p;
 387   enum tree_code code = gimple_assign_rhs_code (gs);
 388   switch (code)
 389     {
 390     case WIDEN_MULT_PLUS_EXPR:
 391     case WIDEN_MULT_MINUS_EXPR:
 392       for (p = tree_code_name [(int) code]; *p; p++)
 393         pp_character (buffer, TOUPPER (*p));
 394       pp_string (buffer, " <");
 395       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 396       pp_string (buffer, ", ");
 397       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 398       pp_string (buffer, ", ");
 399       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 400       pp_character (buffer, '>');
 401       break;
 402
 403     case FMA_EXPR:
 404       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 405       pp_string (buffer, " * ");
 406       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 407       pp_string (buffer, " + ");
 408       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 409       break;
 410
 411     case DOT_PROD_EXPR:
 412       pp_string (buffer, "DOT_PROD_EXPR <");
 413       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 414       pp_string (buffer, ", ");
 415       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 416       pp_string (buffer, ", ");
 417       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 418       pp_string (buffer, ">");
 419       break;
 420
 421     case REALIGN_LOAD_EXPR:
 422       pp_string (buffer, "REALIGN_LOAD <");
 423       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 424       pp_string (buffer, ", ");
 425       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 426       pp_string (buffer, ", ");
 427       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 428       pp_string (buffer, ">");
 429       break;
 430
 431     default:
 432       gcc_unreachable ();
 433     }
 434 }
 435
 436
 437 /* Dump the gimple assignment GS.  BUFFER, SPC and FLAGS are as in
 438    dump_gimple_stmt.  */
 439
 440 static void
 441 dump_gimple_assign (pretty_printer *buffer, gimple gs, int spc, int flags)
 442 {
 443   if (flags & TDF_RAW)
 444     {
 445       tree last;
 446       if (gimple_num_ops (gs) == 2)
 447         last = NULL_TREE;
 448       else if (gimple_num_ops (gs) == 3)
 449         last = gimple_assign_rhs2 (gs);
 450       else
 451         gcc_unreachable ();
 452
 453       dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T>", gs,
 454                        tree_code_name[gimple_assign_rhs_code (gs)],
 455                        gimple_assign_lhs (gs), gimple_assign_rhs1 (gs), last);
 456     }
 457   else
 458     {
 459       if (!(flags & TDF_RHS_ONLY))
 460         {
 461           dump_generic_node (buffer, gimple_assign_lhs (gs), spc, flags, false);
 462           pp_space (buffer);
 463           pp_character (buffer, '=');
 464
 465           if (gimple_assign_nontemporal_move_p (gs))
 466             pp_string (buffer, "{nt}");
 467
 468           if (gimple_has_volatile_ops (gs))
 469             pp_string (buffer, "{v}");
 470
 471           pp_space (buffer);
 472         }
 473
 474       if (gimple_num_ops (gs) == 2)
 475         dump_unary_rhs (buffer, gs, spc, flags);
 476       else if (gimple_num_ops (gs) == 3)
 477         dump_binary_rhs (buffer, gs, spc, flags);
 478       else if (gimple_num_ops (gs) == 4)
 479         dump_ternary_rhs (buffer, gs, spc, flags);
 480       else
 481         gcc_unreachable ();
 482       if (!(flags & TDF_RHS_ONLY))
 483         pp_semicolon(buffer);
 484     }
 485 }
 486
 487
 488 /* Dump the return statement GS.  BUFFER, SPC and FLAGS are as in
 489    dump_gimple_stmt.  */
 490
 491 static void
 492 dump_gimple_return (pretty_printer *buffer, gimple gs, int spc, int flags)
 493 {
 494   tree t;
 495
 496   t = gimple_return_retval (gs);
 497   if (flags & TDF_RAW)
 498     dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, t);
 499   else
 500     {
 501       pp_string (buffer, "return");
 502       if (t)
 503         {
 504           pp_space (buffer);
 505           dump_generic_node (buffer, t, spc, flags, false);
 506         }
 507       pp_semicolon (buffer);
 508     }
 509 }
 510
 511
 512 /* Dump the call arguments for a gimple call. BUFFER, FLAGS are as in
 513    dump_gimple_call.  */
 514
 515 static void
 516 dump_gimple_call_args (pretty_printer *buffer, gimple gs, int flags)
 517 {
 518   size_t i;
 519
 520   for (i = 0; i < gimple_call_num_args (gs); i++)
 521     {
 522       dump_generic_node (buffer, gimple_call_arg (gs, i), 0, flags, false);
 523       if (i < gimple_call_num_args (gs) - 1)
 524         pp_string (buffer, ", ");
 525     }
 526
 527   if (gimple_call_va_arg_pack_p (gs))
 528     {
 529       if (gimple_call_num_args (gs) > 0)
 530         {
 531           pp_character (buffer, ',');
 532           pp_space (buffer);
 533         }
 534
 535       pp_string (buffer, "__builtin_va_arg_pack ()");
 536     }
 537 }
 538
 539 /* Dump the points-to solution *PT to BUFFER.  */
 540
 541 static void
 542 pp_points_to_solution (pretty_printer *buffer, struct pt_solution *pt)
 543 {
 544   if (pt->anything)
 545     {
 546       pp_string (buffer, "anything ");
 547       return;
 548     }
 549   if (pt->nonlocal)
 550     pp_string (buffer, "nonlocal ");
 551   if (pt->escaped)
 552     pp_string (buffer, "escaped ");
 553   if (pt->ipa_escaped)
 554     pp_string (buffer, "unit-escaped ");
 555   if (pt->null)
 556     pp_string (buffer, "null ");
 557   if (pt->vars
 558       && !bitmap_empty_p (pt->vars))
 559     {
 560       bitmap_iterator bi;
 561       unsigned i;
 562       pp_string (buffer, "{ ");
 563       EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
 564         {
 565           tree var = referenced_var_lookup (cfun, i);
 566           if (var)
 567             {
 568               dump_generic_node (buffer, var, 0, dump_flags, false);
 569               if (DECL_PT_UID (var) != DECL_UID (var))
 570                 {
 571                   pp_string (buffer, "ptD.");
 572                   pp_decimal_int (buffer, DECL_PT_UID (var));
 573                 }
 574             }
 575           else
 576             {
 577               pp_string (buffer, "D.");
 578               pp_decimal_int (buffer, i);
 579             }
 580           pp_character (buffer, ' ');
 581         }
 582       pp_character (buffer, '}');
 583       if (pt->vars_contains_global)
 584         pp_string (buffer, " (glob)");
 585       if (pt->vars_contains_restrict)
 586         pp_string (buffer, " (restr)");
 587     }
 588 }
 589
 590 /* Dump the call statement GS.  BUFFER, SPC and FLAGS are as in
 591    dump_gimple_stmt.  */
 592
 593 static void
 594 dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
 595 {
 596   tree lhs = gimple_call_lhs (gs);
 597
 598   if (flags & TDF_ALIAS)
 599     {
 600       struct pt_solution *pt;
 601       pt = gimple_call_use_set (gs);
 602       if (!pt_solution_empty_p (pt))
 603         {
 604           pp_string (buffer, "# USE = ");
 605           pp_points_to_solution (buffer, pt);
 606           newline_and_indent (buffer, spc);
 607         }
 608       pt = gimple_call_clobber_set (gs);
 609       if (!pt_solution_empty_p (pt))
 610         {
 611           pp_string (buffer, "# CLB = ");
 612           pp_points_to_solution (buffer, pt);
 613           newline_and_indent (buffer, spc);
 614         }
 615     }
 616
 617   if (flags & TDF_RAW)
 618     {
 619       if (gimple_call_internal_p (gs))
 620         dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T", gs,
 621                          internal_fn_name (gimple_call_internal_fn (gs)), lhs);
 622       else
 623         dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T",
 624                          gs, gimple_call_fn (gs), lhs);
 625       if (gimple_call_num_args (gs) > 0)
 626         {
 627           pp_string (buffer, ", ");
 628           dump_gimple_call_args (buffer, gs, flags);
 629         }
 630       pp_character (buffer, '>');
 631     }
 632   else
 633     {
 634       if (lhs && !(flags & TDF_RHS_ONLY))
 635         {
 636           dump_generic_node (buffer, lhs, spc, flags, false);
 637           pp_string (buffer, " =");
 638
 639           if (gimple_has_volatile_ops (gs))
 640             pp_string (buffer, "{v}");
 641
 642           pp_space (buffer);
 643         }
 644       if (gimple_call_internal_p (gs))
 645         pp_string (buffer, internal_fn_name (gimple_call_internal_fn (gs)));
 646       else
 647         print_call_name (buffer, gimple_call_fn (gs), flags);
 648       pp_string (buffer, " (");
 649       dump_gimple_call_args (buffer, gs, flags);
 650       pp_character (buffer, ')');
 651       if (!(flags & TDF_RHS_ONLY))
 652         pp_semicolon (buffer);
 653     }
 654
 655   if (gimple_call_chain (gs))
 656     {
 657       pp_string (buffer, " [static-chain: ");
 658       dump_generic_node (buffer, gimple_call_chain (gs), spc, flags, false);
 659       pp_character (buffer, ']');
 660     }
 661
 662   if (gimple_call_return_slot_opt_p (gs))
 663     pp_string (buffer, " [return slot optimization]");
 664
 665   if (gimple_call_tail_p (gs))
 666     pp_string (buffer, " [tail call]");
 667 }
 668
 669
 670 /* Dump the switch statement GS.  BUFFER, SPC and FLAGS are as in
 671    dump_gimple_stmt.  */
 672
 673 static void
 674 dump_gimple_switch (pretty_printer *buffer, gimple gs, int spc, int flags)
 675 {
 676   unsigned int i;
 677
 678   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
 679   if (flags & TDF_RAW)
 680     dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", gs,
 681                    gimple_switch_index (gs));
 682   else
 683     {
 684       pp_string (buffer, "switch (");
 685       dump_generic_node (buffer, gimple_switch_index (gs), spc, flags, true);
 686       pp_string (buffer, ") <");
 687     }
 688
 689   for (i = 0; i < gimple_switch_num_labels (gs); i++)
 690     {
 691       tree case_label = gimple_switch_label (gs, i);
 692       if (case_label == NULL_TREE)
 693         continue;
 694
 695       dump_generic_node (buffer, case_label, spc, flags, false);
 696       pp_character (buffer, ' ');
 697       dump_generic_node (buffer, CASE_LABEL (case_label), spc, flags, false);
 698       if (i < gimple_switch_num_labels (gs) - 1)
 699         pp_string (buffer, ", ");
 700     }
 701   pp_character (buffer, '>');
 702 }
 703
 704
 705 /* Dump the gimple conditional GS.  BUFFER, SPC and FLAGS are as in
 706    dump_gimple_stmt.  */
 707
 708 static void
 709 dump_gimple_cond (pretty_printer *buffer, gimple gs, int spc, int flags)
 710 {
 711   if (flags & TDF_RAW)
 712     dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
 713                    tree_code_name [gimple_cond_code (gs)],
 714                    gimple_cond_lhs (gs), gimple_cond_rhs (gs),
 715                    gimple_cond_true_label (gs), gimple_cond_false_label (gs));
 716   else
 717     {
 718       if (!(flags & TDF_RHS_ONLY))
 719         pp_string (buffer, "if (");
 720       dump_generic_node (buffer, gimple_cond_lhs (gs), spc, flags, false);
 721       pp_space (buffer);
 722       pp_string (buffer, op_symbol_code (gimple_cond_code (gs)));
 723       pp_space (buffer);
 724       dump_generic_node (buffer, gimple_cond_rhs (gs), spc, flags, false);
 725       if (!(flags & TDF_RHS_ONLY))
 726         {
 727           pp_character (buffer, ')');
 728
 729           if (gimple_cond_true_label (gs))
 730             {
 731               pp_string (buffer, " goto ");
 732               dump_generic_node (buffer, gimple_cond_true_label (gs),
 733                                  spc, flags, false);
 734               pp_semicolon (buffer);
 735             }
 736           if (gimple_cond_false_label (gs))
 737             {
 738               pp_string (buffer, " else goto ");
 739               dump_generic_node (buffer, gimple_cond_false_label (gs),
 740                                  spc, flags, false);
 741               pp_semicolon (buffer);
 742             }
 743         }
 744     }
 745 }
 746
 747
 748 /* Dump a GIMPLE_LABEL tuple on the pretty_printer BUFFER, SPC
 749    spaces of indent.  FLAGS specifies details to show in the dump (see
 750    TDF_* in tree-pass.h).  */
 751
 752 static void
 753 dump_gimple_label (pretty_printer *buffer, gimple gs, int spc, int flags)
 754 {
 755   tree label = gimple_label_label (gs);
 756   if (flags & TDF_RAW)
 757       dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label);
 758   else
 759     {
 760       dump_generic_node (buffer, label, spc, flags, false);
 761       pp_character (buffer, ':');
 762     }
 763   if (DECL_NONLOCAL (label))
 764     pp_string (buffer, " [non-local]");
 765   if ((flags & TDF_EH) && EH_LANDING_PAD_NR (label))
 766     pp_printf (buffer, " [LP %d]", EH_LANDING_PAD_NR (label));
 767 }
 768
 769 /* Dump a GIMPLE_GOTO tuple on the pretty_printer BUFFER, SPC
 770    spaces of indent.  FLAGS specifies details to show in the dump (see
 771    TDF_* in tree-pass.h).  */
 772
 773 static void
 774 dump_gimple_goto (pretty_printer *buffer, gimple gs, int spc, int flags)
 775 {
 776   tree label = gimple_goto_dest (gs);
 777   if (flags & TDF_RAW)
 778     dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label);
 779   else
 780     dump_gimple_fmt (buffer, spc, flags, "goto %T;", label);
 781 }
 782
 783
 784 /* Dump a GIMPLE_BIND tuple on the pretty_printer BUFFER, SPC
 785    spaces of indent.  FLAGS specifies details to show in the dump (see
 786    TDF_* in tree-pass.h).  */
 787
 788 static void
 789 dump_gimple_bind (pretty_printer *buffer, gimple gs, int spc, int flags)
 790 {
 791   if (flags & TDF_RAW)
 792     dump_gimple_fmt (buffer, spc, flags, "%G <", gs);
 793   else
 794     pp_character (buffer, '{');
 795   if (!(flags & TDF_SLIM))
 796     {
 797       tree var;
 798
 799       for (var = gimple_bind_vars (gs); var; var = DECL_CHAIN (var))
 800         {
 801           newline_and_indent (buffer, 2);
 802           print_declaration (buffer, var, spc, flags);
 803         }
 804       if (gimple_bind_vars (gs))
 805         pp_newline (buffer);
 806     }
 807   pp_newline (buffer);
 808   dump_gimple_seq (buffer, gimple_bind_body (gs), spc + 2, flags);
 809   newline_and_indent (buffer, spc);
 810   if (flags & TDF_RAW)
 811     pp_character (buffer, '>');
 812   else
 813     pp_character (buffer, '}');
 814 }
 815
 816
 817 /* Dump a GIMPLE_TRY tuple on the pretty_printer BUFFER, SPC spaces of
 818    indent.  FLAGS specifies details to show in the dump (see TDF_* in
 819    tree-pass.h).  */
 820
 821 static void
 822 dump_gimple_try (pretty_printer *buffer, gimple gs, int spc, int flags)
 823 {
 824   if (flags & TDF_RAW)
 825     {
 826       const char *type;
 827       if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
 828         type = "GIMPLE_TRY_CATCH";
 829       else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
 830         type = "GIMPLE_TRY_FINALLY";
 831       else
 832         type = "UNKNOWN GIMPLE_TRY";
 833       dump_gimple_fmt (buffer, spc, flags,
 834                        "%G <%s,%+EVAL <%S>%nCLEANUP <%S>%->", gs, type,
 835                        gimple_try_eval (gs), gimple_try_cleanup (gs));
 836     }
 837   else
 838     {
 839       pp_string (buffer, "try");
 840       newline_and_indent (buffer, spc + 2);
 841       pp_character (buffer, '{');
 842       pp_newline (buffer);
 843
 844       dump_gimple_seq (buffer, gimple_try_eval (gs), spc + 4, flags);
 845       newline_and_indent (buffer, spc + 2);
 846       pp_character (buffer, '}');
 847
 848       if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
 849         {
 850           newline_and_indent (buffer, spc);
 851           pp_string (buffer, "catch");
 852           newline_and_indent (buffer, spc + 2);
 853           pp_character (buffer, '{');
 854         }
 855       else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
 856         {
 857           newline_and_indent (buffer, spc);
 858           pp_string (buffer, "finally");
 859           newline_and_indent (buffer, spc + 2);
 860           pp_character (buffer, '{');
 861         }
 862       else
 863         pp_string (buffer, " <UNKNOWN GIMPLE_TRY> {");
 864
 865       pp_newline (buffer);
 866       dump_gimple_seq (buffer, gimple_try_cleanup (gs), spc + 4, flags);
 867       newline_and_indent (buffer, spc + 2);
 868       pp_character (buffer, '}');
 869     }
 870 }
 871
 872
 873 /* Dump a GIMPLE_CATCH tuple on the pretty_printer BUFFER, SPC spaces of
 874    indent.  FLAGS specifies details to show in the dump (see TDF_* in
 875    tree-pass.h).  */
 876
 877 static void
 878 dump_gimple_catch (pretty_printer *buffer, gimple gs, int spc, int flags)
 879 {
 880   if (flags & TDF_RAW)
 881       dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+CATCH <%S>%->", gs,
 882                        gimple_catch_types (gs), gimple_catch_handler (gs));
 883   else
 884       dump_gimple_fmt (buffer, spc, flags, "catch (%T)%+{%S}",
 885                        gimple_catch_types (gs), gimple_catch_handler (gs));
 886 }
 887
 888
 889 /* Dump a GIMPLE_EH_FILTER tuple on the pretty_printer BUFFER, SPC spaces of
 890    indent.  FLAGS specifies details to show in the dump (see TDF_* in
 891    tree-pass.h).  */
 892
 893 static void
 894 dump_gimple_eh_filter (pretty_printer *buffer, gimple gs, int spc, int flags)
 895 {
 896   if (flags & TDF_RAW)
 897     dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+FAILURE <%S>%->", gs,
 898                      gimple_eh_filter_types (gs),
 899                      gimple_eh_filter_failure (gs));
 900   else
 901     dump_gimple_fmt (buffer, spc, flags, "<<<eh_filter (%T)>>>%+{%+%S%-}",
 902                      gimple_eh_filter_types (gs),
 903                      gimple_eh_filter_failure (gs));
 904 }
 905
 906
 907 /* Dump a GIMPLE_EH_MUST_NOT_THROW tuple.  */
 908
 909 static void
 910 dump_gimple_eh_must_not_throw (pretty_printer *buffer, gimple gs,
 911                                int spc, int flags)
 912 {
 913   if (flags & TDF_RAW)
 914     dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs,
 915                      gimple_eh_must_not_throw_fndecl (gs));
 916   else
 917     dump_gimple_fmt (buffer, spc, flags, "<<<eh_must_not_throw (%T)>>>",
 918                      gimple_eh_must_not_throw_fndecl (gs));
 919 }
 920
 921
 922 /* Dump a GIMPLE_RESX tuple on the pretty_printer BUFFER, SPC spaces of
 923    indent.  FLAGS specifies details to show in the dump (see TDF_* in
 924    tree-pass.h).  */
 925
 926 static void
 927 dump_gimple_resx (pretty_printer *buffer, gimple gs, int spc, int flags)
 928 {
 929   if (flags & TDF_RAW)
 930     dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
 931                      gimple_resx_region (gs));
 932   else
 933     dump_gimple_fmt (buffer, spc, flags, "resx %d", gimple_resx_region (gs));
 934 }
 935
 936 /* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer BUFFER.  */
 937
 938 static void
 939 dump_gimple_eh_dispatch (pretty_printer *buffer, gimple gs, int spc, int flags)
 940 {
 941   if (flags & TDF_RAW)
 942     dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
 943                      gimple_eh_dispatch_region (gs));
 944   else
 945     dump_gimple_fmt (buffer, spc, flags, "eh_dispatch %d",
 946                      gimple_eh_dispatch_region (gs));
 947 }
 948
 949 /* Dump a GIMPLE_DEBUG tuple on the pretty_printer BUFFER, SPC spaces
 950    of indent.  FLAGS specifies details to show in the dump (see TDF_*
 951    in tree-pass.h).  */
 952
 953 static void
 954 dump_gimple_debug (pretty_printer *buffer, gimple gs, int spc, int flags)
 955 {
 956   switch (gs->gsbase.subcode)
 957     {
 958     case GIMPLE_DEBUG_BIND:
 959       if (flags & TDF_RAW)
 960         dump_gimple_fmt (buffer, spc, flags, "%G BIND <%T, %T>", gs,
 961                          gimple_debug_bind_get_var (gs),
 962                          gimple_debug_bind_get_value (gs));
 963       else
 964         dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T => %T",
 965                          gimple_debug_bind_get_var (gs),
 966                          gimple_debug_bind_get_value (gs));
 967       break;
 968
 969     default:
 970       gcc_unreachable ();
 971     }
 972 }
 973
 974 /* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer BUFFER.  */
 975 static void
 976 dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags)
 977 {
 978   size_t i;
 979
 980   if (flags & TDF_RAW)
 981     {
 982       dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
 983                        gimple_omp_body (gs));
 984       dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
 985       dump_gimple_fmt (buffer, spc, flags, " >,");
 986       for (i = 0; i < gimple_omp_for_collapse (gs); i++)
 987         dump_gimple_fmt (buffer, spc, flags,
 988                          "%+%T, %T, %T, %s, %T,%n",
 989                          gimple_omp_for_index (gs, i),
 990                          gimple_omp_for_initial (gs, i),
 991                          gimple_omp_for_final (gs, i),
 992                          tree_code_name[gimple_omp_for_cond (gs, i)],
 993                          gimple_omp_for_incr (gs, i));
 994       dump_gimple_fmt (buffer, spc, flags, "PRE_BODY <%S>%->",
 995                        gimple_omp_for_pre_body (gs));
 996     }
 997   else
 998     {
 999       pp_string (buffer, "#pragma omp for");
1000       dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
1001       for (i = 0; i < gimple_omp_for_collapse (gs); i++)
1002         {
1003           if (i)
1004             spc += 2;
1005           newline_and_indent (buffer, spc);
1006           pp_string (buffer, "for (");
1007           dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1008                              flags, false);
1009           pp_string (buffer, " = ");
1010           dump_generic_node (buffer, gimple_omp_for_initial (gs, i), spc,
1011                              flags, false);
1012           pp_string (buffer, "; ");
1013
1014           dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1015                              flags, false);
1016           pp_space (buffer);
1017           switch (gimple_omp_for_cond (gs, i))
1018             {
1019             case LT_EXPR:
1020               pp_character (buffer, '<');
1021               break;
1022             case GT_EXPR:
1023               pp_character (buffer, '>');
1024               break;
1025             case LE_EXPR:
1026               pp_string (buffer, "<=");
1027               break;
1028             case GE_EXPR:
1029               pp_string (buffer, ">=");
1030               break;
1031             default:
1032               gcc_unreachable ();
1033             }
1034           pp_space (buffer);
1035           dump_generic_node (buffer, gimple_omp_for_final (gs, i), spc,
1036                              flags, false);
1037           pp_string (buffer, "; ");
1038
1039           dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1040                              flags, false);
1041           pp_string (buffer, " = ");
1042           dump_generic_node (buffer, gimple_omp_for_incr (gs, i), spc,
1043                              flags, false);
1044           pp_character (buffer, ')');
1045         }
1046
1047       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1048         {
1049           newline_and_indent (buffer, spc + 2);
1050           pp_character (buffer, '{');
1051           pp_newline (buffer);
1052           dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1053           newline_and_indent (buffer, spc + 2);
1054           pp_character (buffer, '}');
1055         }
1056     }
1057 }
1058
1059 /* Dump a GIMPLE_OMP_CONTINUE tuple on the pretty_printer BUFFER.  */
1060
1061 static void
1062 dump_gimple_omp_continue (pretty_printer *buffer, gimple gs, int spc, int flags)
1063 {
1064   if (flags & TDF_RAW)
1065     {
1066       dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs,
1067                        gimple_omp_continue_control_def (gs),
1068                        gimple_omp_continue_control_use (gs));
1069     }
1070   else
1071     {
1072       pp_string (buffer, "#pragma omp continue (");
1073       dump_generic_node (buffer, gimple_omp_continue_control_def (gs),
1074                          spc, flags, false);
1075       pp_character (buffer, ',');
1076       pp_space (buffer);
1077       dump_generic_node (buffer, gimple_omp_continue_control_use (gs),
1078                          spc, flags, false);
1079       pp_character (buffer, ')');
1080     }
1081 }
1082
1083 /* Dump a GIMPLE_OMP_SINGLE tuple on the pretty_printer BUFFER.  */
1084
1085 static void
1086 dump_gimple_omp_single (pretty_printer *buffer, gimple gs, int spc, int flags)
1087 {
1088   if (flags & TDF_RAW)
1089     {
1090       dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1091                        gimple_omp_body (gs));
1092       dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags);
1093       dump_gimple_fmt (buffer, spc, flags, " >");
1094     }
1095   else
1096     {
1097       pp_string (buffer, "#pragma omp single");
1098       dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags);
1099       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1100         {
1101           newline_and_indent (buffer, spc + 2);
1102           pp_character (buffer, '{');
1103           pp_newline (buffer);
1104           dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1105           newline_and_indent (buffer, spc + 2);
1106           pp_character (buffer, '}');
1107         }
1108     }
1109 }
1110
1111 /* Dump a GIMPLE_OMP_SECTIONS tuple on the pretty_printer BUFFER.  */
1112
1113 static void
1114 dump_gimple_omp_sections (pretty_printer *buffer, gimple gs, int spc,
1115                           int flags)
1116 {
1117   if (flags & TDF_RAW)
1118     {
1119       dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1120                        gimple_omp_body (gs));
1121       dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags);
1122       dump_gimple_fmt (buffer, spc, flags, " >");
1123     }
1124   else
1125     {
1126       pp_string (buffer, "#pragma omp sections");
1127       if (gimple_omp_sections_control (gs))
1128         {
1129           pp_string (buffer, " <");
1130           dump_generic_node (buffer, gimple_omp_sections_control (gs), spc,
1131                              flags, false);
1132           pp_character (buffer, '>');
1133         }
1134       dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags);
1135       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1136         {
1137           newline_and_indent (buffer, spc + 2);
1138           pp_character (buffer, '{');
1139           pp_newline (buffer);
1140           dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1141           newline_and_indent (buffer, spc + 2);
1142           pp_character (buffer, '}');
1143         }
1144     }
1145 }
1146
1147 /* Dump a GIMPLE_OMP_{MASTER,ORDERED,SECTION} tuple on the pretty_printer
1148    BUFFER.  */
1149
1150 static void
1151 dump_gimple_omp_block (pretty_printer *buffer, gimple gs, int spc, int flags)
1152 {
1153   if (flags & TDF_RAW)
1154     dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
1155                      gimple_omp_body (gs));
1156   else
1157     {
1158       switch (gimple_code (gs))
1159         {
1160         case GIMPLE_OMP_MASTER:
1161           pp_string (buffer, "#pragma omp master");
1162           break;
1163         case GIMPLE_OMP_ORDERED:
1164           pp_string (buffer, "#pragma omp ordered");
1165           break;
1166         case GIMPLE_OMP_SECTION:
1167           pp_string (buffer, "#pragma omp section");
1168           break;
1169         default:
1170           gcc_unreachable ();
1171         }
1172       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1173         {
1174           newline_and_indent (buffer, spc + 2);
1175           pp_character (buffer, '{');
1176           pp_newline (buffer);
1177           dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1178           newline_and_indent (buffer, spc + 2);
1179           pp_character (buffer, '}');
1180         }
1181     }
1182 }
1183
1184 /* Dump a GIMPLE_OMP_CRITICAL tuple on the pretty_printer BUFFER.  */
1185
1186 static void
1187 dump_gimple_omp_critical (pretty_printer *buffer, gimple gs, int spc,
1188                           int flags)
1189 {
1190   if (flags & TDF_RAW)
1191     dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
1192                      gimple_omp_body (gs));
1193   else
1194     {
1195       pp_string (buffer, "#pragma omp critical");
1196       if (gimple_omp_critical_name (gs))
1197         {
1198           pp_string (buffer, " (");
1199           dump_generic_node (buffer, gimple_omp_critical_name (gs), spc,
1200                              flags, false);
1201           pp_character (buffer, ')');
1202         }
1203       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1204         {
1205           newline_and_indent (buffer, spc + 2);
1206           pp_character (buffer, '{');
1207           pp_newline (buffer);
1208           dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1209           newline_and_indent (buffer, spc + 2);
1210           pp_character (buffer, '}');
1211         }
1212     }
1213 }
1214
1215 /* Dump a GIMPLE_OMP_RETURN tuple on the pretty_printer BUFFER.  */
1216
1217 static void
1218 dump_gimple_omp_return (pretty_printer *buffer, gimple gs, int spc, int flags)
1219 {
1220   if (flags & TDF_RAW)
1221     {
1222       dump_gimple_fmt (buffer, spc, flags, "%G <nowait=%d>", gs,
1223                        (int) gimple_omp_return_nowait_p (gs));
1224     }
1225   else
1226     {
1227       pp_string (buffer, "#pragma omp return");
1228       if (gimple_omp_return_nowait_p (gs))
1229         pp_string (buffer, "(nowait)");
1230     }
1231 }
1232
1233 /* Dump a GIMPLE_ASM tuple on the pretty_printer BUFFER, SPC spaces of
1234    indent.  FLAGS specifies details to show in the dump (see TDF_* in
1235    tree-pass.h).  */
1236
1237 static void
1238 dump_gimple_asm (pretty_printer *buffer, gimple gs, int spc, int flags)
1239 {
1240   unsigned int i, n, f, fields;
1241
1242   if (flags & TDF_RAW)
1243     {
1244       dump_gimple_fmt (buffer, spc, flags, "%G <%+STRING <%n%s%n>", gs,
1245                        gimple_asm_string (gs));
1246
1247       n = gimple_asm_noutputs (gs);
1248       if (n)
1249         {
1250           newline_and_indent (buffer, spc + 2);
1251           pp_string (buffer, "OUTPUT: ");
1252           for (i = 0; i < n; i++)
1253             {
1254               dump_generic_node (buffer, gimple_asm_output_op (gs, i),
1255                                  spc, flags, false);
1256               if (i < n - 1)
1257                 pp_string (buffer, ", ");
1258             }
1259         }
1260
1261       n = gimple_asm_ninputs (gs);
1262       if (n)
1263         {
1264           newline_and_indent (buffer, spc + 2);
1265           pp_string (buffer, "INPUT: ");
1266           for (i = 0; i < n; i++)
1267             {
1268               dump_generic_node (buffer, gimple_asm_input_op (gs, i),
1269                                  spc, flags, false);
1270               if (i < n - 1)
1271                 pp_string (buffer, ", ");
1272             }
1273         }
1274
1275       n = gimple_asm_nclobbers (gs);
1276       if (n)
1277         {
1278           newline_and_indent (buffer, spc + 2);
1279           pp_string (buffer, "CLOBBER: ");
1280           for (i = 0; i < n; i++)
1281             {
1282               dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
1283                                  spc, flags, false);
1284               if (i < n - 1)
1285                 pp_string (buffer, ", ");
1286             }
1287         }
1288
1289       n = gimple_asm_nlabels (gs);
1290       if (n)
1291         {
1292           newline_and_indent (buffer, spc + 2);
1293           pp_string (buffer, "LABEL: ");
1294           for (i = 0; i < n; i++)
1295             {
1296               dump_generic_node (buffer, gimple_asm_label_op (gs, i),
1297                                  spc, flags, false);
1298               if (i < n - 1)
1299                 pp_string (buffer, ", ");
1300             }
1301         }
1302
1303       newline_and_indent (buffer, spc);
1304       pp_character (buffer, '>');
1305     }
1306   else
1307     {
1308       pp_string (buffer, "__asm__");
1309       if (gimple_asm_volatile_p (gs))
1310         pp_string (buffer, " __volatile__");
1311       if (gimple_asm_nlabels (gs))
1312         pp_string (buffer, " goto");
1313       pp_string (buffer, "(\"");
1314       pp_string (buffer, gimple_asm_string (gs));
1315       pp_string (buffer, "\"");
1316
1317       if (gimple_asm_nlabels (gs))
1318         fields = 4;
1319       else if (gimple_asm_nclobbers (gs))
1320         fields = 3;
1321       else if (gimple_asm_ninputs (gs))
1322         fields = 2;
1323       else if (gimple_asm_noutputs (gs))
1324         fields = 1;
1325       else
1326         fields = 0;
1327
1328       for (f = 0; f < fields; ++f)
1329         {
1330           pp_string (buffer, " : ");
1331
1332           switch (f)
1333             {
1334             case 0:
1335               n = gimple_asm_noutputs (gs);
1336               for (i = 0; i < n; i++)
1337                 {
1338                   dump_generic_node (buffer, gimple_asm_output_op (gs, i),
1339                                      spc, flags, false);
1340                   if (i < n - 1)
1341                     pp_string (buffer, ", ");
1342                 }
1343               break;
1344
1345             case 1:
1346               n = gimple_asm_ninputs (gs);
1347               for (i = 0; i < n; i++)
1348                 {
1349                   dump_generic_node (buffer, gimple_asm_input_op (gs, i),
1350                                      spc, flags, false);
1351                   if (i < n - 1)
1352                     pp_string (buffer, ", ");
1353                 }
1354               break;
1355
1356             case 2:
1357               n = gimple_asm_nclobbers (gs);
1358               for (i = 0; i < n; i++)
1359                 {
1360                   dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
1361                                      spc, flags, false);
1362                   if (i < n - 1)
1363                     pp_string (buffer, ", ");
1364                 }
1365               break;
1366
1367             case 3:
1368               n = gimple_asm_nlabels (gs);
1369               for (i = 0; i < n; i++)
1370                 {
1371                   dump_generic_node (buffer, gimple_asm_label_op (gs, i),
1372                                      spc, flags, false);
1373                   if (i < n - 1)
1374                     pp_string (buffer, ", ");
1375                 }
1376               break;
1377
1378             default:
1379               gcc_unreachable ();
1380             }
1381         }
1382
1383       pp_string (buffer, ");");
1384     }
1385 }
1386
1387
1388 /* Dump a PHI node PHI.  BUFFER, SPC and FLAGS are as in
1389    dump_gimple_stmt.  */
1390
1391 static void
1392 dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, int flags)
1393 {
1394   size_t i;
1395   tree lhs = gimple_phi_result (phi);
1396
1397   if (flags & TDF_ALIAS
1398       && POINTER_TYPE_P (TREE_TYPE (lhs))
1399       && SSA_NAME_PTR_INFO (lhs))
1400     {
1401       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (lhs);
1402       pp_string (buffer, "PT = ");
1403       pp_points_to_solution (buffer, &pi->pt);
1404       newline_and_indent (buffer, spc);
1405       if (pi->align != 1)
1406         pp_printf (buffer, "# ALIGN = %u, MISALIGN = %u",
1407                    pi->align, pi->misalign);
1408       newline_and_indent (buffer, spc);
1409       pp_string (buffer, "# ");
1410     }
1411
1412   if (flags & TDF_RAW)
1413       dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", phi,
1414                        gimple_phi_result (phi));
1415   else
1416     {
1417       dump_generic_node (buffer, lhs, spc, flags, false);
1418       pp_string (buffer, " = PHI <");
1419     }
1420   for (i = 0; i < gimple_phi_num_args (phi); i++)
1421     {
1422       if ((flags & TDF_LINENO) && gimple_phi_arg_has_location (phi, i))
1423         {
1424           expanded_location xloc;
1425
1426           xloc = expand_location (gimple_phi_arg_location (phi, i));
1427           pp_character (buffer, '[');
1428           if (xloc.file)
1429             {
1430               pp_string (buffer, xloc.file);
1431               pp_string (buffer, " : ");
1432             }
1433           pp_decimal_int (buffer, xloc.line);
1434           pp_string (buffer, ":");
1435           pp_decimal_int (buffer, xloc.column);
1436           pp_string (buffer, "] ");
1437         }
1438       dump_generic_node (buffer, gimple_phi_arg_def (phi, i), spc, flags,
1439                          false);
1440       pp_character (buffer, '(');
1441       pp_decimal_int (buffer, gimple_phi_arg_edge (phi, i)->src->index);
1442       pp_character (buffer, ')');
1443       if (i < gimple_phi_num_args (phi) - 1)
1444         pp_string (buffer, ", ");
1445     }
1446   pp_character (buffer, '>');
1447 }
1448
1449
1450 /* Dump a GIMPLE_OMP_PARALLEL tuple on the pretty_printer BUFFER, SPC spaces
1451    of indent.  FLAGS specifies details to show in the dump (see TDF_* in
1452    tree-pass.h).  */
1453
1454 static void
1455 dump_gimple_omp_parallel (pretty_printer *buffer, gimple gs, int spc,
1456                           int flags)
1457 {
1458   if (flags & TDF_RAW)
1459     {
1460       dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1461                        gimple_omp_body (gs));
1462       dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags);
1463       dump_gimple_fmt (buffer, spc, flags, " >, %T, %T%n>",
1464                        gimple_omp_parallel_child_fn (gs),
1465                        gimple_omp_parallel_data_arg (gs));
1466     }
1467   else
1468     {
1469       gimple_seq body;
1470       pp_string (buffer, "#pragma omp parallel");
1471       dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags);
1472       if (gimple_omp_parallel_child_fn (gs))
1473         {
1474           pp_string (buffer, " [child fn: ");
1475           dump_generic_node (buffer, gimple_omp_parallel_child_fn (gs),
1476                              spc, flags, false);
1477           pp_string (buffer, " (");
1478           if (gimple_omp_parallel_data_arg (gs))
1479             dump_generic_node (buffer, gimple_omp_parallel_data_arg (gs),
1480                                spc, flags, false);
1481           else
1482             pp_string (buffer, "???");
1483           pp_string (buffer, ")]");
1484         }
1485       body = gimple_omp_body (gs);
1486       if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
1487         {
1488           newline_and_indent (buffer, spc + 2);
1489           pp_character (buffer, '{');
1490           pp_newline (buffer);
1491           dump_gimple_seq (buffer, body, spc + 4, flags);
1492           newline_and_indent (buffer, spc + 2);
1493           pp_character (buffer, '}');
1494         }
1495       else if (body)
1496         {
1497           pp_newline (buffer);
1498           dump_gimple_seq (buffer, body, spc + 2, flags);
1499         }
1500     }
1501 }
1502
1503
1504 /* Dump a GIMPLE_OMP_TASK tuple on the pretty_printer BUFFER, SPC spaces
1505    of indent.  FLAGS specifies details to show in the dump (see TDF_* in
1506    tree-pass.h).  */
1507
1508 static void
1509 dump_gimple_omp_task (pretty_printer *buffer, gimple gs, int spc,
1510                       int flags)
1511 {
1512   if (flags & TDF_RAW)
1513     {
1514       dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1515                        gimple_omp_body (gs));
1516       dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags);
1517       dump_gimple_fmt (buffer, spc, flags, " >, %T, %T, %T, %T, %T%n>",
1518                        gimple_omp_task_child_fn (gs),
1519                        gimple_omp_task_data_arg (gs),
1520                        gimple_omp_task_copy_fn (gs),
1521                        gimple_omp_task_arg_size (gs),
1522                        gimple_omp_task_arg_size (gs));
1523     }
1524   else
1525     {
1526       gimple_seq body;
1527       pp_string (buffer, "#pragma omp task");
1528       dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags);
1529       if (gimple_omp_task_child_fn (gs))
1530         {
1531           pp_string (buffer, " [child fn: ");
1532           dump_generic_node (buffer, gimple_omp_task_child_fn (gs),
1533                              spc, flags, false);
1534           pp_string (buffer, " (");
1535           if (gimple_omp_task_data_arg (gs))
1536             dump_generic_node (buffer, gimple_omp_task_data_arg (gs),
1537                                spc, flags, false);
1538           else
1539             pp_string (buffer, "???");
1540           pp_string (buffer, ")]");
1541         }
1542       body = gimple_omp_body (gs);
1543       if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
1544         {
1545           newline_and_indent (buffer, spc + 2);
1546           pp_character (buffer, '{');
1547           pp_newline (buffer);
1548           dump_gimple_seq (buffer, body, spc + 4, flags);
1549           newline_and_indent (buffer, spc + 2);
1550           pp_character (buffer, '}');
1551         }
1552       else if (body)
1553         {
1554           pp_newline (buffer);
1555           dump_gimple_seq (buffer, body, spc + 2, flags);
1556         }
1557     }
1558 }
1559
1560
1561 /* Dump a GIMPLE_OMP_ATOMIC_LOAD tuple on the pretty_printer BUFFER, SPC
1562    spaces of indent.  FLAGS specifies details to show in the dump (see TDF_*
1563    in tree-pass.h).  */
1564
1565 static void
1566 dump_gimple_omp_atomic_load (pretty_printer *buffer, gimple gs, int spc,
1567                              int flags)
1568 {
1569   if (flags & TDF_RAW)
1570     {
1571       dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs,
1572                        gimple_omp_atomic_load_lhs (gs),
1573                        gimple_omp_atomic_load_rhs (gs));
1574     }
1575   else
1576     {
1577       pp_string (buffer, "#pragma omp atomic_load");
1578       newline_and_indent (buffer, spc + 2);
1579       dump_generic_node (buffer, gimple_omp_atomic_load_lhs (gs),
1580                          spc, flags, false);
1581       pp_space (buffer);
1582       pp_character (buffer, '=');
1583       pp_space (buffer);
1584       pp_character (buffer, '*');
1585       dump_generic_node (buffer, gimple_omp_atomic_load_rhs (gs),
1586                          spc, flags, false);
1587     }
1588 }
1589
1590 /* Dump a GIMPLE_OMP_ATOMIC_STORE tuple on the pretty_printer BUFFER, SPC
1591    spaces of indent.  FLAGS specifies details to show in the dump (see TDF_*
1592    in tree-pass.h).  */
1593
1594 static void
1595 dump_gimple_omp_atomic_store (pretty_printer *buffer, gimple gs, int spc,
1596                              int flags)
1597 {
1598   if (flags & TDF_RAW)
1599     {
1600       dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs,
1601                        gimple_omp_atomic_store_val (gs));
1602     }
1603   else
1604     {
1605       pp_string (buffer, "#pragma omp atomic_store (");
1606       dump_generic_node (buffer, gimple_omp_atomic_store_val (gs),
1607                          spc, flags, false);
1608       pp_character (buffer, ')');
1609     }
1610 }
1611
1612
1613 /* Dump all the memory operands for statement GS.  BUFFER, SPC and
1614    FLAGS are as in dump_gimple_stmt.  */
1615
1616 static void
1617 dump_gimple_mem_ops (pretty_printer *buffer, gimple gs, int spc, int flags)
1618 {
1619   tree vdef = gimple_vdef (gs);
1620   tree vuse = gimple_vuse (gs);
1621
1622   if (!ssa_operands_active () || !gimple_references_memory_p (gs))
1623     return;
1624
1625   if (vdef != NULL_TREE)
1626     {
1627       pp_string (buffer, "# ");
1628       dump_generic_node (buffer, vdef, spc + 2, flags, false);
1629       pp_string (buffer, " = VDEF <");
1630       dump_generic_node (buffer, vuse, spc + 2, flags, false);
1631       pp_character (buffer, '>');
1632       newline_and_indent (buffer, spc);
1633     }
1634   else if (vuse != NULL_TREE)
1635     {
1636       pp_string (buffer, "# VUSE <");
1637       dump_generic_node (buffer, vuse, spc + 2, flags, false);
1638       pp_character (buffer, '>');
1639       newline_and_indent (buffer, spc);
1640     }
1641 }
1642
1643
1644 /* Dump the gimple statement GS on the pretty printer BUFFER, SPC
1645    spaces of indent.  FLAGS specifies details to show in the dump (see
1646    TDF_* in tree-pass.h).  */
1647
1648 void
1649 dump_gimple_stmt (pretty_printer *buffer, gimple gs, int spc, int flags)
1650 {
1651   if (!gs)
1652     return;
1653
1654   if (flags & TDF_STMTADDR)
1655     pp_printf (buffer, "<&%p> ", (void *) gs);
1656
1657   if ((flags & TDF_LINENO) && gimple_has_location (gs))
1658     {
1659       expanded_location xloc = expand_location (gimple_location (gs));
1660       pp_character (buffer, '[');
1661       if (xloc.file)
1662         {
1663           pp_string (buffer, xloc.file);
1664           pp_string (buffer, " : ");
1665         }
1666       pp_decimal_int (buffer, xloc.line);
1667       pp_string (buffer, ":");
1668       pp_decimal_int (buffer, xloc.column);
1669       pp_string (buffer, "] ");
1670     }
1671
1672   if (flags & TDF_EH)
1673     {
1674       int lp_nr = lookup_stmt_eh_lp (gs);
1675       if (lp_nr > 0)
1676         pp_printf (buffer, "[LP %d] ", lp_nr);
1677       else if (lp_nr < 0)
1678         pp_printf (buffer, "[MNT %d] ", -lp_nr);
1679     }
1680
1681   if ((flags & (TDF_VOPS|TDF_MEMSYMS))
1682       && gimple_has_mem_ops (gs))
1683     dump_gimple_mem_ops (buffer, gs, spc, flags);
1684
1685   if ((flags & TDF_ALIAS)
1686       && gimple_has_lhs (gs))
1687     {
1688       tree lhs = gimple_get_lhs (gs);
1689       if (TREE_CODE (lhs) == SSA_NAME
1690           && POINTER_TYPE_P (TREE_TYPE (lhs))
1691           && SSA_NAME_PTR_INFO (lhs))
1692         {
1693           struct ptr_info_def *pi = SSA_NAME_PTR_INFO (lhs);
1694           pp_string (buffer, "# PT = ");
1695           pp_points_to_solution (buffer, &pi->pt);
1696           newline_and_indent (buffer, spc);
1697           if (pi->align != 1)
1698             {
1699               pp_printf (buffer, "# ALIGN = %u, MISALIGN = %u",
1700                          pi->align, pi->misalign);
1701               newline_and_indent (buffer, spc);
1702             }
1703         }
1704     }
1705
1706   switch (gimple_code (gs))
1707     {
1708     case GIMPLE_ASM:
1709       dump_gimple_asm (buffer, gs, spc, flags);
1710       break;
1711
1712     case GIMPLE_ASSIGN:
1713       dump_gimple_assign (buffer, gs, spc, flags);
1714       break;
1715
1716     case GIMPLE_BIND:
1717       dump_gimple_bind (buffer, gs, spc, flags);
1718       break;
1719
1720     case GIMPLE_CALL:
1721       dump_gimple_call (buffer, gs, spc, flags);
1722       break;
1723
1724     case GIMPLE_COND:
1725       dump_gimple_cond (buffer, gs, spc, flags);
1726       break;
1727
1728     case GIMPLE_LABEL:
1729       dump_gimple_label (buffer, gs, spc, flags);
1730       break;
1731
1732     case GIMPLE_GOTO:
1733       dump_gimple_goto (buffer, gs, spc, flags);
1734       break;
1735
1736     case GIMPLE_NOP:
1737       pp_string (buffer, "GIMPLE_NOP");
1738       break;
1739
1740     case GIMPLE_RETURN:
1741       dump_gimple_return (buffer, gs, spc, flags);
1742       break;
1743
1744     case GIMPLE_SWITCH:
1745       dump_gimple_switch (buffer, gs, spc, flags);
1746       break;
1747
1748     case GIMPLE_TRY:
1749       dump_gimple_try (buffer, gs, spc, flags);
1750       break;
1751
1752     case GIMPLE_PHI:
1753       dump_gimple_phi (buffer, gs, spc, flags);
1754       break;
1755
1756     case GIMPLE_OMP_PARALLEL:
1757       dump_gimple_omp_parallel (buffer, gs, spc, flags);
1758       break;
1759
1760     case GIMPLE_OMP_TASK:
1761       dump_gimple_omp_task (buffer, gs, spc, flags);
1762       break;
1763
1764     case GIMPLE_OMP_ATOMIC_LOAD:
1765       dump_gimple_omp_atomic_load (buffer, gs, spc, flags);
1766
1767       break;
1768
1769     case GIMPLE_OMP_ATOMIC_STORE:
1770       dump_gimple_omp_atomic_store (buffer, gs, spc, flags);
1771       break;
1772
1773     case GIMPLE_OMP_FOR:
1774       dump_gimple_omp_for (buffer, gs, spc, flags);
1775       break;
1776
1777     case GIMPLE_OMP_CONTINUE:
1778       dump_gimple_omp_continue (buffer, gs, spc, flags);
1779       break;
1780
1781     case GIMPLE_OMP_SINGLE:
1782       dump_gimple_omp_single (buffer, gs, spc, flags);
1783       break;
1784
1785     case GIMPLE_OMP_RETURN:
1786       dump_gimple_omp_return (buffer, gs, spc, flags);
1787       break;
1788
1789     case GIMPLE_OMP_SECTIONS:
1790       dump_gimple_omp_sections (buffer, gs, spc, flags);
1791       break;
1792
1793     case GIMPLE_OMP_SECTIONS_SWITCH:
1794       pp_string (buffer, "GIMPLE_SECTIONS_SWITCH");
1795       break;
1796
1797     case GIMPLE_OMP_MASTER:
1798     case GIMPLE_OMP_ORDERED:
1799     case GIMPLE_OMP_SECTION:
1800       dump_gimple_omp_block (buffer, gs, spc, flags);
1801       break;
1802
1803     case GIMPLE_OMP_CRITICAL:
1804       dump_gimple_omp_critical (buffer, gs, spc, flags);
1805       break;
1806
1807     case GIMPLE_CATCH:
1808       dump_gimple_catch (buffer, gs, spc, flags);
1809       break;
1810
1811     case GIMPLE_EH_FILTER:
1812       dump_gimple_eh_filter (buffer, gs, spc, flags);
1813       break;
1814
1815     case GIMPLE_EH_MUST_NOT_THROW:
1816       dump_gimple_eh_must_not_throw (buffer, gs, spc, flags);
1817       break;
1818
1819     case GIMPLE_RESX:
1820       dump_gimple_resx (buffer, gs, spc, flags);
1821       break;
1822
1823     case GIMPLE_EH_DISPATCH:
1824       dump_gimple_eh_dispatch (buffer, gs, spc, flags);
1825       break;
1826
1827     case GIMPLE_DEBUG:
1828       dump_gimple_debug (buffer, gs, spc, flags);
1829       break;
1830
1831     case GIMPLE_PREDICT:
1832       pp_string (buffer, "// predicted ");
1833       if (gimple_predict_outcome (gs))
1834         pp_string (buffer, "likely by ");
1835       else
1836         pp_string (buffer, "unlikely by ");
1837       pp_string (buffer, predictor_name (gimple_predict_predictor (gs)));
1838       pp_string (buffer, " predictor.");
1839       break;
1840
1841     default:
1842       GIMPLE_NIY;
1843     }
1844
1845   /* If we're building a diagnostic, the formatted text will be
1846      written into BUFFER's stream by the caller; otherwise, write it
1847      now.  */
1848   if (!(flags & TDF_DIAGNOSTIC))
1849     pp_write_text_to_stream (buffer);
1850 }
1851
1852
1853 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
1854    spaces and details described by flags.  */
1855
1856 static void
1857 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
1858 {
1859   edge e;
1860   gimple stmt;
1861   edge_iterator ei;
1862
1863   if (flags & TDF_BLOCKS)
1864     {
1865       INDENT (indent);
1866       pp_string (buffer, "# BLOCK ");
1867       pp_decimal_int (buffer, bb->index);
1868       if (bb->frequency)
1869         {
1870           pp_string (buffer, " freq:");
1871           pp_decimal_int (buffer, bb->frequency);
1872         }
1873       if (bb->count)
1874         {
1875           pp_string (buffer, " count:");
1876           pp_widest_integer (buffer, bb->count);
1877         }
1878
1879       if (flags & TDF_LINENO)
1880         {
1881           gimple_stmt_iterator gsi;
1882
1883           for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1884             if (!is_gimple_debug (gsi_stmt (gsi))
1885                 && get_lineno (gsi_stmt (gsi)) != UNKNOWN_LOCATION)
1886               {
1887                 pp_string (buffer, ", starting at line ");
1888                 pp_decimal_int (buffer, get_lineno (gsi_stmt (gsi)));
1889                 break;
1890               }
1891
1892           if (bb->discriminator)
1893             {
1894               pp_string (buffer, ", discriminator ");
1895               pp_decimal_int (buffer, bb->discriminator);
1896             }
1897         }
1898       newline_and_indent (buffer, indent);
1899
1900       pp_string (buffer, "# PRED:");
1901       pp_write_text_to_stream (buffer);
1902       FOR_EACH_EDGE (e, ei, bb->preds)
1903         if (flags & TDF_SLIM)
1904           {
1905             pp_character (buffer, ' ');
1906             if (e->src == ENTRY_BLOCK_PTR)
1907               pp_string (buffer, "ENTRY");
1908             else
1909               pp_decimal_int (buffer, e->src->index);
1910           }
1911         else
1912           dump_edge_info (buffer->buffer->stream, e, 0);
1913       pp_newline (buffer);
1914     }
1915   else
1916     {
1917       stmt = first_stmt (bb);
1918       if (!stmt || gimple_code (stmt) != GIMPLE_LABEL)
1919         {
1920           INDENT (indent - 2);
1921           pp_string (buffer, "<bb ");
1922           pp_decimal_int (buffer, bb->index);
1923           pp_string (buffer, ">:");
1924           pp_newline (buffer);
1925         }
1926     }
1927   pp_write_text_to_stream (buffer);
1928   if (cfun)
1929     check_bb_profile (bb, buffer->buffer->stream);
1930 }
1931
1932
1933 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
1934    spaces.  */
1935
1936 static void
1937 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
1938 {
1939   edge e;
1940   edge_iterator ei;
1941
1942   INDENT (indent);
1943   pp_string (buffer, "# SUCC:");
1944   pp_write_text_to_stream (buffer);
1945   FOR_EACH_EDGE (e, ei, bb->succs)
1946     if (flags & TDF_SLIM)
1947       {
1948         pp_character (buffer, ' ');
1949         if (e->dest == EXIT_BLOCK_PTR)
1950           pp_string (buffer, "EXIT");
1951         else
1952           pp_decimal_int (buffer, e->dest->index);
1953       }
1954     else
1955       dump_edge_info (buffer->buffer->stream, e, 1);
1956   pp_newline (buffer);
1957 }
1958
1959
1960 /* Dump PHI nodes of basic block BB to BUFFER with details described
1961    by FLAGS and indented by INDENT spaces.  */
1962
1963 static void
1964 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
1965 {
1966   gimple_stmt_iterator i;
1967
1968   for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
1969     {
1970       gimple phi = gsi_stmt (i);
1971       if (is_gimple_reg (gimple_phi_result (phi)) || (flags & TDF_VOPS))
1972         {
1973           INDENT (indent);
1974           pp_string (buffer, "# ");
1975           dump_gimple_phi (buffer, phi, indent, flags);
1976           pp_newline (buffer);
1977         }
1978     }
1979 }
1980
1981
1982 /* Dump jump to basic block BB that is represented implicitly in the cfg
1983    to BUFFER.  */
1984
1985 static void
1986 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
1987 {
1988   gimple stmt;
1989
1990   stmt = first_stmt (bb);
1991
1992   pp_string (buffer, "goto <bb ");
1993   pp_decimal_int (buffer, bb->index);
1994   pp_character (buffer, '>');
1995   if (stmt && gimple_code (stmt) == GIMPLE_LABEL)
1996     {
1997       pp_string (buffer, " (");
1998       dump_generic_node (buffer, gimple_label_label (stmt), 0, 0, false);
1999       pp_character (buffer, ')');
2000       pp_semicolon (buffer);
2001     }
2002   else
2003     pp_semicolon (buffer);
2004 }
2005
2006
2007 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2008    by INDENT spaces, with details given by FLAGS.  */
2009
2010 static void
2011 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2012                      int flags)
2013 {
2014   edge e;
2015   gimple stmt;
2016
2017   stmt = last_stmt (bb);
2018
2019   if (stmt && gimple_code (stmt) == GIMPLE_COND)
2020     {
2021       edge true_edge, false_edge;
2022
2023       /* When we are emitting the code or changing CFG, it is possible that
2024          the edges are not yet created.  When we are using debug_bb in such
2025          a situation, we do not want it to crash.  */
2026       if (EDGE_COUNT (bb->succs) != 2)
2027         return;
2028       extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
2029
2030       INDENT (indent + 2);
2031       pp_cfg_jump (buffer, true_edge->dest);
2032       newline_and_indent (buffer, indent);
2033       pp_string (buffer, "else");
2034       newline_and_indent (buffer, indent + 2);
2035       pp_cfg_jump (buffer, false_edge->dest);
2036       pp_newline (buffer);
2037       return;
2038     }
2039
2040   /* If there is a fallthru edge, we may need to add an artificial
2041      goto to the dump.  */
2042   e = find_fallthru_edge (bb->succs);
2043
2044   if (e && e->dest != bb->next_bb)
2045     {
2046       INDENT (indent);
2047
2048       if ((flags & TDF_LINENO)
2049           && e->goto_locus != UNKNOWN_LOCATION
2050           )
2051         {
2052           expanded_location goto_xloc;
2053           goto_xloc = expand_location (e->goto_locus);
2054           pp_character (buffer, '[');
2055           if (goto_xloc.file)
2056             {
2057               pp_string (buffer, goto_xloc.file);
2058               pp_string (buffer, " : ");
2059             }
2060           pp_decimal_int (buffer, goto_xloc.line);
2061           pp_string (buffer, " : ");
2062           pp_decimal_int (buffer, goto_xloc.column);
2063           pp_string (buffer, "] ");
2064         }
2065
2066       pp_cfg_jump (buffer, e->dest);
2067       pp_newline (buffer);
2068     }
2069 }
2070
2071
2072 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2073    indented by INDENT spaces.  */
2074
2075 static void
2076 gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent,
2077                      int flags)
2078 {
2079   gimple_stmt_iterator gsi;
2080   gimple stmt;
2081   int label_indent = indent - 2;
2082
2083   if (label_indent < 0)
2084     label_indent = 0;
2085
2086   dump_bb_header (buffer, bb, indent, flags);
2087   dump_phi_nodes (buffer, bb, indent, flags);
2088
2089   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
2090     {
2091       int curr_indent;
2092
2093       stmt = gsi_stmt (gsi);
2094
2095       curr_indent = gimple_code (stmt) == GIMPLE_LABEL ? label_indent : indent;
2096
2097       INDENT (curr_indent);
2098       dump_gimple_stmt (buffer, stmt, curr_indent, flags);
2099       pp_newline (buffer);
2100       dump_histograms_for_stmt (cfun, buffer->buffer->stream, stmt);
2101     }
2102
2103   dump_implicit_edges (buffer, bb, indent, flags);
2104
2105   if (flags & TDF_BLOCKS)
2106     dump_bb_end (buffer, bb, indent, flags);
2107 }
2108
2109
2110 /* Dumps basic block BB to FILE with details described by FLAGS and
2111    indented by INDENT spaces.  */
2112
2113 void
2114 gimple_dump_bb (basic_block bb, FILE *file, int indent, int flags)
2115 {
2116   maybe_init_pretty_print (file);
2117   gimple_dump_bb_buff (&buffer, bb, indent, flags);
2118   pp_flush (&buffer);
2119 }