LCOV - code coverage report
Current view: top level - gcc - gimple-pretty-print.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1277 1651 77.3 %
Date: 2020-03-28 11:57:23 Functions: 56 67 83.6 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

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

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.