contrib/gcc-8.0/gcc/gimple-pretty-print.c

   1 /* Pretty formatting of GIMPLE statements and expressions.
   2    Copyright (C) 2001-2018 Free Software Foundation, Inc.
   3    Contributed by Aldy Hernandez <aldyh@redhat.com> and
   4    Diego Novillo <dnovillo@google.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "dumpfile.h"
  26 #include "backend.h"
  27 #include "tree.h"
  28 #include "gimple.h"
  29 #include "gimple-predict.h"
  30 #include "ssa.h"
  31 #include "cgraph.h"
  32 #include "gimple-pretty-print.h"
  33 #include "internal-fn.h"
  34 #include "tree-eh.h"
  35 #include "gimple-iterator.h"
  36 #include "tree-cfg.h"
  37 #include "dumpfile.h"   /* for dump_flags */
  38 #include "value-prof.h"
  39 #include "trans-mem.h"
  40 #include "cfganal.h"
  41 #include "stringpool.h"
  42 #include "attribs.h"
  43 #include "asan.h"
  44
  45 #define INDENT(SPACE)                                                   \
  46   do { int i; for (i = 0; i < SPACE; i++) pp_space (buffer); } while (0)
  47
  48 #define GIMPLE_NIY do_niy (buffer,gs)
  49
  50 /* Try to print on BUFFER a default message for the unrecognized
  51    gimple statement GS.  */
  52
  53 static void
  54 do_niy (pretty_printer *buffer, gimple *gs)
  55 {
  56   pp_printf (buffer, "<<< Unknown GIMPLE statement: %s >>>\n",
  57              gimple_code_name[(int) gimple_code (gs)]);
  58 }
  59
  60
  61 /* Emit a newline and SPC indentation spaces to BUFFER.  */
  62
  63 static void
  64 newline_and_indent (pretty_printer *buffer, int spc)
  65 {
  66   pp_newline (buffer);
  67   INDENT (spc);
  68 }
  69
  70
  71 /* Print the GIMPLE statement GS on stderr.  */
  72
  73 DEBUG_FUNCTION void
  74 debug_gimple_stmt (gimple *gs)
  75 {
  76   print_gimple_stmt (stderr, gs, 0, TDF_VOPS|TDF_MEMSYMS);
  77 }
  78
  79
  80 /* Return formatted string of a VALUE probability
  81    (biased by REG_BR_PROB_BASE).  Returned string is allocated
  82    by xstrdup_for_dump.  */
  83
  84 static const char *
  85 dump_profile (profile_count &count)
  86 {
  87   char *buf = NULL;
  88   if (!count.initialized_p ())
  89     return "";
  90   if (count.ipa_p ())
  91     buf = xasprintf ("[count: %" PRId64 "]",
  92                      count.to_gcov_type ());
  93   else if (count.initialized_p ())
  94     buf = xasprintf ("[local count: %" PRId64 "]",
  95                      count.to_gcov_type ());
  96
  97   const char *ret = xstrdup_for_dump (buf);
  98   free (buf);
  99
 100   return ret;
 101 }
 102
 103 /* Return formatted string of a VALUE probability
 104    (biased by REG_BR_PROB_BASE).  Returned string is allocated
 105    by xstrdup_for_dump.  */
 106
 107 static const char *
 108 dump_probability (profile_probability probability)
 109 {
 110   float minimum = 0.01f;
 111   float fvalue = -1;
 112
 113   if (probability.initialized_p ())
 114     {
 115       fvalue = probability.to_reg_br_prob_base () * 100.0f / REG_BR_PROB_BASE;
 116       if (fvalue < minimum && probability.to_reg_br_prob_base ())
 117         fvalue = minimum;
 118     }
 119
 120   char *buf;
 121   if (probability.initialized_p ())
 122     buf = xasprintf ("[%.2f%%]", fvalue);
 123   else
 124     buf = xasprintf ("[INV]");
 125
 126   const char *ret = xstrdup_for_dump (buf);
 127   free (buf);
 128
 129   return ret;
 130 }
 131
 132 /* Dump E probability to BUFFER.  */
 133
 134 static void
 135 dump_edge_probability (pretty_printer *buffer, edge e)
 136 {
 137   pp_scalar (buffer, " %s", dump_probability (e->probability));
 138 }
 139
 140 /* Print GIMPLE statement G to FILE using SPC indentation spaces and
 141    FLAGS as in pp_gimple_stmt_1.  */
 142
 143 void
 144 print_gimple_stmt (FILE *file, gimple *g, int spc, dump_flags_t flags)
 145 {
 146   pretty_printer buffer;
 147   pp_needs_newline (&buffer) = true;
 148   buffer.buffer->stream = file;
 149   pp_gimple_stmt_1 (&buffer, g, spc, flags);
 150   pp_newline_and_flush (&buffer);
 151 }
 152
 153 DEBUG_FUNCTION void
 154 debug (gimple &ref)
 155 {
 156   print_gimple_stmt (stderr, &ref, 0, 0);
 157 }
 158
 159 DEBUG_FUNCTION void
 160 debug (gimple *ptr)
 161 {
 162   if (ptr)
 163     debug (*ptr);
 164   else
 165     fprintf (stderr, "<nil>\n");
 166 }
 167
 168
 169 /* Print GIMPLE statement G to FILE using SPC indentation spaces and
 170    FLAGS as in pp_gimple_stmt_1.  Print only the right-hand side
 171    of the statement.  */
 172
 173 void
 174 print_gimple_expr (FILE *file, gimple *g, int spc, dump_flags_t flags)
 175 {
 176   flags |= TDF_RHS_ONLY;
 177   pretty_printer buffer;
 178   pp_needs_newline (&buffer) = true;
 179   buffer.buffer->stream = file;
 180   pp_gimple_stmt_1 (&buffer, g, spc, flags);
 181   pp_flush (&buffer);
 182 }
 183
 184
 185 /* Print the GIMPLE sequence SEQ on BUFFER using SPC indentation
 186    spaces and FLAGS as in pp_gimple_stmt_1.
 187    The caller is responsible for calling pp_flush on BUFFER to finalize
 188    the pretty printer.  */
 189
 190 static void
 191 dump_gimple_seq (pretty_printer *buffer, gimple_seq seq, int spc,
 192                  dump_flags_t flags)
 193 {
 194   gimple_stmt_iterator i;
 195
 196   for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
 197     {
 198       gimple *gs = gsi_stmt (i);
 199       INDENT (spc);
 200       pp_gimple_stmt_1 (buffer, gs, spc, flags);
 201       if (!gsi_one_before_end_p (i))
 202         pp_newline (buffer);
 203     }
 204 }
 205
 206
 207 /* Print GIMPLE sequence SEQ to FILE using SPC indentation spaces and
 208    FLAGS as in pp_gimple_stmt_1.  */
 209
 210 void
 211 print_gimple_seq (FILE *file, gimple_seq seq, int spc, dump_flags_t flags)
 212 {
 213   pretty_printer buffer;
 214   pp_needs_newline (&buffer) = true;
 215   buffer.buffer->stream = file;
 216   dump_gimple_seq (&buffer, seq, spc, flags);
 217   pp_newline_and_flush (&buffer);
 218 }
 219
 220
 221 /* Print the GIMPLE sequence SEQ on stderr.  */
 222
 223 DEBUG_FUNCTION void
 224 debug_gimple_seq (gimple_seq seq)
 225 {
 226   print_gimple_seq (stderr, seq, 0, TDF_VOPS|TDF_MEMSYMS);
 227 }
 228
 229
 230 /* A simple helper to pretty-print some of the gimple tuples in the printf
 231    style. The format modifiers are preceded by '%' and are:
 232      'G' - outputs a string corresponding to the code of the given gimple,
 233      'S' - outputs a gimple_seq with indent of spc + 2,
 234      'T' - outputs the tree t,
 235      'd' - outputs an int as a decimal,
 236      's' - outputs a string,
 237      'n' - outputs a newline,
 238      'x' - outputs an int as hexadecimal,
 239      '+' - increases indent by 2 then outputs a newline,
 240      '-' - decreases indent by 2 then outputs a newline.   */
 241
 242 static void
 243 dump_gimple_fmt (pretty_printer *buffer, int spc, dump_flags_t flags,
 244                  const char *fmt, ...)
 245 {
 246   va_list args;
 247   const char *c;
 248   const char *tmp;
 249
 250   va_start (args, fmt);
 251   for (c = fmt; *c; c++)
 252     {
 253       if (*c == '%')
 254         {
 255           gimple_seq seq;
 256           tree t;
 257           gimple *g;
 258           switch (*++c)
 259             {
 260               case 'G':
 261                 g = va_arg (args, gimple *);
 262                 tmp = gimple_code_name[gimple_code (g)];
 263                 pp_string (buffer, tmp);
 264                 break;
 265
 266               case 'S':
 267                 seq = va_arg (args, gimple_seq);
 268                 pp_newline (buffer);
 269                 dump_gimple_seq (buffer, seq, spc + 2, flags);
 270                 newline_and_indent (buffer, spc);
 271                 break;
 272
 273               case 'T':
 274                 t = va_arg (args, tree);
 275                 if (t == NULL_TREE)
 276                   pp_string (buffer, "NULL");
 277                 else
 278                   dump_generic_node (buffer, t, spc, flags, false);
 279                 break;
 280
 281               case 'd':
 282                 pp_decimal_int (buffer, va_arg (args, int));
 283                 break;
 284
 285               case 's':
 286                 pp_string (buffer, va_arg (args, char *));
 287                 break;
 288
 289               case 'n':
 290                 newline_and_indent (buffer, spc);
 291                 break;
 292
 293               case 'x':
 294                 pp_scalar (buffer, "%x", va_arg (args, int));
 295                 break;
 296
 297               case '+':
 298                 spc += 2;
 299                 newline_and_indent (buffer, spc);
 300                 break;
 301
 302               case '-':
 303                 spc -= 2;
 304                 newline_and_indent (buffer, spc);
 305                 break;
 306
 307               default:
 308                 gcc_unreachable ();
 309             }
 310         }
 311       else
 312         pp_character (buffer, *c);
 313     }
 314   va_end (args);
 315 }
 316
 317
 318 /* Helper for dump_gimple_assign.  Print the unary RHS of the
 319    assignment GS.  BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1.  */
 320
 321 static void
 322 dump_unary_rhs (pretty_printer *buffer, gassign *gs, int spc,
 323                 dump_flags_t flags)
 324 {
 325   enum tree_code rhs_code = gimple_assign_rhs_code (gs);
 326   tree lhs = gimple_assign_lhs (gs);
 327   tree rhs = gimple_assign_rhs1 (gs);
 328
 329   switch (rhs_code)
 330     {
 331     case VIEW_CONVERT_EXPR:
 332     case ASSERT_EXPR:
 333       dump_generic_node (buffer, rhs, spc, flags, false);
 334       break;
 335
 336     case FIXED_CONVERT_EXPR:
 337     case ADDR_SPACE_CONVERT_EXPR:
 338     case FIX_TRUNC_EXPR:
 339     case FLOAT_EXPR:
 340     CASE_CONVERT:
 341       pp_left_paren (buffer);
 342       dump_generic_node (buffer, TREE_TYPE (lhs), spc, flags, false);
 343       pp_string (buffer, ") ");
 344       if (op_prio (rhs) < op_code_prio (rhs_code))
 345         {
 346           pp_left_paren (buffer);
 347           dump_generic_node (buffer, rhs, spc, flags, false);
 348           pp_right_paren (buffer);
 349         }
 350       else
 351         dump_generic_node (buffer, rhs, spc, flags, false);
 352       break;
 353
 354     case PAREN_EXPR:
 355       pp_string (buffer, "((");
 356       dump_generic_node (buffer, rhs, spc, flags, false);
 357       pp_string (buffer, "))");
 358       break;
 359
 360     case ABS_EXPR:
 361       if (flags & TDF_GIMPLE)
 362         {
 363           pp_string (buffer, "__ABS ");
 364           dump_generic_node (buffer, rhs, spc, flags, false);
 365         }
 366       else
 367         {
 368           pp_string (buffer, "ABS_EXPR <");
 369           dump_generic_node (buffer, rhs, spc, flags, false);
 370           pp_greater (buffer);
 371         }
 372       break;
 373
 374     default:
 375       if (TREE_CODE_CLASS (rhs_code) == tcc_declaration
 376           || TREE_CODE_CLASS (rhs_code) == tcc_constant
 377           || TREE_CODE_CLASS (rhs_code) == tcc_reference
 378           || rhs_code == SSA_NAME
 379           || rhs_code == ADDR_EXPR
 380           || rhs_code == CONSTRUCTOR)
 381         {
 382           dump_generic_node (buffer, rhs, spc, flags, false);
 383           break;
 384         }
 385       else if (rhs_code == BIT_NOT_EXPR)
 386         pp_complement (buffer);
 387       else if (rhs_code == TRUTH_NOT_EXPR)
 388         pp_exclamation (buffer);
 389       else if (rhs_code == NEGATE_EXPR)
 390         pp_minus (buffer);
 391       else
 392         {
 393           pp_left_bracket (buffer);
 394           pp_string (buffer, get_tree_code_name (rhs_code));
 395           pp_string (buffer, "] ");
 396         }
 397
 398       if (op_prio (rhs) < op_code_prio (rhs_code))
 399         {
 400           pp_left_paren (buffer);
 401           dump_generic_node (buffer, rhs, spc, flags, false);
 402           pp_right_paren (buffer);
 403         }
 404       else
 405         dump_generic_node (buffer, rhs, spc, flags, false);
 406       break;
 407     }
 408 }
 409
 410
 411 /* Helper for dump_gimple_assign.  Print the binary RHS of the
 412    assignment GS.  BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1.  */
 413
 414 static void
 415 dump_binary_rhs (pretty_printer *buffer, gassign *gs, int spc,
 416                  dump_flags_t flags)
 417 {
 418   const char *p;
 419   enum tree_code code = gimple_assign_rhs_code (gs);
 420   switch (code)
 421     {
 422     case COMPLEX_EXPR:
 423     case MIN_EXPR:
 424     case MAX_EXPR:
 425     case VEC_WIDEN_MULT_HI_EXPR:
 426     case VEC_WIDEN_MULT_LO_EXPR:
 427     case VEC_WIDEN_MULT_EVEN_EXPR:
 428     case VEC_WIDEN_MULT_ODD_EXPR:
 429     case VEC_PACK_TRUNC_EXPR:
 430     case VEC_PACK_SAT_EXPR:
 431     case VEC_PACK_FIX_TRUNC_EXPR:
 432     case VEC_WIDEN_LSHIFT_HI_EXPR:
 433     case VEC_WIDEN_LSHIFT_LO_EXPR:
 434     case VEC_SERIES_EXPR:
 435       for (p = get_tree_code_name (code); *p; p++)
 436         pp_character (buffer, TOUPPER (*p));
 437       pp_string (buffer, " <");
 438       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 439       pp_string (buffer, ", ");
 440       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 441       pp_greater (buffer);
 442       break;
 443
 444     default:
 445       if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code))
 446         {
 447           pp_left_paren (buffer);
 448           dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags,
 449                              false);
 450           pp_right_paren (buffer);
 451         }
 452       else
 453         dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 454       pp_space (buffer);
 455       pp_string (buffer, op_symbol_code (gimple_assign_rhs_code (gs)));
 456       pp_space (buffer);
 457       if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code))
 458         {
 459           pp_left_paren (buffer);
 460           dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags,
 461                              false);
 462           pp_right_paren (buffer);
 463         }
 464       else
 465         dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 466     }
 467 }
 468
 469 /* Helper for dump_gimple_assign.  Print the ternary RHS of the
 470    assignment GS.  BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1.  */
 471
 472 static void
 473 dump_ternary_rhs (pretty_printer *buffer, gassign *gs, int spc,
 474                   dump_flags_t flags)
 475 {
 476   const char *p;
 477   enum tree_code code = gimple_assign_rhs_code (gs);
 478   switch (code)
 479     {
 480     case WIDEN_MULT_PLUS_EXPR:
 481     case WIDEN_MULT_MINUS_EXPR:
 482       for (p = get_tree_code_name (code); *p; p++)
 483         pp_character (buffer, TOUPPER (*p));
 484       pp_string (buffer, " <");
 485       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 486       pp_string (buffer, ", ");
 487       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 488       pp_string (buffer, ", ");
 489       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 490       pp_greater (buffer);
 491       break;
 492
 493     case FMA_EXPR:
 494       if (flags & TDF_GIMPLE)
 495         {
 496           pp_string (buffer, "__FMA (");
 497           dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 498           pp_comma (buffer);
 499           dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 500           pp_comma (buffer);
 501           dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 502           pp_right_paren (buffer);
 503         }
 504       else
 505         {
 506           dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 507           pp_string (buffer, " * ");
 508           dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 509           pp_string (buffer, " + ");
 510           dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 511         }
 512       break;
 513
 514     case DOT_PROD_EXPR:
 515       pp_string (buffer, "DOT_PROD_EXPR <");
 516       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 517       pp_string (buffer, ", ");
 518       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 519       pp_string (buffer, ", ");
 520       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 521       pp_greater (buffer);
 522       break;
 523
 524     case SAD_EXPR:
 525       pp_string (buffer, "SAD_EXPR <");
 526       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 527       pp_string (buffer, ", ");
 528       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 529       pp_string (buffer, ", ");
 530       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 531       pp_greater (buffer);
 532       break;
 533
 534     case VEC_PERM_EXPR:
 535       pp_string (buffer, "VEC_PERM_EXPR <");
 536       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 537       pp_string (buffer, ", ");
 538       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 539       pp_string (buffer, ", ");
 540       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 541       pp_greater (buffer);
 542       break;
 543
 544     case REALIGN_LOAD_EXPR:
 545       pp_string (buffer, "REALIGN_LOAD <");
 546       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 547       pp_string (buffer, ", ");
 548       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 549       pp_string (buffer, ", ");
 550       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 551       pp_greater (buffer);
 552       break;
 553
 554     case COND_EXPR:
 555       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 556       pp_string (buffer, " ? ");
 557       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 558       pp_string (buffer, " : ");
 559       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 560       break;
 561
 562     case VEC_COND_EXPR:
 563       pp_string (buffer, "VEC_COND_EXPR <");
 564       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 565       pp_string (buffer, ", ");
 566       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 567       pp_string (buffer, ", ");
 568       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 569       pp_greater (buffer);
 570       break;
 571
 572     case BIT_INSERT_EXPR:
 573       pp_string (buffer, "BIT_INSERT_EXPR <");
 574       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
 575       pp_string (buffer, ", ");
 576       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
 577       pp_string (buffer, ", ");
 578       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
 579       pp_string (buffer, " (");
 580       if (INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_rhs2 (gs))))
 581         pp_decimal_int (buffer,
 582                         TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs2 (gs))));
 583       else
 584         dump_generic_node (buffer,
 585                            TYPE_SIZE (TREE_TYPE (gimple_assign_rhs2 (gs))),
 586                            spc, flags, false);
 587       pp_string (buffer, " bits)>");
 588       break;
 589
 590     default:
 591       gcc_unreachable ();
 592     }
 593 }
 594
 595
 596 /* Dump the gimple assignment GS.  BUFFER, SPC and FLAGS are as in
 597    pp_gimple_stmt_1.  */
 598
 599 static void
 600 dump_gimple_assign (pretty_printer *buffer, gassign *gs, int spc,
 601                     dump_flags_t flags)
 602 {
 603   if (flags & TDF_RAW)
 604     {
 605       tree arg1 = NULL;
 606       tree arg2 = NULL;
 607       tree arg3 = NULL;
 608       switch (gimple_num_ops (gs))
 609         {
 610         case 4:
 611           arg3 = gimple_assign_rhs3 (gs);
 612           /* FALLTHRU */
 613         case 3:
 614           arg2 = gimple_assign_rhs2 (gs);
 615           /* FALLTHRU */
 616         case 2:
 617           arg1 = gimple_assign_rhs1 (gs);
 618           break;
 619         default:
 620           gcc_unreachable ();
 621         }
 622
 623       dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
 624                        get_tree_code_name (gimple_assign_rhs_code (gs)),
 625                        gimple_assign_lhs (gs), arg1, arg2, arg3);
 626     }
 627   else
 628     {
 629       if (!(flags & TDF_RHS_ONLY))
 630         {
 631           dump_generic_node (buffer, gimple_assign_lhs (gs), spc, flags, false);
 632           pp_space (buffer);
 633           pp_equal (buffer);
 634
 635           if (gimple_assign_nontemporal_move_p (gs))
 636             pp_string (buffer, "{nt}");
 637
 638           if (gimple_has_volatile_ops (gs))
 639             pp_string (buffer, "{v}");
 640
 641           pp_space (buffer);
 642         }
 643
 644       if (gimple_num_ops (gs) == 2)
 645         dump_unary_rhs (buffer, gs, spc, flags);
 646       else if (gimple_num_ops (gs) == 3)
 647         dump_binary_rhs (buffer, gs, spc, flags);
 648       else if (gimple_num_ops (gs) == 4)
 649         dump_ternary_rhs (buffer, gs, spc, flags);
 650       else
 651         gcc_unreachable ();
 652       if (!(flags & TDF_RHS_ONLY))
 653         pp_semicolon (buffer);
 654     }
 655 }
 656
 657
 658 /* Dump the return statement GS.  BUFFER, SPC and FLAGS are as in
 659    pp_gimple_stmt_1.  */
 660
 661 static void
 662 dump_gimple_return (pretty_printer *buffer, greturn *gs, int spc,
 663                     dump_flags_t flags)
 664 {
 665   tree t, t2;
 666
 667   t = gimple_return_retval (gs);
 668   t2 = gimple_return_retbnd (gs);
 669   if (flags & TDF_RAW)
 670     dump_gimple_fmt (buffer, spc, flags, "%G <%T %T>", gs, t, t2);
 671   else
 672     {
 673       pp_string (buffer, "return");
 674       if (t)
 675         {
 676           pp_space (buffer);
 677           dump_generic_node (buffer, t, spc, flags, false);
 678         }
 679       if (t2)
 680         {
 681           pp_string (buffer, ", ");
 682           dump_generic_node (buffer, t2, spc, flags, false);
 683         }
 684       pp_semicolon (buffer);
 685     }
 686 }
 687
 688
 689 /* Dump the call arguments for a gimple call. BUFFER, FLAGS are as in
 690    dump_gimple_call.  */
 691
 692 static void
 693 dump_gimple_call_args (pretty_printer *buffer, gcall *gs, dump_flags_t flags)
 694 {
 695   size_t i = 0;
 696
 697   /* Pretty print first arg to certain internal fns.  */
 698   if (gimple_call_internal_p (gs))
 699     {
 700       const char *const *enums = NULL;
 701       unsigned limit = 0;
 702
 703       switch (gimple_call_internal_fn (gs))
 704         {
 705         case IFN_UNIQUE:
 706 #define DEF(X) #X
 707           static const char *const unique_args[] = {IFN_UNIQUE_CODES};
 708 #undef DEF
 709           enums = unique_args;
 710
 711           limit = ARRAY_SIZE (unique_args);
 712           break;
 713
 714         case IFN_GOACC_LOOP:
 715 #define DEF(X) #X
 716           static const char *const loop_args[] = {IFN_GOACC_LOOP_CODES};
 717 #undef DEF
 718           enums = loop_args;
 719           limit = ARRAY_SIZE (loop_args);
 720           break;
 721
 722         case IFN_GOACC_REDUCTION:
 723 #define DEF(X) #X
 724           static const char *const reduction_args[]
 725             = {IFN_GOACC_REDUCTION_CODES};
 726 #undef DEF
 727           enums = reduction_args;
 728           limit = ARRAY_SIZE (reduction_args);
 729           break;
 730
 731         case IFN_ASAN_MARK:
 732 #define DEF(X) #X
 733           static const char *const asan_mark_args[] = {IFN_ASAN_MARK_FLAGS};
 734 #undef DEF
 735           enums = asan_mark_args;
 736           limit = ARRAY_SIZE (asan_mark_args);
 737           break;
 738
 739         default:
 740           break;
 741         }
 742       if (limit)
 743         {
 744           tree arg0 = gimple_call_arg (gs, 0);
 745           HOST_WIDE_INT v;
 746
 747           if (TREE_CODE (arg0) == INTEGER_CST
 748               && tree_fits_shwi_p (arg0)
 749               && (v = tree_to_shwi (arg0)) >= 0 && v < limit)
 750             {
 751               i++;
 752               pp_string (buffer, enums[v]);
 753             }
 754         }
 755     }
 756
 757   for (; i < gimple_call_num_args (gs); i++)
 758     {
 759       if (i)
 760         pp_string (buffer, ", ");
 761       dump_generic_node (buffer, gimple_call_arg (gs, i), 0, flags, false);
 762     }
 763
 764   if (gimple_call_va_arg_pack_p (gs))
 765     {
 766       if (i)
 767         pp_string (buffer, ", ");
 768
 769       pp_string (buffer, "__builtin_va_arg_pack ()");
 770     }
 771 }
 772
 773 /* Dump the points-to solution *PT to BUFFER.  */
 774
 775 static void
 776 pp_points_to_solution (pretty_printer *buffer, struct pt_solution *pt)
 777 {
 778   if (pt->anything)
 779     {
 780       pp_string (buffer, "anything ");
 781       return;
 782     }
 783   if (pt->nonlocal)
 784     pp_string (buffer, "nonlocal ");
 785   if (pt->escaped)
 786     pp_string (buffer, "escaped ");
 787   if (pt->ipa_escaped)
 788     pp_string (buffer, "unit-escaped ");
 789   if (pt->null)
 790     pp_string (buffer, "null ");
 791   if (pt->vars
 792       && !bitmap_empty_p (pt->vars))
 793     {
 794       bitmap_iterator bi;
 795       unsigned i;
 796       pp_string (buffer, "{ ");
 797       EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
 798         {
 799           pp_string (buffer, "D.");
 800           pp_decimal_int (buffer, i);
 801           pp_space (buffer);
 802         }
 803       pp_right_brace (buffer);
 804       if (pt->vars_contains_nonlocal
 805           || pt->vars_contains_escaped
 806           || pt->vars_contains_escaped_heap
 807           || pt->vars_contains_restrict)
 808         {
 809           const char *comma = "";
 810           pp_string (buffer, " (");
 811           if (pt->vars_contains_nonlocal)
 812             {
 813               pp_string (buffer, "nonlocal");
 814               comma = ", ";
 815             }
 816           if (pt->vars_contains_escaped)
 817             {
 818               pp_string (buffer, comma);
 819               pp_string (buffer, "escaped");
 820               comma = ", ";
 821             }
 822           if (pt->vars_contains_escaped_heap)
 823             {
 824               pp_string (buffer, comma);
 825               pp_string (buffer, "escaped heap");
 826               comma = ", ";
 827             }
 828           if (pt->vars_contains_restrict)
 829             {
 830               pp_string (buffer, comma);
 831               pp_string (buffer, "restrict");
 832               comma = ", ";
 833             }
 834           if (pt->vars_contains_interposable)
 835             {
 836               pp_string (buffer, comma);
 837               pp_string (buffer, "interposable");
 838             }
 839           pp_string (buffer, ")");
 840         }
 841
 842     }
 843 }
 844
 845 /* Dump the call statement GS.  BUFFER, SPC and FLAGS are as in
 846    pp_gimple_stmt_1.  */
 847
 848 static void
 849 dump_gimple_call (pretty_printer *buffer, gcall *gs, int spc,
 850                   dump_flags_t flags)
 851 {
 852   tree lhs = gimple_call_lhs (gs);
 853   tree fn = gimple_call_fn (gs);
 854
 855   if (flags & TDF_ALIAS)
 856     {
 857       struct pt_solution *pt;
 858       pt = gimple_call_use_set (gs);
 859       if (!pt_solution_empty_p (pt))
 860         {
 861           pp_string (buffer, "# USE = ");
 862           pp_points_to_solution (buffer, pt);
 863           newline_and_indent (buffer, spc);
 864         }
 865       pt = gimple_call_clobber_set (gs);
 866       if (!pt_solution_empty_p (pt))
 867         {
 868           pp_string (buffer, "# CLB = ");
 869           pp_points_to_solution (buffer, pt);
 870           newline_and_indent (buffer, spc);
 871         }
 872     }
 873
 874   if (flags & TDF_RAW)
 875     {
 876       if (gimple_call_internal_p (gs))
 877         dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T", gs,
 878                          internal_fn_name (gimple_call_internal_fn (gs)), lhs);
 879       else
 880         dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T", gs, fn, lhs);
 881       if (gimple_call_num_args (gs) > 0)
 882         {
 883           pp_string (buffer, ", ");
 884           dump_gimple_call_args (buffer, gs, flags);
 885         }
 886       pp_greater (buffer);
 887     }
 888   else
 889     {
 890       if (lhs && !(flags & TDF_RHS_ONLY))
 891         {
 892           dump_generic_node (buffer, lhs, spc, flags, false);
 893           pp_string (buffer, " =");
 894
 895           if (gimple_has_volatile_ops (gs))
 896             pp_string (buffer, "{v}");
 897
 898           pp_space (buffer);
 899         }
 900       if (gimple_call_internal_p (gs))
 901         pp_string (buffer, internal_fn_name (gimple_call_internal_fn (gs)));
 902       else
 903         print_call_name (buffer, fn, flags);
 904       pp_string (buffer, " (");
 905       dump_gimple_call_args (buffer, gs, flags);
 906       pp_right_paren (buffer);
 907       if (!(flags & TDF_RHS_ONLY))
 908         pp_semicolon (buffer);
 909     }
 910
 911   if (gimple_call_chain (gs))
 912     {
 913       pp_string (buffer, " [static-chain: ");
 914       dump_generic_node (buffer, gimple_call_chain (gs), spc, flags, false);
 915       pp_right_bracket (buffer);
 916     }
 917
 918   if (gimple_call_return_slot_opt_p (gs))
 919     pp_string (buffer, " [return slot optimization]");
 920   if (gimple_call_tail_p (gs))
 921     pp_string (buffer, " [tail call]");
 922   if (gimple_call_must_tail_p (gs))
 923     pp_string (buffer, " [must tail call]");
 924
 925   if (fn == NULL)
 926     return;
 927
 928   /* Dump the arguments of _ITM_beginTransaction sanely.  */
 929   if (TREE_CODE (fn) == ADDR_EXPR)
 930     fn = TREE_OPERAND (fn, 0);
 931   if (TREE_CODE (fn) == FUNCTION_DECL && decl_is_tm_clone (fn))
 932     pp_string (buffer, " [tm-clone]");
 933   if (TREE_CODE (fn) == FUNCTION_DECL
 934       && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
 935       && DECL_FUNCTION_CODE (fn) == BUILT_IN_TM_START
 936       && gimple_call_num_args (gs) > 0)
 937     {
 938       tree t = gimple_call_arg (gs, 0);
 939       unsigned HOST_WIDE_INT props;
 940       gcc_assert (TREE_CODE (t) == INTEGER_CST);
 941
 942       pp_string (buffer, " [ ");
 943
 944       /* Get the transaction code properties.  */
 945       props = TREE_INT_CST_LOW (t);
 946
 947       if (props & PR_INSTRUMENTEDCODE)
 948         pp_string (buffer, "instrumentedCode ");
 949       if (props & PR_UNINSTRUMENTEDCODE)
 950         pp_string (buffer, "uninstrumentedCode ");
 951       if (props & PR_HASNOXMMUPDATE)
 952         pp_string (buffer, "hasNoXMMUpdate ");
 953       if (props & PR_HASNOABORT)
 954         pp_string (buffer, "hasNoAbort ");
 955       if (props & PR_HASNOIRREVOCABLE)
 956         pp_string (buffer, "hasNoIrrevocable ");
 957       if (props & PR_DOESGOIRREVOCABLE)
 958         pp_string (buffer, "doesGoIrrevocable ");
 959       if (props & PR_HASNOSIMPLEREADS)
 960         pp_string (buffer, "hasNoSimpleReads ");
 961       if (props & PR_AWBARRIERSOMITTED)
 962         pp_string (buffer, "awBarriersOmitted ");
 963       if (props & PR_RARBARRIERSOMITTED)
 964         pp_string (buffer, "RaRBarriersOmitted ");
 965       if (props & PR_UNDOLOGCODE)
 966         pp_string (buffer, "undoLogCode ");
 967       if (props & PR_PREFERUNINSTRUMENTED)
 968         pp_string (buffer, "preferUninstrumented ");
 969       if (props & PR_EXCEPTIONBLOCK)
 970         pp_string (buffer, "exceptionBlock ");
 971       if (props & PR_HASELSE)
 972         pp_string (buffer, "hasElse ");
 973       if (props & PR_READONLY)
 974         pp_string (buffer, "readOnly ");
 975
 976       pp_right_bracket (buffer);
 977     }
 978 }
 979
 980
 981 /* Dump the switch statement GS.  BUFFER, SPC and FLAGS are as in
 982    pp_gimple_stmt_1.  */
 983
 984 static void
 985 dump_gimple_switch (pretty_printer *buffer, gswitch *gs, int spc,
 986                     dump_flags_t flags)
 987 {
 988   unsigned int i;
 989
 990   GIMPLE_CHECK (gs, GIMPLE_SWITCH);
 991   if (flags & TDF_RAW)
 992     dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", gs,
 993                    gimple_switch_index (gs));
 994   else
 995     {
 996       pp_string (buffer, "switch (");
 997       dump_generic_node (buffer, gimple_switch_index (gs), spc, flags, true);
 998       if (flags & TDF_GIMPLE)
 999         pp_string (buffer, ") {");
1000       else
1001         pp_string (buffer, ") <");
1002     }
1003
1004   for (i = 0; i < gimple_switch_num_labels (gs); i++)
1005     {
1006       tree case_label = gimple_switch_label (gs, i);
1007       gcc_checking_assert (case_label != NULL_TREE);
1008       dump_generic_node (buffer, case_label, spc, flags, false);
1009       pp_space (buffer);
1010       tree label = CASE_LABEL (case_label);
1011       dump_generic_node (buffer, label, spc, flags, false);
1012
1013       if (cfun && cfun->cfg)
1014         {
1015           basic_block dest = label_to_block (label);
1016           if (dest)
1017             {
1018               edge label_edge = find_edge (gimple_bb (gs), dest);
1019               if (label_edge && !(flags & TDF_GIMPLE))
1020                 dump_edge_probability (buffer, label_edge);
1021             }
1022         }
1023
1024       if (i < gimple_switch_num_labels (gs) - 1)
1025         {
1026           if (flags & TDF_GIMPLE)
1027             pp_string (buffer, "; ");
1028           else
1029             pp_string (buffer, ", ");
1030         }
1031     }
1032   if (flags & TDF_GIMPLE)
1033     pp_string (buffer, "; }");
1034   else
1035     pp_greater (buffer);
1036 }
1037
1038
1039 /* Dump the gimple conditional GS.  BUFFER, SPC and FLAGS are as in
1040    pp_gimple_stmt_1.  */
1041
1042 static void
1043 dump_gimple_cond (pretty_printer *buffer, gcond *gs, int spc,
1044                   dump_flags_t flags)
1045 {
1046   if (flags & TDF_RAW)
1047     dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
1048                      get_tree_code_name (gimple_cond_code (gs)),
1049                      gimple_cond_lhs (gs), gimple_cond_rhs (gs),
1050                      gimple_cond_true_label (gs), gimple_cond_false_label (gs));
1051   else
1052     {
1053       if (!(flags & TDF_RHS_ONLY))
1054         pp_string (buffer, "if (");
1055       dump_generic_node (buffer, gimple_cond_lhs (gs), spc, flags, false);
1056       pp_space (buffer);
1057       pp_string (buffer, op_symbol_code (gimple_cond_code (gs)));
1058       pp_space (buffer);
1059       dump_generic_node (buffer, gimple_cond_rhs (gs), spc, flags, false);
1060       if (!(flags & TDF_RHS_ONLY))
1061         {
1062           edge_iterator ei;
1063           edge e, true_edge = NULL, false_edge = NULL;
1064           basic_block bb = gimple_bb (gs);
1065
1066           if (bb)
1067             {
1068               FOR_EACH_EDGE (e, ei, bb->succs)
1069                 {
1070                   if (e->flags & EDGE_TRUE_VALUE)
1071                     true_edge = e;
1072                   else if (e->flags & EDGE_FALSE_VALUE)
1073                     false_edge = e;
1074                 }
1075             }
1076
1077           bool has_edge_info = true_edge != NULL && false_edge != NULL;
1078
1079           pp_right_paren (buffer);
1080
1081           if (gimple_cond_true_label (gs))
1082             {
1083               pp_string (buffer, " goto ");
1084               dump_generic_node (buffer, gimple_cond_true_label (gs),
1085                                  spc, flags, false);
1086               if (has_edge_info && !(flags & TDF_GIMPLE))
1087                 dump_edge_probability (buffer, true_edge);
1088               pp_semicolon (buffer);
1089             }
1090           if (gimple_cond_false_label (gs))
1091             {
1092               pp_string (buffer, " else goto ");
1093               dump_generic_node (buffer, gimple_cond_false_label (gs),
1094                                  spc, flags, false);
1095               if (has_edge_info && !(flags & TDF_GIMPLE))
1096                 dump_edge_probability (buffer, false_edge);
1097
1098               pp_semicolon (buffer);
1099             }
1100         }
1101     }
1102 }
1103
1104
1105 /* Dump a GIMPLE_LABEL tuple on the pretty_printer BUFFER, SPC
1106    spaces of indent.  FLAGS specifies details to show in the dump (see
1107    TDF_* in dumpfils.h).  */
1108
1109 static void
1110 dump_gimple_label (pretty_printer *buffer, glabel *gs, int spc,
1111                    dump_flags_t flags)
1112 {
1113   tree label = gimple_label_label (gs);
1114   if (flags & TDF_RAW)
1115     dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label);
1116   else
1117     {
1118       dump_generic_node (buffer, label, spc, flags, false);
1119       pp_colon (buffer);
1120     }
1121   if (flags & TDF_GIMPLE)
1122     return;
1123   if (DECL_NONLOCAL (label))
1124     pp_string (buffer, " [non-local]");
1125   if ((flags & TDF_EH) && EH_LANDING_PAD_NR (label))
1126     pp_printf (buffer, " [LP %d]", EH_LANDING_PAD_NR (label));
1127 }
1128
1129 /* Dump a GIMPLE_GOTO tuple on the pretty_printer BUFFER, SPC
1130    spaces of indent.  FLAGS specifies details to show in the dump (see
1131    TDF_* in dumpfile.h).  */
1132
1133 static void
1134 dump_gimple_goto (pretty_printer *buffer, ggoto *gs, int spc,
1135                   dump_flags_t flags)
1136 {
1137   tree label = gimple_goto_dest (gs);
1138   if (flags & TDF_RAW)
1139     dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label);
1140   else
1141     dump_gimple_fmt (buffer, spc, flags, "goto %T;", label);
1142 }
1143
1144
1145 /* Dump a GIMPLE_BIND tuple on the pretty_printer BUFFER, SPC
1146    spaces of indent.  FLAGS specifies details to show in the dump (see
1147    TDF_* in dumpfile.h).  */
1148
1149 static void
1150 dump_gimple_bind (pretty_printer *buffer, gbind *gs, int spc,
1151                   dump_flags_t flags)
1152 {
1153   if (flags & TDF_RAW)
1154     dump_gimple_fmt (buffer, spc, flags, "%G <", gs);
1155   else
1156     pp_left_brace (buffer);
1157   if (!(flags & TDF_SLIM))
1158     {
1159       tree var;
1160
1161       for (var = gimple_bind_vars (gs); var; var = DECL_CHAIN (var))
1162         {
1163           newline_and_indent (buffer, 2);
1164           print_declaration (buffer, var, spc, flags);
1165         }
1166       if (gimple_bind_vars (gs))
1167         pp_newline (buffer);
1168     }
1169   pp_newline (buffer);
1170   dump_gimple_seq (buffer, gimple_bind_body (gs), spc + 2, flags);
1171   newline_and_indent (buffer, spc);
1172   if (flags & TDF_RAW)
1173     pp_greater (buffer);
1174   else
1175     pp_right_brace (buffer);
1176 }
1177
1178
1179 /* Dump a GIMPLE_TRY tuple on the pretty_printer BUFFER, SPC spaces of
1180    indent.  FLAGS specifies details to show in the dump (see TDF_* in
1181    dumpfile.h).  */
1182
1183 static void
1184 dump_gimple_try (pretty_printer *buffer, gtry *gs, int spc,
1185                  dump_flags_t flags)
1186 {
1187   if (flags & TDF_RAW)
1188     {
1189       const char *type;
1190       if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
1191         type = "GIMPLE_TRY_CATCH";
1192       else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
1193         type = "GIMPLE_TRY_FINALLY";
1194       else
1195         type = "UNKNOWN GIMPLE_TRY";
1196       dump_gimple_fmt (buffer, spc, flags,
1197                        "%G <%s,%+EVAL <%S>%nCLEANUP <%S>%->", gs, type,
1198                        gimple_try_eval (gs), gimple_try_cleanup (gs));
1199     }
1200   else
1201     {
1202       pp_string (buffer, "try");
1203       newline_and_indent (buffer, spc + 2);
1204       pp_left_brace (buffer);
1205       pp_newline (buffer);
1206
1207       dump_gimple_seq (buffer, gimple_try_eval (gs), spc + 4, flags);
1208       newline_and_indent (buffer, spc + 2);
1209       pp_right_brace (buffer);
1210
1211       if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
1212         {
1213           newline_and_indent (buffer, spc);
1214           pp_string (buffer, "catch");
1215           newline_and_indent (buffer, spc + 2);
1216           pp_left_brace (buffer);
1217         }
1218       else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
1219         {
1220           newline_and_indent (buffer, spc);
1221           pp_string (buffer, "finally");
1222           newline_and_indent (buffer, spc + 2);
1223           pp_left_brace (buffer);
1224         }
1225       else
1226         pp_string (buffer, " <UNKNOWN GIMPLE_TRY> {");
1227
1228       pp_newline (buffer);
1229       dump_gimple_seq (buffer, gimple_try_cleanup (gs), spc + 4, flags);
1230       newline_and_indent (buffer, spc + 2);
1231       pp_right_brace (buffer);
1232     }
1233 }
1234
1235
1236 /* Dump a GIMPLE_CATCH tuple on the pretty_printer BUFFER, SPC spaces of
1237    indent.  FLAGS specifies details to show in the dump (see TDF_* in
1238    dumpfile.h).  */
1239
1240 static void
1241 dump_gimple_catch (pretty_printer *buffer, gcatch *gs, int spc,
1242                    dump_flags_t flags)
1243 {
1244   if (flags & TDF_RAW)
1245       dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+CATCH <%S>%->", gs,
1246                        gimple_catch_types (gs), gimple_catch_handler (gs));
1247   else
1248       dump_gimple_fmt (buffer, spc, flags, "catch (%T)%+{%S}",
1249                        gimple_catch_types (gs), gimple_catch_handler (gs));
1250 }
1251
1252
1253 /* Dump a GIMPLE_EH_FILTER tuple on the pretty_printer BUFFER, SPC spaces of
1254    indent.  FLAGS specifies details to show in the dump (see TDF_* in
1255    dumpfile.h).  */
1256
1257 static void
1258 dump_gimple_eh_filter (pretty_printer *buffer, geh_filter *gs, int spc,
1259                        dump_flags_t flags)
1260 {
1261   if (flags & TDF_RAW)
1262     dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+FAILURE <%S>%->", gs,
1263                      gimple_eh_filter_types (gs),
1264                      gimple_eh_filter_failure (gs));
1265   else
1266     dump_gimple_fmt (buffer, spc, flags, "<<<eh_filter (%T)>>>%+{%+%S%-}",
1267                      gimple_eh_filter_types (gs),
1268                      gimple_eh_filter_failure (gs));
1269 }
1270
1271
1272 /* Dump a GIMPLE_EH_MUST_NOT_THROW tuple.  */
1273
1274 static void
1275 dump_gimple_eh_must_not_throw (pretty_printer *buffer,
1276                                geh_mnt *gs, int spc, dump_flags_t flags)
1277 {
1278   if (flags & TDF_RAW)
1279     dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs,
1280                      gimple_eh_must_not_throw_fndecl (gs));
1281   else
1282     dump_gimple_fmt (buffer, spc, flags, "<<<eh_must_not_throw (%T)>>>",
1283                      gimple_eh_must_not_throw_fndecl (gs));
1284 }
1285
1286
1287 /* Dump a GIMPLE_EH_ELSE tuple on the pretty_printer BUFFER, SPC spaces of
1288    indent.  FLAGS specifies details to show in the dump (see TDF_* in
1289    dumpfile.h).  */
1290
1291 static void
1292 dump_gimple_eh_else (pretty_printer *buffer, geh_else *gs, int spc,
1293                      dump_flags_t flags)
1294 {
1295   if (flags & TDF_RAW)
1296     dump_gimple_fmt (buffer, spc, flags,
1297                      "%G <%+N_BODY <%S>%nE_BODY <%S>%->", gs,
1298                      gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs));
1299   else
1300     dump_gimple_fmt (buffer, spc, flags,
1301                     "<<<if_normal_exit>>>%+{%S}%-<<<else_eh_exit>>>%+{%S}",
1302                      gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs));
1303 }
1304
1305
1306 /* Dump a GIMPLE_RESX tuple on the pretty_printer BUFFER, SPC spaces of
1307    indent.  FLAGS specifies details to show in the dump (see TDF_* in
1308    dumpfile.h).  */
1309
1310 static void
1311 dump_gimple_resx (pretty_printer *buffer, gresx *gs, int spc,
1312                   dump_flags_t flags)
1313 {
1314   if (flags & TDF_RAW)
1315     dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
1316                      gimple_resx_region (gs));
1317   else
1318     dump_gimple_fmt (buffer, spc, flags, "resx %d", gimple_resx_region (gs));
1319 }
1320
1321 /* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer BUFFER.  */
1322
1323 static void
1324 dump_gimple_eh_dispatch (pretty_printer *buffer, geh_dispatch *gs, int spc,
1325                          dump_flags_t flags)
1326 {
1327   if (flags & TDF_RAW)
1328     dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs,
1329                      gimple_eh_dispatch_region (gs));
1330   else
1331     dump_gimple_fmt (buffer, spc, flags, "eh_dispatch %d",
1332                      gimple_eh_dispatch_region (gs));
1333 }
1334
1335 /* Dump a GIMPLE_DEBUG tuple on the pretty_printer BUFFER, SPC spaces
1336    of indent.  FLAGS specifies details to show in the dump (see TDF_*
1337    in dumpfile.h).  */
1338
1339 static void
1340 dump_gimple_debug (pretty_printer *buffer, gdebug *gs, int spc,
1341                    dump_flags_t flags)
1342 {
1343   switch (gs->subcode)
1344     {
1345     case GIMPLE_DEBUG_BIND:
1346       if (flags & TDF_RAW)
1347         dump_gimple_fmt (buffer, spc, flags, "%G BIND <%T, %T>", gs,
1348                          gimple_debug_bind_get_var (gs),
1349                          gimple_debug_bind_get_value (gs));
1350       else
1351         dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T => %T",
1352                          gimple_debug_bind_get_var (gs),
1353                          gimple_debug_bind_get_value (gs));
1354       break;
1355
1356     case GIMPLE_DEBUG_SOURCE_BIND:
1357       if (flags & TDF_RAW)
1358         dump_gimple_fmt (buffer, spc, flags, "%G SRCBIND <%T, %T>", gs,
1359                          gimple_debug_source_bind_get_var (gs),
1360                          gimple_debug_source_bind_get_value (gs));
1361       else
1362         dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T s=> %T",
1363                          gimple_debug_source_bind_get_var (gs),
1364                          gimple_debug_source_bind_get_value (gs));
1365       break;
1366
1367     case GIMPLE_DEBUG_BEGIN_STMT:
1368       if (flags & TDF_RAW)
1369         dump_gimple_fmt (buffer, spc, flags, "%G BEGIN_STMT", gs);
1370       else
1371         dump_gimple_fmt (buffer, spc, flags, "# DEBUG BEGIN_STMT");
1372       break;
1373
1374     case GIMPLE_DEBUG_INLINE_ENTRY:
1375       if (flags & TDF_RAW)
1376         dump_gimple_fmt (buffer, spc, flags, "%G INLINE_ENTRY %T", gs,
1377                          gimple_block (gs)
1378                          ? block_ultimate_origin (gimple_block (gs))
1379                          : NULL_TREE);
1380       else
1381         dump_gimple_fmt (buffer, spc, flags, "# DEBUG INLINE_ENTRY %T",
1382                          gimple_block (gs)
1383                          ? block_ultimate_origin (gimple_block (gs))
1384                          : NULL_TREE);
1385       break;
1386
1387     default:
1388       gcc_unreachable ();
1389     }
1390 }
1391
1392 /* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer BUFFER.  */
1393 static void
1394 dump_gimple_omp_for (pretty_printer *buffer, gomp_for *gs, int spc,
1395                      dump_flags_t flags)
1396 {
1397   size_t i;
1398
1399   if (flags & TDF_RAW)
1400     {
1401       const char *kind;
1402       switch (gimple_omp_for_kind (gs))
1403         {
1404         case GF_OMP_FOR_KIND_FOR:
1405           kind = "";
1406           break;
1407         case GF_OMP_FOR_KIND_DISTRIBUTE:
1408           kind = " distribute";
1409           break;
1410         case GF_OMP_FOR_KIND_TASKLOOP:
1411           kind = " taskloop";
1412           break;
1413         case GF_OMP_FOR_KIND_OACC_LOOP:
1414           kind = " oacc_loop";
1415           break;
1416         case GF_OMP_FOR_KIND_SIMD:
1417           kind = " simd";
1418           break;
1419         default:
1420           gcc_unreachable ();
1421         }
1422       dump_gimple_fmt (buffer, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs,
1423                        kind, gimple_omp_body (gs));
1424       dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
1425       dump_gimple_fmt (buffer, spc, flags, " >,");
1426       for (i = 0; i < gimple_omp_for_collapse (gs); i++)
1427         dump_gimple_fmt (buffer, spc, flags,
1428                          "%+%T, %T, %T, %s, %T,%n",
1429                          gimple_omp_for_index (gs, i),
1430                          gimple_omp_for_initial (gs, i),
1431                          gimple_omp_for_final (gs, i),
1432                          get_tree_code_name (gimple_omp_for_cond (gs, i)),
1433                          gimple_omp_for_incr (gs, i));
1434       dump_gimple_fmt (buffer, spc, flags, "PRE_BODY <%S>%->",
1435                        gimple_omp_for_pre_body (gs));
1436     }
1437   else
1438     {
1439       switch (gimple_omp_for_kind (gs))
1440         {
1441         case GF_OMP_FOR_KIND_FOR:
1442           pp_string (buffer, "#pragma omp for");
1443           break;
1444         case GF_OMP_FOR_KIND_DISTRIBUTE:
1445           pp_string (buffer, "#pragma omp distribute");
1446           break;
1447         case GF_OMP_FOR_KIND_TASKLOOP:
1448           pp_string (buffer, "#pragma omp taskloop");
1449           break;
1450         case GF_OMP_FOR_KIND_OACC_LOOP:
1451           pp_string (buffer, "#pragma acc loop");
1452           break;
1453         case GF_OMP_FOR_KIND_SIMD:
1454           pp_string (buffer, "#pragma omp simd");
1455           break;
1456         case GF_OMP_FOR_KIND_GRID_LOOP:
1457           pp_string (buffer, "#pragma omp for grid_loop");
1458           break;
1459         default:
1460           gcc_unreachable ();
1461         }
1462       dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags);
1463       for (i = 0; i < gimple_omp_for_collapse (gs); i++)
1464         {
1465           if (i)
1466             spc += 2;
1467           newline_and_indent (buffer, spc);
1468           pp_string (buffer, "for (");
1469           dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1470                              flags, false);
1471           pp_string (buffer, " = ");
1472           dump_generic_node (buffer, gimple_omp_for_initial (gs, i), spc,
1473                              flags, false);
1474           pp_string (buffer, "; ");
1475
1476           dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1477                              flags, false);
1478           pp_space (buffer);
1479           switch (gimple_omp_for_cond (gs, i))
1480             {
1481             case LT_EXPR:
1482               pp_less (buffer);
1483               break;
1484             case GT_EXPR:
1485               pp_greater (buffer);
1486               break;
1487             case LE_EXPR:
1488               pp_less_equal (buffer);
1489               break;
1490             case GE_EXPR:
1491               pp_greater_equal (buffer);
1492               break;
1493             case NE_EXPR:
1494               pp_string (buffer, "!=");
1495               break;
1496             default:
1497               gcc_unreachable ();
1498             }
1499           pp_space (buffer);
1500           dump_generic_node (buffer, gimple_omp_for_final (gs, i), spc,
1501                              flags, false);
1502           pp_string (buffer, "; ");
1503
1504           dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc,
1505                              flags, false);
1506           pp_string (buffer, " = ");
1507           dump_generic_node (buffer, gimple_omp_for_incr (gs, i), spc,
1508                              flags, false);
1509           pp_right_paren (buffer);
1510         }
1511
1512       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1513         {
1514           newline_and_indent (buffer, spc + 2);
1515           pp_left_brace (buffer);
1516           pp_newline (buffer);
1517           dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1518           newline_and_indent (buffer, spc + 2);
1519           pp_right_brace (buffer);
1520         }
1521     }
1522 }
1523
1524 /* Dump a GIMPLE_OMP_CONTINUE tuple on the pretty_printer BUFFER.  */
1525
1526 static void
1527 dump_gimple_omp_continue (pretty_printer *buffer, gomp_continue *gs,
1528                           int spc, dump_flags_t flags)
1529 {
1530   if (flags & TDF_RAW)
1531     {
1532       dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs,
1533                        gimple_omp_continue_control_def (gs),
1534                        gimple_omp_continue_control_use (gs));
1535     }
1536   else
1537     {
1538       pp_string (buffer, "#pragma omp continue (");
1539       dump_generic_node (buffer, gimple_omp_continue_control_def (gs),
1540                          spc, flags, false);
1541       pp_comma (buffer);
1542       pp_space (buffer);
1543       dump_generic_node (buffer, gimple_omp_continue_control_use (gs),
1544                          spc, flags, false);
1545       pp_right_paren (buffer);
1546     }
1547 }
1548
1549 /* Dump a GIMPLE_OMP_SINGLE tuple on the pretty_printer BUFFER.  */
1550
1551 static void
1552 dump_gimple_omp_single (pretty_printer *buffer, gomp_single *gs,
1553                         int spc, dump_flags_t flags)
1554 {
1555   if (flags & TDF_RAW)
1556     {
1557       dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1558                        gimple_omp_body (gs));
1559       dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags);
1560       dump_gimple_fmt (buffer, spc, flags, " >");
1561     }
1562   else
1563     {
1564       pp_string (buffer, "#pragma omp single");
1565       dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags);
1566       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1567         {
1568           newline_and_indent (buffer, spc + 2);
1569           pp_left_brace (buffer);
1570           pp_newline (buffer);
1571           dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1572           newline_and_indent (buffer, spc + 2);
1573           pp_right_brace (buffer);
1574         }
1575     }
1576 }
1577
1578 /* Dump a GIMPLE_OMP_TARGET tuple on the pretty_printer BUFFER.  */
1579
1580 static void
1581 dump_gimple_omp_target (pretty_printer *buffer, gomp_target *gs,
1582                         int spc, dump_flags_t flags)
1583 {
1584   const char *kind;
1585   switch (gimple_omp_target_kind (gs))
1586     {
1587     case GF_OMP_TARGET_KIND_REGION:
1588       kind = "";
1589       break;
1590     case GF_OMP_TARGET_KIND_DATA:
1591       kind = " data";
1592       break;
1593     case GF_OMP_TARGET_KIND_UPDATE:
1594       kind = " update";
1595       break;
1596     case GF_OMP_TARGET_KIND_ENTER_DATA:
1597       kind = " enter data";
1598       break;
1599     case GF_OMP_TARGET_KIND_EXIT_DATA:
1600       kind = " exit data";
1601       break;
1602     case GF_OMP_TARGET_KIND_OACC_KERNELS:
1603       kind = " oacc_kernels";
1604       break;
1605     case GF_OMP_TARGET_KIND_OACC_PARALLEL:
1606       kind = " oacc_parallel";
1607       break;
1608     case GF_OMP_TARGET_KIND_OACC_DATA:
1609       kind = " oacc_data";
1610       break;
1611     case GF_OMP_TARGET_KIND_OACC_UPDATE:
1612       kind = " oacc_update";
1613       break;
1614     case GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA:
1615       kind = " oacc_enter_exit_data";
1616       break;
1617     case GF_OMP_TARGET_KIND_OACC_DECLARE:
1618       kind = " oacc_declare";
1619       break;
1620     case GF_OMP_TARGET_KIND_OACC_HOST_DATA:
1621       kind = " oacc_host_data";
1622       break;
1623     default:
1624       gcc_unreachable ();
1625     }
1626   if (flags & TDF_RAW)
1627     {
1628       dump_gimple_fmt (buffer, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs,
1629                        kind, gimple_omp_body (gs));
1630       dump_omp_clauses (buffer, gimple_omp_target_clauses (gs), spc, flags);
1631       dump_gimple_fmt (buffer, spc, flags, " >, %T, %T%n>",
1632                        gimple_omp_target_child_fn (gs),
1633                        gimple_omp_target_data_arg (gs));
1634     }
1635   else
1636     {
1637       pp_string (buffer, "#pragma omp target");
1638       pp_string (buffer, kind);
1639       dump_omp_clauses (buffer, gimple_omp_target_clauses (gs), spc, flags);
1640       if (gimple_omp_target_child_fn (gs))
1641         {
1642           pp_string (buffer, " [child fn: ");
1643           dump_generic_node (buffer, gimple_omp_target_child_fn (gs),
1644                              spc, flags, false);
1645           pp_string (buffer, " (");
1646           if (gimple_omp_target_data_arg (gs))
1647             dump_generic_node (buffer, gimple_omp_target_data_arg (gs),
1648                                spc, flags, false);
1649           else
1650             pp_string (buffer, "???");
1651           pp_string (buffer, ")]");
1652         }
1653       gimple_seq body = gimple_omp_body (gs);
1654       if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
1655         {
1656           newline_and_indent (buffer, spc + 2);
1657           pp_left_brace (buffer);
1658           pp_newline (buffer);
1659           dump_gimple_seq (buffer, body, spc + 4, flags);
1660           newline_and_indent (buffer, spc + 2);
1661           pp_right_brace (buffer);
1662         }
1663       else if (body)
1664         {
1665           pp_newline (buffer);
1666           dump_gimple_seq (buffer, body, spc + 2, flags);
1667         }
1668     }
1669 }
1670
1671 /* Dump a GIMPLE_OMP_TEAMS tuple on the pretty_printer BUFFER.  */
1672
1673 static void
1674 dump_gimple_omp_teams (pretty_printer *buffer, gomp_teams *gs, int spc,
1675                        dump_flags_t flags)
1676 {
1677   if (flags & TDF_RAW)
1678     {
1679       dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1680                        gimple_omp_body (gs));
1681       dump_omp_clauses (buffer, gimple_omp_teams_clauses (gs), spc, flags);
1682       dump_gimple_fmt (buffer, spc, flags, " >");
1683     }
1684   else
1685     {
1686       pp_string (buffer, "#pragma omp teams");
1687       dump_omp_clauses (buffer, gimple_omp_teams_clauses (gs), spc, flags);
1688       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1689         {
1690           newline_and_indent (buffer, spc + 2);
1691           pp_character (buffer, '{');
1692           pp_newline (buffer);
1693           dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1694           newline_and_indent (buffer, spc + 2);
1695           pp_character (buffer, '}');
1696         }
1697     }
1698 }
1699
1700 /* Dump a GIMPLE_OMP_SECTIONS tuple on the pretty_printer BUFFER.  */
1701
1702 static void
1703 dump_gimple_omp_sections (pretty_printer *buffer, gomp_sections *gs,
1704                           int spc, dump_flags_t flags)
1705 {
1706   if (flags & TDF_RAW)
1707     {
1708       dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
1709                        gimple_omp_body (gs));
1710       dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags);
1711       dump_gimple_fmt (buffer, spc, flags, " >");
1712     }
1713   else
1714     {
1715       pp_string (buffer, "#pragma omp sections");
1716       if (gimple_omp_sections_control (gs))
1717         {
1718           pp_string (buffer, " <");
1719           dump_generic_node (buffer, gimple_omp_sections_control (gs), spc,
1720                              flags, false);
1721           pp_greater (buffer);
1722         }
1723       dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags);
1724       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1725         {
1726           newline_and_indent (buffer, spc + 2);
1727           pp_left_brace (buffer);
1728           pp_newline (buffer);
1729           dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1730           newline_and_indent (buffer, spc + 2);
1731           pp_right_brace (buffer);
1732         }
1733     }
1734 }
1735
1736 /* Dump a GIMPLE_OMP_{MASTER,TASKGROUP,ORDERED,SECTION} tuple on the
1737    pretty_printer BUFFER.  */
1738
1739 static void
1740 dump_gimple_omp_block (pretty_printer *buffer, gimple *gs, int spc,
1741                        dump_flags_t flags)
1742 {
1743   if (flags & TDF_RAW)
1744     dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
1745                      gimple_omp_body (gs));
1746   else
1747     {
1748       switch (gimple_code (gs))
1749         {
1750         case GIMPLE_OMP_MASTER:
1751           pp_string (buffer, "#pragma omp master");
1752           break;
1753         case GIMPLE_OMP_TASKGROUP:
1754           pp_string (buffer, "#pragma omp taskgroup");
1755           break;
1756         case GIMPLE_OMP_SECTION:
1757           pp_string (buffer, "#pragma omp section");
1758           break;
1759         case GIMPLE_OMP_GRID_BODY:
1760           pp_string (buffer, "#pragma omp gridified body");
1761           break;
1762         default:
1763           gcc_unreachable ();
1764         }
1765       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1766         {
1767           newline_and_indent (buffer, spc + 2);
1768           pp_left_brace (buffer);
1769           pp_newline (buffer);
1770           dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1771           newline_and_indent (buffer, spc + 2);
1772           pp_right_brace (buffer);
1773         }
1774     }
1775 }
1776
1777 /* Dump a GIMPLE_OMP_CRITICAL tuple on the pretty_printer BUFFER.  */
1778
1779 static void
1780 dump_gimple_omp_critical (pretty_printer *buffer, gomp_critical *gs,
1781                           int spc, dump_flags_t flags)
1782 {
1783   if (flags & TDF_RAW)
1784     dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
1785                      gimple_omp_body (gs));
1786   else
1787     {
1788       pp_string (buffer, "#pragma omp critical");
1789       if (gimple_omp_critical_name (gs))
1790         {
1791           pp_string (buffer, " (");
1792           dump_generic_node (buffer, gimple_omp_critical_name (gs), spc,
1793                              flags, false);
1794           pp_right_paren (buffer);
1795         }
1796       dump_omp_clauses (buffer, gimple_omp_critical_clauses (gs), spc, flags);
1797       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1798         {
1799           newline_and_indent (buffer, spc + 2);
1800           pp_left_brace (buffer);
1801           pp_newline (buffer);
1802           dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1803           newline_and_indent (buffer, spc + 2);
1804           pp_right_brace (buffer);
1805         }
1806     }
1807 }
1808
1809 /* Dump a GIMPLE_OMP_ORDERED tuple on the pretty_printer BUFFER.  */
1810
1811 static void
1812 dump_gimple_omp_ordered (pretty_printer *buffer, gomp_ordered *gs,
1813                          int spc, dump_flags_t flags)
1814 {
1815   if (flags & TDF_RAW)
1816     dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs,
1817                      gimple_omp_body (gs));
1818   else
1819     {
1820       pp_string (buffer, "#pragma omp ordered");
1821       dump_omp_clauses (buffer, gimple_omp_ordered_clauses (gs), spc, flags);
1822       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
1823         {
1824           newline_and_indent (buffer, spc + 2);
1825           pp_left_brace (buffer);
1826           pp_newline (buffer);
1827           dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
1828           newline_and_indent (buffer, spc + 2);
1829           pp_right_brace (buffer);
1830         }
1831     }
1832 }
1833
1834 /* Dump a GIMPLE_OMP_RETURN tuple on the pretty_printer BUFFER.  */
1835
1836 static void
1837 dump_gimple_omp_return (pretty_printer *buffer, gimple *gs, int spc,
1838                         dump_flags_t flags)
1839 {
1840   if (flags & TDF_RAW)
1841     {
1842       dump_gimple_fmt (buffer, spc, flags, "%G <nowait=%d", gs,
1843                        (int) gimple_omp_return_nowait_p (gs));
1844       if (gimple_omp_return_lhs (gs))
1845         dump_gimple_fmt (buffer, spc, flags, ", lhs=%T>",
1846                          gimple_omp_return_lhs (gs));
1847       else
1848         dump_gimple_fmt (buffer, spc, flags, ">");
1849     }
1850   else
1851     {
1852       pp_string (buffer, "#pragma omp return");
1853       if (gimple_omp_return_nowait_p (gs))
1854         pp_string (buffer, "(nowait)");
1855       if (gimple_omp_return_lhs (gs))
1856         {
1857           pp_string (buffer, " (set ");
1858           dump_generic_node (buffer, gimple_omp_return_lhs (gs),
1859                              spc, flags, false);
1860           pp_character (buffer, ')');
1861         }
1862     }
1863 }
1864
1865 /* Dump a GIMPLE_TRANSACTION tuple on the pretty_printer BUFFER.  */
1866
1867 static void
1868 dump_gimple_transaction (pretty_printer *buffer, gtransaction *gs,
1869                          int spc, dump_flags_t flags)
1870 {
1871   unsigned subcode = gimple_transaction_subcode (gs);
1872
1873   if (flags & TDF_RAW)
1874     {
1875       dump_gimple_fmt (buffer, spc, flags,
1876                        "%G [SUBCODE=%x,NORM=%T,UNINST=%T,OVER=%T] "
1877                        "<%+BODY <%S> >",
1878                        gs, subcode, gimple_transaction_label_norm (gs),
1879                        gimple_transaction_label_uninst (gs),
1880                        gimple_transaction_label_over (gs),
1881                        gimple_transaction_body (gs));
1882     }
1883   else
1884     {
1885       if (subcode & GTMA_IS_OUTER)
1886         pp_string (buffer, "__transaction_atomic [[outer]]");
1887       else if (subcode & GTMA_IS_RELAXED)
1888         pp_string (buffer, "__transaction_relaxed");
1889       else
1890         pp_string (buffer, "__transaction_atomic");
1891       subcode &= ~GTMA_DECLARATION_MASK;
1892
1893       if (gimple_transaction_body (gs))
1894         {
1895           newline_and_indent (buffer, spc + 2);
1896           pp_left_brace (buffer);
1897           pp_newline (buffer);
1898           dump_gimple_seq (buffer, gimple_transaction_body (gs),
1899                            spc + 4, flags);
1900           newline_and_indent (buffer, spc + 2);
1901           pp_right_brace (buffer);
1902         }
1903       else
1904         {
1905           pp_string (buffer, "  //");
1906           if (gimple_transaction_label_norm (gs))
1907             {
1908               pp_string (buffer, " NORM=");
1909               dump_generic_node (buffer, gimple_transaction_label_norm (gs),
1910                                  spc, flags, false);
1911             }
1912           if (gimple_transaction_label_uninst (gs))
1913             {
1914               pp_string (buffer, " UNINST=");
1915               dump_generic_node (buffer, gimple_transaction_label_uninst (gs),
1916                                  spc, flags, false);
1917             }
1918           if (gimple_transaction_label_over (gs))
1919             {
1920               pp_string (buffer, " OVER=");
1921               dump_generic_node (buffer, gimple_transaction_label_over (gs),
1922                                  spc, flags, false);
1923             }
1924           if (subcode)
1925             {
1926               pp_string (buffer, " SUBCODE=[ ");
1927               if (subcode & GTMA_HAVE_ABORT)
1928                 {
1929                   pp_string (buffer, "GTMA_HAVE_ABORT ");
1930                   subcode &= ~GTMA_HAVE_ABORT;
1931                 }
1932               if (subcode & GTMA_HAVE_LOAD)
1933                 {
1934                   pp_string (buffer, "GTMA_HAVE_LOAD ");
1935                   subcode &= ~GTMA_HAVE_LOAD;
1936                 }
1937               if (subcode & GTMA_HAVE_STORE)
1938                 {
1939                   pp_string (buffer, "GTMA_HAVE_STORE ");
1940                   subcode &= ~GTMA_HAVE_STORE;
1941                 }
1942               if (subcode & GTMA_MAY_ENTER_IRREVOCABLE)
1943                 {
1944                   pp_string (buffer, "GTMA_MAY_ENTER_IRREVOCABLE ");
1945                   subcode &= ~GTMA_MAY_ENTER_IRREVOCABLE;
1946                 }
1947               if (subcode & GTMA_DOES_GO_IRREVOCABLE)
1948                 {
1949                   pp_string (buffer, "GTMA_DOES_GO_IRREVOCABLE ");
1950                   subcode &= ~GTMA_DOES_GO_IRREVOCABLE;
1951                 }
1952               if (subcode & GTMA_HAS_NO_INSTRUMENTATION)
1953                 {
1954                   pp_string (buffer, "GTMA_HAS_NO_INSTRUMENTATION ");
1955                   subcode &= ~GTMA_HAS_NO_INSTRUMENTATION;
1956                 }
1957               if (subcode)
1958                 pp_printf (buffer, "0x%x ", subcode);
1959               pp_right_bracket (buffer);
1960             }
1961         }
1962     }
1963 }
1964
1965 /* Dump a GIMPLE_ASM tuple on the pretty_printer BUFFER, SPC spaces of
1966    indent.  FLAGS specifies details to show in the dump (see TDF_* in
1967    dumpfile.h).  */
1968
1969 static void
1970 dump_gimple_asm (pretty_printer *buffer, gasm *gs, int spc, dump_flags_t flags)
1971 {
1972   unsigned int i, n, f, fields;
1973
1974   if (flags & TDF_RAW)
1975     {
1976       dump_gimple_fmt (buffer, spc, flags, "%G <%+STRING <%n%s%n>", gs,
1977                        gimple_asm_string (gs));
1978
1979       n = gimple_asm_noutputs (gs);
1980       if (n)
1981         {
1982           newline_and_indent (buffer, spc + 2);
1983           pp_string (buffer, "OUTPUT: ");
1984           for (i = 0; i < n; i++)
1985             {
1986               dump_generic_node (buffer, gimple_asm_output_op (gs, i),
1987                                  spc, flags, false);
1988               if (i < n - 1)
1989                 pp_string (buffer, ", ");
1990             }
1991         }
1992
1993       n = gimple_asm_ninputs (gs);
1994       if (n)
1995         {
1996           newline_and_indent (buffer, spc + 2);
1997           pp_string (buffer, "INPUT: ");
1998           for (i = 0; i < n; i++)
1999             {
2000               dump_generic_node (buffer, gimple_asm_input_op (gs, i),
2001                                  spc, flags, false);
2002               if (i < n - 1)
2003                 pp_string (buffer, ", ");
2004             }
2005         }
2006
2007       n = gimple_asm_nclobbers (gs);
2008       if (n)
2009         {
2010           newline_and_indent (buffer, spc + 2);
2011           pp_string (buffer, "CLOBBER: ");
2012           for (i = 0; i < n; i++)
2013             {
2014               dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
2015                                  spc, flags, false);
2016               if (i < n - 1)
2017                 pp_string (buffer, ", ");
2018             }
2019         }
2020
2021       n = gimple_asm_nlabels (gs);
2022       if (n)
2023         {
2024           newline_and_indent (buffer, spc + 2);
2025           pp_string (buffer, "LABEL: ");
2026           for (i = 0; i < n; i++)
2027             {
2028               dump_generic_node (buffer, gimple_asm_label_op (gs, i),
2029                                  spc, flags, false);
2030               if (i < n - 1)
2031                 pp_string (buffer, ", ");
2032             }
2033         }
2034
2035       newline_and_indent (buffer, spc);
2036       pp_greater (buffer);
2037     }
2038   else
2039     {
2040       pp_string (buffer, "__asm__");
2041       if (gimple_asm_volatile_p (gs))
2042         pp_string (buffer, " __volatile__");
2043       if (gimple_asm_nlabels (gs))
2044         pp_string (buffer, " goto");
2045       pp_string (buffer, "(\"");
2046       pp_string (buffer, gimple_asm_string (gs));
2047       pp_string (buffer, "\"");
2048
2049       if (gimple_asm_nlabels (gs))
2050         fields = 4;
2051       else if (gimple_asm_nclobbers (gs))
2052         fields = 3;
2053       else if (gimple_asm_ninputs (gs))
2054         fields = 2;
2055       else if (gimple_asm_noutputs (gs))
2056         fields = 1;
2057       else
2058         fields = 0;
2059
2060       for (f = 0; f < fields; ++f)
2061         {
2062           pp_string (buffer, " : ");
2063
2064           switch (f)
2065             {
2066             case 0:
2067               n = gimple_asm_noutputs (gs);
2068               for (i = 0; i < n; i++)
2069                 {
2070                   dump_generic_node (buffer, gimple_asm_output_op (gs, i),
2071                                      spc, flags, false);
2072                   if (i < n - 1)
2073                     pp_string (buffer, ", ");
2074                 }
2075               break;
2076
2077             case 1:
2078               n = gimple_asm_ninputs (gs);
2079               for (i = 0; i < n; i++)
2080                 {
2081                   dump_generic_node (buffer, gimple_asm_input_op (gs, i),
2082                                      spc, flags, false);
2083                   if (i < n - 1)
2084                     pp_string (buffer, ", ");
2085                 }
2086               break;
2087
2088             case 2:
2089               n = gimple_asm_nclobbers (gs);
2090               for (i = 0; i < n; i++)
2091                 {
2092                   dump_generic_node (buffer, gimple_asm_clobber_op (gs, i),
2093                                      spc, flags, false);
2094                   if (i < n - 1)
2095                     pp_string (buffer, ", ");
2096                 }
2097               break;
2098
2099             case 3:
2100               n = gimple_asm_nlabels (gs);
2101               for (i = 0; i < n; i++)
2102                 {
2103                   dump_generic_node (buffer, gimple_asm_label_op (gs, i),
2104                                      spc, flags, false);
2105                   if (i < n - 1)
2106                     pp_string (buffer, ", ");
2107                 }
2108               break;
2109
2110             default:
2111               gcc_unreachable ();
2112             }
2113         }
2114
2115       pp_string (buffer, ");");
2116     }
2117 }
2118
2119 /* Dump ptr_info and range_info for NODE on pretty_printer BUFFER with
2120    SPC spaces of indent.  */
2121
2122 static void
2123 dump_ssaname_info (pretty_printer *buffer, tree node, int spc)
2124 {
2125   if (TREE_CODE (node) != SSA_NAME)
2126     return;
2127
2128   if (POINTER_TYPE_P (TREE_TYPE (node))
2129       && SSA_NAME_PTR_INFO (node))
2130     {
2131       unsigned int align, misalign;
2132       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (node);
2133       pp_string (buffer, "# PT = ");
2134       pp_points_to_solution (buffer, &pi->pt);
2135       newline_and_indent (buffer, spc);
2136       if (get_ptr_info_alignment (pi, &align, &misalign))
2137         {
2138           pp_printf (buffer, "# ALIGN = %u, MISALIGN = %u", align, misalign);
2139           newline_and_indent (buffer, spc);
2140         }
2141     }
2142
2143   if (!POINTER_TYPE_P (TREE_TYPE (node))
2144       && SSA_NAME_RANGE_INFO (node))
2145     {
2146       wide_int min, max, nonzero_bits;
2147       value_range_type range_type = get_range_info (node, &min, &max);
2148
2149       if (range_type == VR_VARYING)
2150         pp_printf (buffer, "# RANGE VR_VARYING");
2151       else if (range_type == VR_RANGE || range_type == VR_ANTI_RANGE)
2152         {
2153           pp_printf (buffer, "# RANGE ");
2154           pp_printf (buffer, "%s[", range_type == VR_RANGE ? "" : "~");
2155           pp_wide_int (buffer, min, TYPE_SIGN (TREE_TYPE (node)));
2156           pp_printf (buffer, ", ");
2157           pp_wide_int (buffer, max, TYPE_SIGN (TREE_TYPE (node)));
2158           pp_printf (buffer, "]");
2159         }
2160       nonzero_bits = get_nonzero_bits (node);
2161       if (nonzero_bits != -1)
2162         {
2163           pp_string (buffer, " NONZERO ");
2164           pp_wide_int (buffer, nonzero_bits, UNSIGNED);
2165         }
2166       newline_and_indent (buffer, spc);
2167     }
2168 }
2169
2170 /* As dump_ssaname_info, but dump to FILE.  */
2171
2172 void
2173 dump_ssaname_info_to_file (FILE *file, tree node, int spc)
2174 {
2175   pretty_printer buffer;
2176   pp_needs_newline (&buffer) = true;
2177   buffer.buffer->stream = file;
2178   dump_ssaname_info (&buffer, node, spc);
2179   pp_flush (&buffer);
2180 }
2181
2182 /* Dump a PHI node PHI.  BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1.
2183    The caller is responsible for calling pp_flush on BUFFER to finalize
2184    pretty printer.  If COMMENT is true, print this after #.  */
2185
2186 static void
2187 dump_gimple_phi (pretty_printer *buffer, gphi *phi, int spc, bool comment,
2188                  dump_flags_t flags)
2189 {
2190   size_t i;
2191   tree lhs = gimple_phi_result (phi);
2192
2193   if (flags & TDF_ALIAS)
2194     dump_ssaname_info (buffer, lhs, spc);
2195
2196   if (comment)
2197     pp_string (buffer, "# ");
2198
2199   if (flags & TDF_RAW)
2200     dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", phi,
2201                      gimple_phi_result (phi));
2202   else
2203     {
2204       dump_generic_node (buffer, lhs, spc, flags, false);
2205       if (flags & TDF_GIMPLE)
2206         pp_string (buffer, " = __PHI (");
2207       else
2208         pp_string (buffer, " = PHI <");
2209     }
2210   for (i = 0; i < gimple_phi_num_args (phi); i++)
2211     {
2212       if ((flags & TDF_LINENO) && gimple_phi_arg_has_location (phi, i))
2213         dump_location (buffer, gimple_phi_arg_location (phi, i));
2214       if (flags & TDF_GIMPLE)
2215         {
2216           basic_block src = gimple_phi_arg_edge (phi, i)->src;
2217           gimple *stmt = first_stmt (src);
2218           if (!stmt || gimple_code (stmt) != GIMPLE_LABEL)
2219             {
2220               pp_string (buffer, "bb_");
2221               pp_decimal_int (buffer, src->index);
2222             }
2223           else
2224             dump_generic_node (buffer, gimple_label_label (as_a <glabel *> (stmt)), 0, flags,
2225                                false);
2226           pp_string (buffer, ": ");
2227         }
2228       dump_generic_node (buffer, gimple_phi_arg_def (phi, i), spc, flags,
2229                          false);
2230       if (! (flags & TDF_GIMPLE))
2231         {
2232           pp_left_paren (buffer);
2233           pp_decimal_int (buffer, gimple_phi_arg_edge (phi, i)->src->index);
2234           pp_right_paren (buffer);
2235         }
2236       if (i < gimple_phi_num_args (phi) - 1)
2237         pp_string (buffer, ", ");
2238     }
2239   if (flags & TDF_GIMPLE)
2240     pp_string (buffer, ");");
2241   else
2242     pp_greater (buffer);
2243 }
2244
2245
2246 /* Dump a GIMPLE_OMP_PARALLEL tuple on the pretty_printer BUFFER, SPC spaces
2247    of indent.  FLAGS specifies details to show in the dump (see TDF_* in
2248    dumpfile.h).  */
2249
2250 static void
2251 dump_gimple_omp_parallel (pretty_printer *buffer, gomp_parallel *gs,
2252                           int spc, dump_flags_t flags)
2253 {
2254   if (flags & TDF_RAW)
2255     {
2256       dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
2257                        gimple_omp_body (gs));
2258       dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags);
2259       dump_gimple_fmt (buffer, spc, flags, " >, %T, %T%n>",
2260                        gimple_omp_parallel_child_fn (gs),
2261                        gimple_omp_parallel_data_arg (gs));
2262     }
2263   else
2264     {
2265       gimple_seq body;
2266       pp_string (buffer, "#pragma omp parallel");
2267       dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags);
2268       if (gimple_omp_parallel_child_fn (gs))
2269         {
2270           pp_string (buffer, " [child fn: ");
2271           dump_generic_node (buffer, gimple_omp_parallel_child_fn (gs),
2272                              spc, flags, false);
2273           pp_string (buffer, " (");
2274           if (gimple_omp_parallel_data_arg (gs))
2275             dump_generic_node (buffer, gimple_omp_parallel_data_arg (gs),
2276                                spc, flags, false);
2277           else
2278             pp_string (buffer, "???");
2279           pp_string (buffer, ")]");
2280         }
2281       body = gimple_omp_body (gs);
2282       if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
2283         {
2284           newline_and_indent (buffer, spc + 2);
2285           pp_left_brace (buffer);
2286           pp_newline (buffer);
2287           dump_gimple_seq (buffer, body, spc + 4, flags);
2288           newline_and_indent (buffer, spc + 2);
2289           pp_right_brace (buffer);
2290         }
2291       else if (body)
2292         {
2293           pp_newline (buffer);
2294           dump_gimple_seq (buffer, body, spc + 2, flags);
2295         }
2296     }
2297 }
2298
2299
2300 /* Dump a GIMPLE_OMP_TASK tuple on the pretty_printer BUFFER, SPC spaces
2301    of indent.  FLAGS specifies details to show in the dump (see TDF_* in
2302    dumpfile.h).  */
2303
2304 static void
2305 dump_gimple_omp_task (pretty_printer *buffer, gomp_task *gs, int spc,
2306                       dump_flags_t flags)
2307 {
2308   if (flags & TDF_RAW)
2309     {
2310       dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs,
2311                        gimple_omp_body (gs));
2312       dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags);
2313       dump_gimple_fmt (buffer, spc, flags, " >, %T, %T, %T, %T, %T%n>",
2314                        gimple_omp_task_child_fn (gs),
2315                        gimple_omp_task_data_arg (gs),
2316                        gimple_omp_task_copy_fn (gs),
2317                        gimple_omp_task_arg_size (gs),
2318                        gimple_omp_task_arg_size (gs));
2319     }
2320   else
2321     {
2322       gimple_seq body;
2323       if (gimple_omp_task_taskloop_p (gs))
2324         pp_string (buffer, "#pragma omp taskloop");
2325       else
2326         pp_string (buffer, "#pragma omp task");
2327       dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags);
2328       if (gimple_omp_task_child_fn (gs))
2329         {
2330           pp_string (buffer, " [child fn: ");
2331           dump_generic_node (buffer, gimple_omp_task_child_fn (gs),
2332                              spc, flags, false);
2333           pp_string (buffer, " (");
2334           if (gimple_omp_task_data_arg (gs))
2335             dump_generic_node (buffer, gimple_omp_task_data_arg (gs),
2336                                spc, flags, false);
2337           else
2338             pp_string (buffer, "???");
2339           pp_string (buffer, ")]");
2340         }
2341       body = gimple_omp_body (gs);
2342       if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
2343         {
2344           newline_and_indent (buffer, spc + 2);
2345           pp_left_brace (buffer);
2346           pp_newline (buffer);
2347           dump_gimple_seq (buffer, body, spc + 4, flags);
2348           newline_and_indent (buffer, spc + 2);
2349           pp_right_brace (buffer);
2350         }
2351       else if (body)
2352         {
2353           pp_newline (buffer);
2354           dump_gimple_seq (buffer, body, spc + 2, flags);
2355         }
2356     }
2357 }
2358
2359
2360 /* Dump a GIMPLE_OMP_ATOMIC_LOAD tuple on the pretty_printer BUFFER, SPC
2361    spaces of indent.  FLAGS specifies details to show in the dump (see TDF_*
2362    in dumpfile.h).  */
2363
2364 static void
2365 dump_gimple_omp_atomic_load (pretty_printer *buffer, gomp_atomic_load *gs,
2366                              int spc, dump_flags_t flags)
2367 {
2368   if (flags & TDF_RAW)
2369     {
2370       dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs,
2371                        gimple_omp_atomic_load_lhs (gs),
2372                        gimple_omp_atomic_load_rhs (gs));
2373     }
2374   else
2375     {
2376       pp_string (buffer, "#pragma omp atomic_load");
2377       if (gimple_omp_atomic_seq_cst_p (gs))
2378         pp_string (buffer, " seq_cst");
2379       if (gimple_omp_atomic_need_value_p (gs))
2380         pp_string (buffer, " [needed]");
2381       newline_and_indent (buffer, spc + 2);
2382       dump_generic_node (buffer, gimple_omp_atomic_load_lhs (gs),
2383                          spc, flags, false);
2384       pp_space (buffer);
2385       pp_equal (buffer);
2386       pp_space (buffer);
2387       pp_star (buffer);
2388       dump_generic_node (buffer, gimple_omp_atomic_load_rhs (gs),
2389                          spc, flags, false);
2390     }
2391 }
2392
2393 /* Dump a GIMPLE_OMP_ATOMIC_STORE tuple on the pretty_printer BUFFER, SPC
2394    spaces of indent.  FLAGS specifies details to show in the dump (see TDF_*
2395    in dumpfile.h).  */
2396
2397 static void
2398 dump_gimple_omp_atomic_store (pretty_printer *buffer,
2399                               gomp_atomic_store *gs, int spc,
2400                               dump_flags_t flags)
2401 {
2402   if (flags & TDF_RAW)
2403     {
2404       dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs,
2405                        gimple_omp_atomic_store_val (gs));
2406     }
2407   else
2408     {
2409       pp_string (buffer, "#pragma omp atomic_store ");
2410       if (gimple_omp_atomic_seq_cst_p (gs))
2411         pp_string (buffer, "seq_cst ");
2412       if (gimple_omp_atomic_need_value_p (gs))
2413         pp_string (buffer, "[needed] ");
2414       pp_left_paren (buffer);
2415       dump_generic_node (buffer, gimple_omp_atomic_store_val (gs),
2416                          spc, flags, false);
2417       pp_right_paren (buffer);
2418     }
2419 }
2420
2421
2422 /* Dump all the memory operands for statement GS.  BUFFER, SPC and
2423    FLAGS are as in pp_gimple_stmt_1.  */
2424
2425 static void
2426 dump_gimple_mem_ops (pretty_printer *buffer, gimple *gs, int spc,
2427                      dump_flags_t flags)
2428 {
2429   tree vdef = gimple_vdef (gs);
2430   tree vuse = gimple_vuse (gs);
2431
2432   if (vdef != NULL_TREE)
2433     {
2434       pp_string (buffer, "# ");
2435       dump_generic_node (buffer, vdef, spc + 2, flags, false);
2436       pp_string (buffer, " = VDEF <");
2437       dump_generic_node (buffer, vuse, spc + 2, flags, false);
2438       pp_greater (buffer);
2439       newline_and_indent (buffer, spc);
2440     }
2441   else if (vuse != NULL_TREE)
2442     {
2443       pp_string (buffer, "# VUSE <");
2444       dump_generic_node (buffer, vuse, spc + 2, flags, false);
2445       pp_greater (buffer);
2446       newline_and_indent (buffer, spc);
2447     }
2448 }
2449
2450
2451 /* Print the gimple statement GS on the pretty printer BUFFER, SPC
2452    spaces of indent.  FLAGS specifies details to show in the dump (see
2453    TDF_* in dumpfile.h).  The caller is responsible for calling
2454    pp_flush on BUFFER to finalize the pretty printer.  */
2455
2456 void
2457 pp_gimple_stmt_1 (pretty_printer *buffer, gimple *gs, int spc,
2458                   dump_flags_t flags)
2459 {
2460   if (!gs)
2461     return;
2462
2463   if (flags & TDF_STMTADDR)
2464     pp_printf (buffer, "<&%p> ", (void *) gs);
2465
2466   if ((flags & TDF_LINENO) && gimple_has_location (gs))
2467     dump_location (buffer, gimple_location (gs));
2468
2469   if (flags & TDF_EH)
2470     {
2471       int lp_nr = lookup_stmt_eh_lp (gs);
2472       if (lp_nr > 0)
2473         pp_printf (buffer, "[LP %d] ", lp_nr);
2474       else if (lp_nr < 0)
2475         pp_printf (buffer, "[MNT %d] ", -lp_nr);
2476     }
2477
2478   if ((flags & (TDF_VOPS|TDF_MEMSYMS))
2479       && gimple_has_mem_ops (gs))
2480     dump_gimple_mem_ops (buffer, gs, spc, flags);
2481
2482   if (gimple_has_lhs (gs)
2483       && (flags & TDF_ALIAS))
2484     dump_ssaname_info (buffer, gimple_get_lhs (gs), spc);
2485
2486   switch (gimple_code (gs))
2487     {
2488     case GIMPLE_ASM:
2489       dump_gimple_asm (buffer, as_a <gasm *> (gs), spc, flags);
2490       break;
2491
2492     case GIMPLE_ASSIGN:
2493       dump_gimple_assign (buffer, as_a <gassign *> (gs), spc, flags);
2494       break;
2495
2496     case GIMPLE_BIND:
2497       dump_gimple_bind (buffer, as_a <gbind *> (gs), spc, flags);
2498       break;
2499
2500     case GIMPLE_CALL:
2501       dump_gimple_call (buffer, as_a <gcall *> (gs), spc, flags);
2502       break;
2503
2504     case GIMPLE_COND:
2505       dump_gimple_cond (buffer, as_a <gcond *> (gs), spc, flags);
2506       break;
2507
2508     case GIMPLE_LABEL:
2509       dump_gimple_label (buffer, as_a <glabel *> (gs), spc, flags);
2510       break;
2511
2512     case GIMPLE_GOTO:
2513       dump_gimple_goto (buffer, as_a <ggoto *> (gs), spc, flags);
2514       break;
2515
2516     case GIMPLE_NOP:
2517       pp_string (buffer, "GIMPLE_NOP");
2518       break;
2519
2520     case GIMPLE_RETURN:
2521       dump_gimple_return (buffer, as_a <greturn *> (gs), spc, flags);
2522       break;
2523
2524     case GIMPLE_SWITCH:
2525       dump_gimple_switch (buffer, as_a <gswitch *> (gs), spc, flags);
2526       break;
2527
2528     case GIMPLE_TRY:
2529       dump_gimple_try (buffer, as_a <gtry *> (gs), spc, flags);
2530       break;
2531
2532     case GIMPLE_PHI:
2533       dump_gimple_phi (buffer, as_a <gphi *> (gs), spc, false, flags);
2534       break;
2535
2536     case GIMPLE_OMP_PARALLEL:
2537       dump_gimple_omp_parallel (buffer, as_a <gomp_parallel *> (gs), spc,
2538                                 flags);
2539       break;
2540
2541     case GIMPLE_OMP_TASK:
2542       dump_gimple_omp_task (buffer, as_a <gomp_task *> (gs), spc, flags);
2543       break;
2544
2545     case GIMPLE_OMP_ATOMIC_LOAD:
2546       dump_gimple_omp_atomic_load (buffer, as_a <gomp_atomic_load *> (gs),
2547                                    spc, flags);
2548       break;
2549
2550     case GIMPLE_OMP_ATOMIC_STORE:
2551       dump_gimple_omp_atomic_store (buffer,
2552                                     as_a <gomp_atomic_store *> (gs),
2553                                     spc, flags);
2554       break;
2555
2556     case GIMPLE_OMP_FOR:
2557       dump_gimple_omp_for (buffer, as_a <gomp_for *> (gs), spc, flags);
2558       break;
2559
2560     case GIMPLE_OMP_CONTINUE:
2561       dump_gimple_omp_continue (buffer, as_a <gomp_continue *> (gs), spc,
2562                                 flags);
2563       break;
2564
2565     case GIMPLE_OMP_SINGLE:
2566       dump_gimple_omp_single (buffer, as_a <gomp_single *> (gs), spc,
2567                               flags);
2568       break;
2569
2570     case GIMPLE_OMP_TARGET:
2571       dump_gimple_omp_target (buffer, as_a <gomp_target *> (gs), spc,
2572                               flags);
2573       break;
2574
2575     case GIMPLE_OMP_TEAMS:
2576       dump_gimple_omp_teams (buffer, as_a <gomp_teams *> (gs), spc,
2577                              flags);
2578       break;
2579
2580     case GIMPLE_OMP_RETURN:
2581       dump_gimple_omp_return (buffer, gs, spc, flags);
2582       break;
2583
2584     case GIMPLE_OMP_SECTIONS:
2585       dump_gimple_omp_sections (buffer, as_a <gomp_sections *> (gs),
2586                                 spc, flags);
2587       break;
2588
2589     case GIMPLE_OMP_SECTIONS_SWITCH:
2590       pp_string (buffer, "GIMPLE_SECTIONS_SWITCH");
2591       break;
2592
2593     case GIMPLE_OMP_MASTER:
2594     case GIMPLE_OMP_TASKGROUP:
2595     case GIMPLE_OMP_SECTION:
2596     case GIMPLE_OMP_GRID_BODY:
2597       dump_gimple_omp_block (buffer, gs, spc, flags);
2598       break;
2599
2600     case GIMPLE_OMP_ORDERED:
2601       dump_gimple_omp_ordered (buffer, as_a <gomp_ordered *> (gs), spc,
2602                                flags);
2603       break;
2604
2605     case GIMPLE_OMP_CRITICAL:
2606       dump_gimple_omp_critical (buffer, as_a <gomp_critical *> (gs), spc,
2607                                 flags);
2608       break;
2609
2610     case GIMPLE_CATCH:
2611       dump_gimple_catch (buffer, as_a <gcatch *> (gs), spc, flags);
2612       break;
2613
2614     case GIMPLE_EH_FILTER:
2615       dump_gimple_eh_filter (buffer, as_a <geh_filter *> (gs), spc, flags);
2616       break;
2617
2618     case GIMPLE_EH_MUST_NOT_THROW:
2619       dump_gimple_eh_must_not_throw (buffer,
2620                                      as_a <geh_mnt *> (gs),
2621                                      spc, flags);
2622       break;
2623
2624     case GIMPLE_EH_ELSE:
2625       dump_gimple_eh_else (buffer, as_a <geh_else *> (gs), spc, flags);
2626       break;
2627
2628     case GIMPLE_RESX:
2629       dump_gimple_resx (buffer, as_a <gresx *> (gs), spc, flags);
2630       break;
2631
2632     case GIMPLE_EH_DISPATCH:
2633       dump_gimple_eh_dispatch (buffer, as_a <geh_dispatch *> (gs), spc,
2634                                flags);
2635       break;
2636
2637     case GIMPLE_DEBUG:
2638       dump_gimple_debug (buffer, as_a <gdebug *> (gs), spc, flags);
2639       break;
2640
2641     case GIMPLE_PREDICT:
2642       pp_string (buffer, "// predicted ");
2643       if (gimple_predict_outcome (gs))
2644         pp_string (buffer, "likely by ");
2645       else
2646         pp_string (buffer, "unlikely by ");
2647       pp_string (buffer, predictor_name (gimple_predict_predictor (gs)));
2648       pp_string (buffer, " predictor.");
2649       break;
2650
2651     case GIMPLE_TRANSACTION:
2652       dump_gimple_transaction (buffer, as_a <gtransaction *> (gs), spc,
2653                                flags);
2654       break;
2655
2656     default:
2657       GIMPLE_NIY;
2658     }
2659 }
2660
2661
2662 /* Dumps header of basic block BB to OUTF indented by INDENT
2663    spaces and details described by flags.  */
2664
2665 static void
2666 dump_gimple_bb_header (FILE *outf, basic_block bb, int indent,
2667                        dump_flags_t flags)
2668 {
2669   if (flags & TDF_BLOCKS)
2670     {
2671       if (flags & TDF_LINENO)
2672         {
2673           gimple_stmt_iterator gsi;
2674
2675           fputs (";; ", outf);
2676
2677           for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
2678             if (!is_gimple_debug (gsi_stmt (gsi))
2679                 && get_lineno (gsi_stmt (gsi)) != UNKNOWN_LOCATION)
2680               {
2681                 fprintf (outf, "%*sstarting at line %d",
2682                          indent, "", get_lineno (gsi_stmt (gsi)));
2683                 break;
2684               }
2685           if (bb->discriminator)
2686             fprintf (outf, ", discriminator %i", bb->discriminator);
2687           fputc ('\n', outf);
2688         }
2689     }
2690   else
2691     {
2692       if (flags & TDF_GIMPLE)
2693         fprintf (outf, "%*sbb_%d:\n", indent, "", bb->index);
2694       else
2695         fprintf (outf, "%*s<bb %d> %s:\n",
2696                  indent, "", bb->index, dump_profile (bb->count));
2697     }
2698 }
2699
2700
2701 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2702    spaces.  */
2703
2704 static void
2705 dump_gimple_bb_footer (FILE *outf ATTRIBUTE_UNUSED,
2706                        basic_block bb ATTRIBUTE_UNUSED,
2707                        int indent ATTRIBUTE_UNUSED,
2708                        dump_flags_t flags ATTRIBUTE_UNUSED)
2709 {
2710   /* There is currently no GIMPLE-specific basic block info to dump.  */
2711   return;
2712 }
2713
2714
2715 /* Dump PHI nodes of basic block BB to BUFFER with details described
2716    by FLAGS and indented by INDENT spaces.  */
2717
2718 static void
2719 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent,
2720                 dump_flags_t flags)
2721 {
2722   gphi_iterator i;
2723
2724   for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
2725     {
2726       gphi *phi = i.phi ();
2727       if (!virtual_operand_p (gimple_phi_result (phi)) || (flags & TDF_VOPS))
2728         {
2729           INDENT (indent);
2730           dump_gimple_phi (buffer, phi, indent,
2731                            (flags & TDF_GIMPLE) ? false : true, flags);
2732           pp_newline (buffer);
2733         }
2734     }
2735 }
2736
2737
2738 /* Dump jump to basic block BB that is represented implicitly in the cfg
2739    to BUFFER.  */
2740
2741 static void
2742 pp_cfg_jump (pretty_printer *buffer, edge e, dump_flags_t flags)
2743 {
2744   if (flags & TDF_GIMPLE)
2745     {
2746       pp_string (buffer, "goto bb_");
2747       pp_decimal_int (buffer, e->dest->index);
2748       pp_semicolon (buffer);
2749     }
2750   else
2751     {
2752       pp_string (buffer, "goto <bb ");
2753       pp_decimal_int (buffer, e->dest->index);
2754       pp_greater (buffer);
2755       pp_semicolon (buffer);
2756
2757       dump_edge_probability (buffer, e);
2758     }
2759 }
2760
2761
2762 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2763    by INDENT spaces, with details given by FLAGS.  */
2764
2765 static void
2766 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2767                      dump_flags_t flags)
2768 {
2769   edge e;
2770   gimple *stmt;
2771
2772   stmt = last_stmt (bb);
2773
2774   if (stmt && gimple_code (stmt) == GIMPLE_COND)
2775     {
2776       edge true_edge, false_edge;
2777
2778       /* When we are emitting the code or changing CFG, it is possible that
2779          the edges are not yet created.  When we are using debug_bb in such
2780          a situation, we do not want it to crash.  */
2781       if (EDGE_COUNT (bb->succs) != 2)
2782         return;
2783       extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
2784
2785       INDENT (indent + 2);
2786       pp_cfg_jump (buffer, true_edge, flags);
2787       newline_and_indent (buffer, indent);
2788       pp_string (buffer, "else");
2789       newline_and_indent (buffer, indent + 2);
2790       pp_cfg_jump (buffer, false_edge, flags);
2791       pp_newline (buffer);
2792       return;
2793     }
2794
2795   /* If there is a fallthru edge, we may need to add an artificial
2796      goto to the dump.  */
2797   e = find_fallthru_edge (bb->succs);
2798
2799   if (e && e->dest != bb->next_bb)
2800     {
2801       INDENT (indent);
2802
2803       if ((flags & TDF_LINENO)
2804           && e->goto_locus != UNKNOWN_LOCATION)
2805         dump_location (buffer, e->goto_locus);
2806
2807       pp_cfg_jump (buffer, e, flags);
2808       pp_newline (buffer);
2809     }
2810 }
2811
2812
2813 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2814    indented by INDENT spaces.  */
2815
2816 static void
2817 gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent,
2818                      dump_flags_t flags)
2819 {
2820   gimple_stmt_iterator gsi;
2821   gimple *stmt;
2822   int label_indent = indent - 2;
2823
2824   if (label_indent < 0)
2825     label_indent = 0;
2826
2827   dump_phi_nodes (buffer, bb, indent, flags);
2828
2829   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
2830     {
2831       int curr_indent;
2832
2833       stmt = gsi_stmt (gsi);
2834
2835       curr_indent = gimple_code (stmt) == GIMPLE_LABEL ? label_indent : indent;
2836
2837       INDENT (curr_indent);
2838       pp_gimple_stmt_1 (buffer, stmt, curr_indent, flags);
2839       pp_newline_and_flush (buffer);
2840       gcc_checking_assert (DECL_STRUCT_FUNCTION (current_function_decl));
2841       dump_histograms_for_stmt (DECL_STRUCT_FUNCTION (current_function_decl),
2842                                 pp_buffer (buffer)->stream, stmt);
2843     }
2844
2845   dump_implicit_edges (buffer, bb, indent, flags);
2846   pp_flush (buffer);
2847 }
2848
2849
2850 /* Dumps basic block BB to FILE with details described by FLAGS and
2851    indented by INDENT spaces.  */
2852
2853 void
2854 gimple_dump_bb (FILE *file, basic_block bb, int indent, dump_flags_t flags)
2855 {
2856   dump_gimple_bb_header (file, bb, indent, flags);
2857   if (bb->index >= NUM_FIXED_BLOCKS)
2858     {
2859       pretty_printer buffer;
2860       pp_needs_newline (&buffer) = true;
2861       buffer.buffer->stream = file;
2862       gimple_dump_bb_buff (&buffer, bb, indent, flags);
2863     }
2864   dump_gimple_bb_footer (file, bb, indent, flags);
2865 }
2866
2867 /* Dumps basic block BB to pretty-printer PP with default dump flags and
2868    no indentation, for use as a label of a DOT graph record-node.
2869    ??? Should just use gimple_dump_bb_buff here, except that value profiling
2870    histogram dumping doesn't know about pretty-printers.  */
2871
2872 void
2873 gimple_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
2874 {
2875   pp_printf (pp, "<bb %d>:\n", bb->index);
2876   pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
2877
2878   for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
2879        gsi_next (&gsi))
2880     {
2881       gphi *phi = gsi.phi ();
2882       if (!virtual_operand_p (gimple_phi_result (phi))
2883           || (dump_flags & TDF_VOPS))
2884         {
2885           pp_bar (pp);
2886           pp_write_text_to_stream (pp);
2887           pp_string (pp, "# ");
2888           pp_gimple_stmt_1 (pp, phi, 0, dump_flags);
2889           pp_newline (pp);
2890           pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
2891         }
2892     }
2893
2894   for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
2895        gsi_next (&gsi))
2896     {
2897       gimple *stmt = gsi_stmt (gsi);
2898       pp_bar (pp);
2899       pp_write_text_to_stream (pp);
2900       pp_gimple_stmt_1 (pp, stmt, 0, dump_flags);
2901       pp_newline (pp);
2902       pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
2903     }
2904   dump_implicit_edges (pp, bb, 0, dump_flags);
2905   pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
2906 }
2907
2908
2909 /* Handle the %G format for TEXT.  Same as %K in handle_K_format in
2910    tree-pretty-print.c but with a Gimple call statement as an argument.  */
2911
2912 void
2913 percent_G_format (text_info *text)
2914 {
2915   gcall *stmt = va_arg (*text->args_ptr, gcall*);
2916
2917   /* Build a call expression from the Gimple call statement and
2918      pass it to the K formatter that knows how to format it.  */
2919   tree exp = build_vl_exp (CALL_EXPR, gimple_call_num_args (stmt) + 3);
2920   CALL_EXPR_FN (exp) = gimple_call_fn (stmt);
2921   TREE_TYPE (exp) = gimple_call_return_type (stmt);
2922   CALL_EXPR_STATIC_CHAIN (exp) = gimple_call_chain (stmt);
2923   SET_EXPR_LOCATION (exp, gimple_location (stmt));
2924
2925   percent_K_format (text, exp);
2926 }