LCOV - code coverage report
Current view: top level - gcc - tree-pretty-print.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 79.1 % 3458 2734
Test Date: 2026-11-14 16:39:50 Functions: 94.7 % 38 36
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /* Pretty formatting of GENERIC trees in C syntax.
       2              :    Copyright (C) 2001-2026 Free Software Foundation, Inc.
       3              :    Adapted from c-pretty-print.cc by Diego Novillo <dnovillo@redhat.com>
       4              : 
       5              : This file is part of GCC.
       6              : 
       7              : GCC is free software; you can redistribute it and/or modify it under
       8              : the terms of the GNU General Public License as published by the Free
       9              : Software Foundation; either version 3, or (at your option) any later
      10              : version.
      11              : 
      12              : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13              : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14              : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15              : for more details.
      16              : 
      17              : You should have received a copy of the GNU General Public License
      18              : along with GCC; see the file COPYING3.  If not see
      19              : <http://www.gnu.org/licenses/>.  */
      20              : 
      21              : #include "config.h"
      22              : #include "system.h"
      23              : #include "coretypes.h"
      24              : #include "backend.h"
      25              : #include "rtl.h"
      26              : #include "tree.h"
      27              : #include "predict.h"
      28              : #include "cgraph.h"
      29              : #include "tree-pretty-print.h"
      30              : #include "stor-layout.h"
      31              : #include "langhooks.h"
      32              : #include "tree-iterator.h"
      33              : #include "dumpfile.h"
      34              : #include "internal-fn.h"
      35              : #include "gomp-constants.h"
      36              : #include "gimple.h"
      37              : #include "fold-const.h"
      38              : #include "omp-general.h"
      39              : 
      40              : /* Routines in this file get invoked via the default tree printer
      41              :    used by diagnostics and thus they are called from pp_printf which
      42              :    isn't reentrant.  Avoid using pp_printf in this file.  */
      43              : #pragma GCC poison pp_printf
      44              : 
      45              : /* Disable warnings about quoting issues in the pp_xxx calls below
      46              :    that (intentionally) don't follow GCC diagnostic conventions.  */
      47              : #if __GNUC__ >= 10
      48              : #  pragma GCC diagnostic push
      49              : #  pragma GCC diagnostic ignored "-Wformat-diag"
      50              : #endif
      51              : 
      52              : /* Local functions, macros and variables.  */
      53              : static const char *op_symbol (const_tree, dump_flags_t = TDF_NONE);
      54              : static void newline_and_indent (pretty_printer *, int);
      55              : static void maybe_init_pretty_print (FILE *);
      56              : static void print_struct_decl (pretty_printer *, const_tree, int, dump_flags_t);
      57              : static void do_niy (pretty_printer *, const_tree, int, dump_flags_t);
      58              : 
      59              : #define INDENT(SPACE) do { \
      60              :   int i; for (i = 0; i<SPACE; i++) pp_space (pp); } while (0)
      61              : 
      62              : #define NIY do_niy (pp, node, spc, flags)
      63              : 
      64              : static pretty_printer *tree_pp;
      65              : 
      66              : /* Try to print something for an unknown tree code.  */
      67              : 
      68              : static void
      69        13333 : do_niy (pretty_printer *pp, const_tree node, int spc, dump_flags_t flags)
      70              : {
      71        13333 :   int i, len;
      72              : 
      73        13333 :   pp_string (pp, "<<< Unknown tree: ");
      74        13333 :   pp_string (pp, get_tree_code_name (TREE_CODE (node)));
      75              : 
      76        13333 :   if (EXPR_P (node))
      77              :     {
      78        13115 :       len = TREE_OPERAND_LENGTH (node);
      79        43336 :       for (i = 0; i < len; ++i)
      80              :         {
      81        17106 :           newline_and_indent (pp, spc+2);
      82        17106 :           dump_generic_node (pp, TREE_OPERAND (node, i), spc+2, flags, false);
      83              :         }
      84              :     }
      85              : 
      86        13333 :   pp_string (pp, " >>>");
      87        13333 : }
      88              : 
      89              : /* Debugging function to print out a generic expression.  */
      90              : 
      91              : DEBUG_FUNCTION void
      92            1 : debug_generic_expr (tree t)
      93              : {
      94            1 :   print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);
      95            1 :   fprintf (stderr, "\n");
      96            1 : }
      97              : 
      98              : /* Debugging function to print out a generic statement.  */
      99              : 
     100              : DEBUG_FUNCTION void
     101            0 : debug_generic_stmt (tree t)
     102              : {
     103            0 :   print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);
     104            0 :   fprintf (stderr, "\n");
     105            0 : }
     106              : 
     107              : /* Debugging function to print out a chain of trees .  */
     108              : 
     109              : DEBUG_FUNCTION void
     110            0 : debug_tree_chain (tree t)
     111              : {
     112            0 :   hash_set<tree> seen;
     113              : 
     114            0 :   while (t)
     115              :     {
     116            0 :       print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
     117            0 :       fprintf (stderr, " ");
     118            0 :       t = TREE_CHAIN (t);
     119            0 :       if (seen.add (t))
     120              :         {
     121            0 :           fprintf (stderr, "... [cycled back to ");
     122            0 :           print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);
     123            0 :           fprintf (stderr, "]");
     124            0 :           break;
     125              :         }
     126              :     }
     127            0 :   fprintf (stderr, "\n");
     128            0 : }
     129              : 
     130              : /* Prints declaration DECL to the FILE with details specified by FLAGS.  */
     131              : void
     132       298834 : print_generic_decl (FILE *file, tree decl, dump_flags_t flags)
     133              : {
     134       298834 :   maybe_init_pretty_print (file);
     135       298834 :   print_declaration (tree_pp, decl, 2, flags);
     136       298834 :   pp_write_text_to_stream (tree_pp);
     137       298834 : }
     138              : 
     139              : /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
     140              :    to show in the dump.  See TDF_* in dumpfile.h.  */
     141              : 
     142              : void
     143        72325 : print_generic_stmt (FILE *file, tree t, dump_flags_t flags)
     144              : {
     145        72325 :   maybe_init_pretty_print (file);
     146        72325 :   dump_generic_node (tree_pp, t, 0, flags, true);
     147        72325 :   pp_newline_and_flush (tree_pp);
     148        72325 : }
     149              : 
     150              : /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
     151              :    to show in the dump.  See TDF_* in dumpfile.h.  The output is indented by
     152              :    INDENT spaces.  */
     153              : 
     154              : void
     155         6438 : print_generic_stmt_indented (FILE *file, tree t, dump_flags_t flags, int indent)
     156              : {
     157         6438 :   int i;
     158              : 
     159         6438 :   maybe_init_pretty_print (file);
     160              : 
     161        12876 :   for (i = 0; i < indent; i++)
     162            0 :     pp_space (tree_pp);
     163         6438 :   dump_generic_node (tree_pp, t, indent, flags, true);
     164         6438 :   pp_newline_and_flush (tree_pp);
     165         6438 : }
     166              : 
     167              : /* Print a single expression T on file FILE.  FLAGS specifies details to show
     168              :    in the dump.  See TDF_* in dumpfile.h.  */
     169              : 
     170              : void
     171      6808598 : print_generic_expr (FILE *file, tree t, dump_flags_t flags)
     172              : {
     173      6808598 :   maybe_init_pretty_print (file);
     174      6808598 :   dump_generic_node (tree_pp, t, 0, flags, false);
     175      6808598 :   pp_flush (tree_pp);
     176      6808598 : }
     177              : 
     178              : /* Print a single expression T to string, and return it.  The caller
     179              :    must free the returned memory.  */
     180              : 
     181              : char *
     182        62656 : print_generic_expr_to_str (tree t)
     183              : {
     184        62656 :   pretty_printer pp;
     185        62656 :   dump_generic_node (&pp, t, 0, TDF_VOPS|TDF_MEMSYMS, false);
     186        62656 :   return xstrdup (pp_formatted_text (&pp));
     187        62656 : }
     188              : 
     189              : /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D<num> sequences
     190              :    in it are replaced with Dxxxx, as long as they are at the start or
     191              :    preceded by $ and at the end or followed by $.  See make_fancy_name
     192              :    in tree-sra.cc.  */
     193              : 
     194              : static void
     195         2664 : dump_fancy_name (pretty_printer *pp, tree name)
     196              : {
     197         2664 :   int cnt = 0;
     198         2664 :   int length = IDENTIFIER_LENGTH (name);
     199         2664 :   const char *n = IDENTIFIER_POINTER (name);
     200         2664 :   do
     201              :     {
     202         2664 :       n = strchr (n, 'D');
     203         2664 :       if (n == NULL)
     204              :         break;
     205            0 :       if (ISDIGIT (n[1])
     206            0 :           && (n == IDENTIFIER_POINTER (name) || n[-1] == '$'))
     207              :         {
     208              :           int l = 2;
     209            0 :           while (ISDIGIT (n[l]))
     210            0 :             l++;
     211            0 :           if (n[l] == '\0' || n[l] == '$')
     212              :             {
     213            0 :               cnt++;
     214            0 :               length += 5 - l;
     215              :             }
     216            0 :           n += l;
     217              :         }
     218              :       else
     219            0 :         n++;
     220              :     }
     221              :   while (1);
     222         2664 :   if (cnt == 0)
     223              :     {
     224         2664 :       pp_tree_identifier (pp, name);
     225         2664 :       return;
     226              :     }
     227              : 
     228            0 :   char *str = XNEWVEC (char, length + 1);
     229            0 :   char *p = str;
     230            0 :   const char *q;
     231            0 :   q = n = IDENTIFIER_POINTER (name);
     232            0 :   do
     233              :     {
     234            0 :       q = strchr (q, 'D');
     235            0 :       if (q == NULL)
     236              :         break;
     237            0 :       if (ISDIGIT (q[1])
     238            0 :           && (q == IDENTIFIER_POINTER (name) || q[-1] == '$'))
     239              :         {
     240              :           int l = 2;
     241            0 :           while (ISDIGIT (q[l]))
     242            0 :             l++;
     243            0 :           if (q[l] == '\0' || q[l] == '$')
     244              :             {
     245            0 :               memcpy (p, n, q - n);
     246            0 :               memcpy (p + (q - n), "Dxxxx", 5);
     247            0 :               p += (q - n) + 5;
     248            0 :               n = q + l;
     249              :             }
     250            0 :           q += l;
     251              :         }
     252              :       else
     253            0 :         q++;
     254              :     }
     255              :   while (1);
     256            0 :   memcpy (p, n, IDENTIFIER_LENGTH (name) - (n - IDENTIFIER_POINTER (name)));
     257            0 :   str[length] = '\0';
     258            0 :   if (pp_translate_identifiers (pp))
     259              :     {
     260            0 :       const char *text = identifier_to_locale (str);
     261            0 :       pp_append_text (pp, text, text + strlen (text));
     262              :     }
     263              :   else
     264            0 :     pp_append_text (pp, str, str + length);
     265            0 :   XDELETEVEC (str);
     266              : }
     267              : 
     268              : /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
     269              :    in FLAGS.  */
     270              : 
     271              : static void
     272      6116223 : dump_decl_name (pretty_printer *pp, tree node, dump_flags_t flags)
     273              : {
     274      6116223 :   tree name = DECL_NAME (node);
     275      6116223 :   if (name)
     276              :     {
     277      5593515 :       if ((flags & TDF_ASMNAME)
     278        17260 :           && HAS_DECL_ASSEMBLER_NAME_P (node)
     279      5608760 :           && DECL_ASSEMBLER_NAME_SET_P (node))
     280         1610 :         pp_tree_identifier (pp, DECL_ASSEMBLER_NAME_RAW (node));
     281              :       /* For -fcompare-debug don't dump DECL_NAMELESS names at all,
     282              :          -g might have created more fancy names and their indexes
     283              :          could get out of sync.  Usually those should be DECL_IGNORED_P
     284              :          too, SRA can create even non-DECL_IGNORED_P DECL_NAMELESS fancy
     285              :          names, let's hope those never get out of sync after doing the
     286              :          dump_fancy_name sanitization.  */
     287      5591905 :       else if ((flags & TDF_COMPARE_DEBUG)
     288        44028 :                && DECL_NAMELESS (node)
     289      5597159 :                && DECL_IGNORED_P (node))
     290              :         name = NULL_TREE;
     291              :       /* For DECL_NAMELESS names look for embedded uids in the
     292              :          names and sanitize them for TDF_NOUID.  */
     293      5587307 :       else if ((flags & TDF_NOUID) && DECL_NAMELESS (node))
     294         1462 :         dump_fancy_name (pp, name);
     295              :       else
     296      5585845 :         pp_tree_identifier (pp, name);
     297              :     }
     298      6116223 :   char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.';
     299      6116223 :   if ((flags & TDF_UID) || name == NULL_TREE)
     300              :     {
     301       544972 :       if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)
     302              :         {
     303            3 :           pp_character (pp, 'L');
     304            3 :           pp_character (pp, uid_sep);
     305            3 :           pp_decimal_int (pp, (int) LABEL_DECL_UID (node));
     306              :         }
     307       544969 :       else if (TREE_CODE (node) == DEBUG_EXPR_DECL)
     308              :         {
     309         4499 :           if (flags & TDF_NOUID)
     310            0 :             pp_string (pp, "D#xxxx");
     311              :           else
     312              :             {
     313         4499 :               pp_string (pp, "D#");
     314         4499 :               pp_decimal_int (pp, (int) DEBUG_TEMP_UID (node));
     315              :             }
     316              :         }
     317              :       else
     318              :         {
     319       540470 :           char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
     320       540470 :           pp_character (pp, c);
     321       540470 :           pp_character (pp, uid_sep);
     322       540470 :           if (flags & TDF_NOUID)
     323         7251 :             pp_string (pp, "xxxx");
     324              :           else
     325       533219 :             pp_scalar (pp, "%u", DECL_UID (node));
     326              :         }
     327              :     }
     328      6116223 :   if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node))
     329              :     {
     330            2 :       if (flags & TDF_NOUID)
     331            0 :         pp_string (pp, "ptD.xxxx");
     332              :       else
     333              :         {
     334            2 :           pp_string (pp, "ptD.");
     335            2 :           pp_scalar (pp, "%u", DECL_PT_UID (node));
     336              :         }
     337              :     }
     338      6116223 : }
     339              : 
     340              : /* Like the above, but used for pretty printing function calls.  */
     341              : 
     342              : static void
     343       184502 : dump_function_name (pretty_printer *pp, tree node, dump_flags_t flags)
     344              : {
     345       184502 :   if (CONVERT_EXPR_P (node))
     346            0 :     node = TREE_OPERAND (node, 0);
     347       184502 :   if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)
     348              :     {
     349       184119 :       pp_string (pp, lang_hooks.decl_printable_name (node, 1));
     350       184119 :       if (flags & TDF_UID)
     351              :         {
     352            0 :           char uid_sep = (flags & TDF_GIMPLE) ? '_' : '.';
     353            0 :           pp_character (pp, 'D');
     354            0 :           pp_character (pp, uid_sep);
     355            0 :           pp_scalar (pp, "%u", DECL_UID (node));
     356              :         }
     357              :     }
     358              :   else
     359          383 :     dump_decl_name (pp, node, flags);
     360       184502 : }
     361              : 
     362              : /* Dump a function declaration.  NODE is the FUNCTION_TYPE.  PP, SPC and
     363              :    FLAGS are as in dump_generic_node.  */
     364              : 
     365              : static void
     366        16398 : dump_function_declaration (pretty_printer *pp, tree node,
     367              :                            int spc, dump_flags_t flags)
     368              : {
     369        16398 :   bool wrote_arg = false;
     370        16398 :   tree arg;
     371              : 
     372        16398 :   pp_space (pp);
     373        16398 :   pp_left_paren (pp);
     374              : 
     375              :   /* Print the argument types.  */
     376        16398 :   arg = TYPE_ARG_TYPES (node);
     377        44850 :   while (arg && arg != void_list_node && arg != error_mark_node)
     378              :     {
     379        28452 :       if (wrote_arg)
     380              :         {
     381        17410 :           pp_comma (pp);
     382        17410 :           pp_space (pp);
     383              :         }
     384        28452 :       wrote_arg = true;
     385        28452 :       dump_generic_node (pp, TREE_VALUE (arg), spc, flags, false);
     386        28452 :       arg = TREE_CHAIN (arg);
     387              :     }
     388              : 
     389              :   /* Drop the trailing void_type_node if we had any previous argument.  */
     390        16398 :   if (arg == void_list_node && !wrote_arg)
     391         2860 :     pp_string (pp, "void");
     392              :   /* Properly dump vararg function types.  */
     393        13538 :   else if (!arg && wrote_arg)
     394          115 :     pp_string (pp, ", ...");
     395              :   /* Avoid printing any arg for unprototyped functions.  */
     396              : 
     397        16398 :   pp_right_paren (pp);
     398        16398 : }
     399              : 
     400              : /* Dump the domain associated with an array.  */
     401              : 
     402              : static void
     403       105147 : dump_array_domain (pretty_printer *pp, tree domain, int spc, dump_flags_t flags)
     404              : {
     405       105147 :   pp_left_bracket (pp);
     406       105147 :   if (domain)
     407              :     {
     408       104829 :       tree min = TYPE_MIN_VALUE (domain);
     409       104829 :       tree max = TYPE_MAX_VALUE (domain);
     410              : 
     411       104829 :       if (min && max
     412        81884 :           && integer_zerop (min)
     413       181875 :           && tree_fits_shwi_p (max))
     414        72232 :         pp_wide_integer (pp, tree_to_shwi (max) + 1);
     415              :       else
     416              :         {
     417        32597 :           if (min)
     418        32597 :             dump_generic_node (pp, min, spc, flags, false);
     419        32597 :           pp_colon (pp);
     420        32597 :           if (max)
     421         9652 :             dump_generic_node (pp, max, spc, flags, false);
     422              :         }
     423              :     }
     424              :   else
     425          318 :     pp_string (pp, "<unknown>");
     426       105147 :   pp_right_bracket (pp);
     427       105147 : }
     428              : 
     429              : 
     430              : /* Dump OpenMP iterators ITER.  */
     431              : 
     432              : static void
     433          137 : dump_omp_iterators (pretty_printer *pp, tree iter, int spc, dump_flags_t flags)
     434              : {
     435          137 :   pp_string (pp, "iterator(");
     436          479 :   for (tree it = iter; it; it = TREE_CHAIN (it))
     437              :     {
     438          205 :       if (it != iter)
     439           68 :         pp_string (pp, ", ");
     440          205 :       dump_generic_node (pp, TREE_TYPE (OMP_ITERATOR_VAR (it)), spc, flags,
     441              :                          false);
     442          205 :       pp_space (pp);
     443          205 :       dump_generic_node (pp, OMP_ITERATOR_VAR (it), spc, flags, false);
     444          205 :       pp_equal (pp);
     445          205 :       dump_generic_node (pp, OMP_ITERATOR_BEGIN (it), spc, flags, false);
     446          205 :       pp_colon (pp);
     447          205 :       dump_generic_node (pp, OMP_ITERATOR_END (it), spc, flags, false);
     448          205 :       pp_colon (pp);
     449          205 :       dump_generic_node (pp, OMP_ITERATOR_STEP (it), spc, flags, false);
     450              :     }
     451          137 :   if (flags & TDF_DETAILS && OMP_ITERATOR_BLOCK (iter))
     452              :     {
     453            0 :       pp_string (pp, ", block=");
     454            0 :       pp_left_brace (pp);
     455            0 :       newline_and_indent (pp, spc + 2);
     456            0 :       dump_generic_node (pp, BLOCK_SUBBLOCKS (OMP_ITERATOR_BLOCK (iter)),
     457              :                          spc + 2, flags, true);
     458            0 :       newline_and_indent (pp, spc);
     459            0 :       pp_right_brace (pp);
     460              :     }
     461          137 :   if (OMP_ITERATOR_EXPANDED_P (iter))
     462              :     {
     463          119 :       pp_string (pp, ", loop_label=");
     464          119 :       dump_generic_node (pp, OMP_ITERATOR_LABEL (iter), spc, flags, false);
     465          119 :       pp_string (pp, ", elems=");
     466          119 :       dump_generic_node (pp, OMP_ITERATOR_ELEMS (iter), spc, flags, false);
     467          119 :       pp_string (pp, ", index=");
     468          119 :       dump_generic_node (pp, OMP_ITERATOR_INDEX (iter), spc, flags, false);
     469              :       /* The count field is not used yet.  */
     470              :     }
     471          137 :   pp_right_paren (pp);
     472          137 : }
     473              : 
     474              : /* Dump OpenMP's prefer_type of the init clause.  */
     475              : 
     476              : static void
     477          251 : dump_omp_init_prefer_type (pretty_printer *pp, tree t)
     478              : {
     479          251 :   if (t == NULL_TREE)
     480              :     return;
     481          119 :   pp_string (pp, "prefer_type(");
     482          119 :   const char *str = TREE_STRING_POINTER (t);
     483          527 :   while (str[0] == (char) GOMP_INTEROP_IFR_SEPARATOR)
     484              :     {
     485          408 :       bool has_fr = false;
     486          408 :       pp_character (pp, '{');
     487          408 :       str++;
     488          794 :       while (str[0] != (char) GOMP_INTEROP_IFR_SEPARATOR)
     489              :         {
     490          386 :           if (has_fr)
     491            0 :             pp_character (pp, ',');
     492          386 :           has_fr = true;
     493          386 :           pp_string (pp, "fr(\"");
     494          386 :           pp_string (pp, omp_get_name_from_fr_id (str[0]));
     495          386 :           pp_string (pp, "\")");
     496          386 :           str++;
     497              :         }
     498          408 :       str++;
     499          408 :       if (has_fr && str[0] != '\0')
     500           52 :         pp_character (pp, ',');
     501          534 :       while (str[0] != '\0')
     502              :         {
     503          126 :           pp_string (pp, "attr(\"");
     504          126 :           pp_string (pp, str);
     505          126 :           pp_string (pp, "\")");
     506          126 :           str += strlen (str) + 1;
     507          126 :           if (str[0] != '\0')
     508           52 :             pp_character (pp, ',');
     509              :         }
     510          408 :       str++;
     511          408 :       pp_character (pp, '}');
     512          408 :       if (str[0] != '\0')
     513          289 :         pp_string (pp, ", ");
     514              :     }
     515          119 :   pp_right_paren (pp);
     516              : }
     517              : 
     518              : /* Dump OMP clause CLAUSE, without following OMP_CLAUSE_CHAIN.
     519              : 
     520              :    PP, CLAUSE, SPC and FLAGS are as in dump_generic_node.  */
     521              : 
     522              : static void
     523        30503 : dump_omp_clause (pretty_printer *pp, tree clause, int spc, dump_flags_t flags)
     524              : {
     525        30503 :   const char *name;
     526        30503 :   const char *modifier = NULL;
     527        30503 :   switch (OMP_CLAUSE_CODE (clause))
     528              :     {
     529         3277 :     case OMP_CLAUSE_PRIVATE:
     530         3277 :       name = "private";
     531         3277 :       goto print_remap;
     532         1124 :     case OMP_CLAUSE_SHARED:
     533         1124 :       name = "shared";
     534         1124 :       goto print_remap;
     535         1607 :     case OMP_CLAUSE_FIRSTPRIVATE:
     536         1607 :       name = "firstprivate";
     537         1607 :       goto print_remap;
     538         1166 :     case OMP_CLAUSE_LASTPRIVATE:
     539         1166 :       name = "lastprivate";
     540         1166 :       if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (clause))
     541            7 :         modifier = "conditional:";
     542         1166 :       goto print_remap;
     543            4 :     case OMP_CLAUSE_COPYIN:
     544            4 :       name = "copyin";
     545            4 :       goto print_remap;
     546            1 :     case OMP_CLAUSE_COPYPRIVATE:
     547            1 :       name = "copyprivate";
     548            1 :       goto print_remap;
     549          747 :     case OMP_CLAUSE_UNIFORM:
     550          747 :       name = "uniform";
     551          747 :       goto print_remap;
     552          131 :     case OMP_CLAUSE_USE_DEVICE_PTR:
     553          131 :       name = "use_device_ptr";
     554          131 :       if (OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT (clause))
     555           29 :         modifier = "if_present:";
     556          131 :       goto print_remap;
     557           30 :     case OMP_CLAUSE_USE_DEVICE_ADDR:
     558           30 :       name = "use_device_addr";
     559           30 :       goto print_remap;
     560           40 :     case OMP_CLAUSE_HAS_DEVICE_ADDR:
     561           40 :       name = "has_device_addr";
     562           40 :       goto print_remap;
     563          116 :     case OMP_CLAUSE_IS_DEVICE_PTR:
     564          116 :       name = "is_device_ptr";
     565          116 :       goto print_remap;
     566            3 :     case OMP_CLAUSE_INCLUSIVE:
     567            3 :       name = "inclusive";
     568            3 :       goto print_remap;
     569            2 :     case OMP_CLAUSE_EXCLUSIVE:
     570            2 :       name = "exclusive";
     571            2 :       goto print_remap;
     572           45 :     case OMP_CLAUSE_NOVARIANTS:
     573           45 :       pp_string (pp, "novariants");
     574           45 :       pp_left_paren (pp);
     575           45 :       gcc_assert (OMP_CLAUSE_NOVARIANTS_EXPR (clause));
     576           45 :       dump_generic_node (pp, OMP_CLAUSE_NOVARIANTS_EXPR (clause), spc, flags,
     577              :                          false);
     578           45 :       pp_right_paren (pp);
     579           45 :       break;
     580           60 :     case OMP_CLAUSE_NOCONTEXT:
     581           60 :       pp_string (pp, "nocontext");
     582           60 :       pp_left_paren (pp);
     583           60 :       gcc_assert (OMP_CLAUSE_NOCONTEXT_EXPR (clause));
     584           60 :       dump_generic_node (pp, OMP_CLAUSE_NOCONTEXT_EXPR (clause), spc, flags,
     585              :                          false);
     586           60 :       pp_right_paren (pp);
     587           60 :       break;
     588           86 :     case OMP_CLAUSE__LOOPTEMP_:
     589           86 :       name = "_looptemp_";
     590           86 :       goto print_remap;
     591           12 :     case OMP_CLAUSE__REDUCTEMP_:
     592           12 :       name = "_reductemp_";
     593           12 :       goto print_remap;
     594            0 :     case OMP_CLAUSE__CONDTEMP_:
     595            0 :       name = "_condtemp_";
     596            0 :       goto print_remap;
     597            0 :     case OMP_CLAUSE__SCANTEMP_:
     598            0 :       name = "_scantemp_";
     599            0 :       goto print_remap;
     600            0 :     case OMP_CLAUSE_ENTER:
     601            0 :       if (OMP_CLAUSE_ENTER_TO (clause))
     602              :         name = "to";
     603              :       else
     604            0 :         name = "enter";
     605            0 :       goto print_remap;
     606            0 :     case OMP_CLAUSE_LINK:
     607            0 :       name = "link";
     608            0 :       goto print_remap;
     609            3 :     case OMP_CLAUSE_NONTEMPORAL:
     610            3 :       name = "nontemporal";
     611            3 :       goto print_remap;
     612         8349 :   print_remap:
     613         8349 :       pp_string (pp, name);
     614         8349 :       pp_left_paren (pp);
     615         8349 :       if (modifier)
     616           36 :         pp_string (pp, modifier);
     617         8349 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
     618              :                          spc, flags, false);
     619         8349 :       pp_right_paren (pp);
     620         8349 :       break;
     621              : 
     622           24 :     case OMP_CLAUSE_TASK_REDUCTION:
     623           24 :     case OMP_CLAUSE_IN_REDUCTION:
     624           27 :       pp_string (pp, OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_IN_REDUCTION
     625              :                      ? "in_" : "task_");
     626              :       /* FALLTHRU */
     627         1240 :     case OMP_CLAUSE_REDUCTION:
     628         1240 :       pp_string (pp, "reduction(");
     629         1240 :       if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_REDUCTION)
     630              :         {
     631         1216 :           if (OMP_CLAUSE_REDUCTION_TASK (clause))
     632           12 :             pp_string (pp, "task,");
     633         1204 :           else if (OMP_CLAUSE_REDUCTION_INSCAN (clause))
     634            6 :             pp_string (pp, "inscan,");
     635              :         }
     636         1240 :       if (OMP_CLAUSE_REDUCTION_CODE (clause) != ERROR_MARK)
     637              :         {
     638         1228 :           pp_string (pp,
     639         1228 :                      op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
     640         1228 :           pp_colon (pp);
     641              :         }
     642         1240 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
     643              :                          spc, flags, false);
     644         1240 :       pp_right_paren (pp);
     645         1240 :       break;
     646              : 
     647          152 :     case OMP_CLAUSE_IF:
     648          152 :       pp_string (pp, "if(");
     649          152 :       switch (OMP_CLAUSE_IF_MODIFIER (clause))
     650              :         {
     651              :         case ERROR_MARK: break;
     652            0 :         case VOID_CST: pp_string (pp, "cancel:"); break;
     653            4 :         case OMP_PARALLEL: pp_string (pp, "parallel:"); break;
     654            2 :         case OMP_SIMD: pp_string (pp, "simd:"); break;
     655            0 :         case OMP_TASK: pp_string (pp, "task:"); break;
     656            4 :         case OMP_TASKLOOP: pp_string (pp, "taskloop:"); break;
     657            0 :         case OMP_TARGET_DATA: pp_string (pp, "target data:"); break;
     658            0 :         case OMP_TARGET: pp_string (pp, "target:"); break;
     659            0 :         case OMP_TARGET_UPDATE: pp_string (pp, "target update:"); break;
     660            0 :         case OMP_TARGET_ENTER_DATA:
     661            0 :           pp_string (pp, "target enter data:"); break;
     662            0 :         case OMP_TARGET_EXIT_DATA: pp_string (pp, "target exit data:"); break;
     663            0 :         default: gcc_unreachable ();
     664              :         }
     665          152 :       dump_generic_node (pp, OMP_CLAUSE_IF_EXPR (clause),
     666              :                          spc, flags, false);
     667          152 :       pp_right_paren (pp);
     668          152 :       break;
     669              : 
     670           52 :     case OMP_CLAUSE_DESTROY:
     671           52 :       pp_string (pp, "destroy(");
     672           52 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
     673              :                          spc, flags, false);
     674           52 :       pp_right_paren (pp);
     675           52 :       break;
     676              : 
     677          251 :     case OMP_CLAUSE_INIT:
     678          251 :       pp_string (pp, "init(");
     679          251 :       dump_omp_init_prefer_type (pp, OMP_CLAUSE_INIT_PREFER_TYPE (clause));
     680          251 :       if (OMP_CLAUSE_INIT_TARGET (clause))
     681              :         {
     682          156 :           if (OMP_CLAUSE_INIT_PREFER_TYPE (clause))
     683           67 :             pp_string (pp, ", ");
     684          156 :           pp_string (pp, "target");
     685              :         }
     686          251 :       if (OMP_CLAUSE_INIT_TARGETSYNC (clause))
     687              :         {
     688          128 :           if (OMP_CLAUSE_INIT_PREFER_TYPE (clause) || OMP_CLAUSE_INIT_TARGET (clause))
     689           85 :             pp_string (pp, ", ");
     690          128 :           pp_string (pp, "targetsync");
     691              :         }
     692          251 :       if (OMP_CLAUSE_INIT_PREFER_TYPE (clause)
     693          132 :           || OMP_CLAUSE_INIT_TARGET (clause)
     694          294 :           || OMP_CLAUSE_INIT_TARGETSYNC (clause))
     695          251 :         pp_string (pp, ": ");
     696          251 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
     697              :                          spc, flags, false);
     698          251 :       pp_right_paren (pp);
     699          251 :       break;
     700              : 
     701           59 :     case OMP_CLAUSE_USE:
     702           59 :       pp_string (pp, "use(");
     703           59 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
     704              :                          spc, flags, false);
     705           59 :       pp_right_paren (pp);
     706           59 :       break;
     707              : 
     708           61 :     case OMP_CLAUSE_SELF:
     709           61 :       pp_string (pp, "self(");
     710           61 :       dump_generic_node (pp, OMP_CLAUSE_SELF_EXPR (clause),
     711              :                          spc, flags, false);
     712           61 :       pp_right_paren (pp);
     713           61 :       break;
     714              : 
     715          141 :     case OMP_CLAUSE_NUM_THREADS:
     716          141 :       pp_string (pp, "num_threads(");
     717          141 :       if (OMP_CLAUSE_NUM_THREADS_STRICT (clause))
     718            9 :         pp_string (pp, "strict");
     719          141 :       if (OMP_CLAUSE_NUM_THREADS_STRICT (clause)
     720          141 :           && OMP_CLAUSE_NUM_THREADS_DIMS (clause))
     721            5 :         pp_comma (pp);
     722          141 :       if (OMP_CLAUSE_NUM_THREADS_DIMS (clause))
     723           11 :         pp_string (pp, "dims()");
     724          141 :       if (OMP_CLAUSE_NUM_THREADS_STRICT (clause)
     725          141 :           || OMP_CLAUSE_NUM_THREADS_DIMS (clause))
     726           15 :         pp_colon (pp);
     727          141 :       dump_generic_node (pp, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
     728              :                          spc, flags, false);
     729          141 :       pp_right_paren (pp);
     730          141 :       break;
     731              : 
     732          764 :     case OMP_CLAUSE_NOWAIT:
     733          764 :       pp_string (pp, "nowait");
     734          764 :       break;
     735           27 :     case OMP_CLAUSE_ORDERED:
     736           27 :       pp_string (pp, "ordered");
     737           27 :       if (OMP_CLAUSE_ORDERED_EXPR (clause))
     738              :         {
     739            9 :           pp_left_paren (pp);
     740            9 :           dump_generic_node (pp, OMP_CLAUSE_ORDERED_EXPR (clause),
     741              :                              spc, flags, false);
     742            9 :           pp_right_paren (pp);
     743              :         }
     744              :       break;
     745              : 
     746         1262 :     case OMP_CLAUSE_DEFAULT:
     747         1262 :       pp_string (pp, "default(");
     748         1262 :       switch (OMP_CLAUSE_DEFAULT_KIND (clause))
     749              :         {
     750              :         case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
     751              :           break;
     752           11 :         case OMP_CLAUSE_DEFAULT_SHARED:
     753           11 :           pp_string (pp, "shared");
     754           11 :           break;
     755         1194 :         case OMP_CLAUSE_DEFAULT_NONE:
     756         1194 :           pp_string (pp, "none");
     757         1194 :           break;
     758            0 :         case OMP_CLAUSE_DEFAULT_PRIVATE:
     759            0 :           pp_string (pp, "private");
     760            0 :           break;
     761            4 :         case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
     762            4 :           pp_string (pp, "firstprivate");
     763            4 :           break;
     764           53 :         case OMP_CLAUSE_DEFAULT_PRESENT:
     765           53 :           pp_string (pp, "present");
     766           53 :           break;
     767            0 :         default:
     768            0 :           gcc_unreachable ();
     769              :         }
     770         1262 :       pp_right_paren (pp);
     771         1262 :       break;
     772              : 
     773          152 :     case OMP_CLAUSE_SCHEDULE:
     774          152 :       pp_string (pp, "schedule(");
     775          152 :       if (OMP_CLAUSE_SCHEDULE_KIND (clause)
     776              :           & (OMP_CLAUSE_SCHEDULE_MONOTONIC
     777              :              | OMP_CLAUSE_SCHEDULE_NONMONOTONIC))
     778              :         {
     779            0 :           if (OMP_CLAUSE_SCHEDULE_KIND (clause)
     780              :               & OMP_CLAUSE_SCHEDULE_MONOTONIC)
     781            0 :             pp_string (pp, "monotonic");
     782              :           else
     783            0 :             pp_string (pp, "nonmonotonic");
     784            0 :           if (OMP_CLAUSE_SCHEDULE_SIMD (clause))
     785            0 :             pp_comma (pp);
     786              :           else
     787            0 :             pp_colon (pp);
     788              :         }
     789          152 :       if (OMP_CLAUSE_SCHEDULE_SIMD (clause))
     790            0 :         pp_string (pp, "simd:");
     791              : 
     792          152 :       switch (OMP_CLAUSE_SCHEDULE_KIND (clause) & OMP_CLAUSE_SCHEDULE_MASK)
     793              :         {
     794          111 :         case OMP_CLAUSE_SCHEDULE_STATIC:
     795          111 :           pp_string (pp, "static");
     796          111 :           break;
     797            4 :         case OMP_CLAUSE_SCHEDULE_DYNAMIC:
     798            4 :           pp_string (pp, "dynamic");
     799            4 :           break;
     800           27 :         case OMP_CLAUSE_SCHEDULE_GUIDED:
     801           27 :           pp_string (pp, "guided");
     802           27 :           break;
     803            2 :         case OMP_CLAUSE_SCHEDULE_RUNTIME:
     804            2 :           pp_string (pp, "runtime");
     805            2 :           break;
     806            8 :         case OMP_CLAUSE_SCHEDULE_AUTO:
     807            8 :           pp_string (pp, "auto");
     808            8 :           break;
     809            0 :         default:
     810            0 :           gcc_unreachable ();
     811              :         }
     812          152 :       if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
     813              :         {
     814           16 :           pp_comma (pp);
     815           16 :           dump_generic_node (pp, OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
     816              :                              spc, flags, false);
     817              :         }
     818          152 :       pp_right_paren (pp);
     819          152 :       break;
     820              : 
     821            4 :     case OMP_CLAUSE_UNTIED:
     822            4 :       pp_string (pp, "untied");
     823            4 :       break;
     824              : 
     825          418 :     case OMP_CLAUSE_COLLAPSE:
     826          418 :       pp_string (pp, "collapse(");
     827          418 :       dump_generic_node (pp, OMP_CLAUSE_COLLAPSE_EXPR (clause),
     828              :                          spc, flags, false);
     829          418 :       pp_right_paren (pp);
     830          418 :       break;
     831              : 
     832            4 :     case OMP_CLAUSE_FINAL:
     833            4 :       pp_string (pp, "final(");
     834            4 :       dump_generic_node (pp, OMP_CLAUSE_FINAL_EXPR (clause),
     835              :                          spc, flags, false);
     836            4 :       pp_right_paren (pp);
     837            4 :       break;
     838              : 
     839            4 :     case OMP_CLAUSE_MERGEABLE:
     840            4 :       pp_string (pp, "mergeable");
     841            4 :       break;
     842              : 
     843           60 :     case OMP_CLAUSE_MESSAGE:
     844           60 :       if (OMP_CLAUSE_MESSAGE_EXPR (clause))
     845              :         {
     846           57 :           pp_string (pp, "message(");
     847           57 :           dump_generic_node (pp, OMP_CLAUSE_MESSAGE_EXPR (clause),
     848              :                              spc, flags, false);
     849           57 :           if (OMP_CLAUSE_MESSAGE_LEN (clause))
     850              :             {
     851           57 :               pp_string (pp, " [len:");
     852           57 :               dump_generic_node (pp, OMP_CLAUSE_MESSAGE_LEN (clause),
     853              :                                  spc, flags, false);
     854           57 :               pp_right_bracket (pp);
     855              :             }
     856           57 :           pp_right_paren (pp);
     857           57 :           pp_space (pp);
     858              :         }
     859           60 :       if (OMP_CLAUSE_MESSAGE_SEVERITY_WARN (clause))
     860           16 :         pp_string (pp, "severity(warning)");
     861              :       else
     862           44 :         pp_string (pp, "severity(fatal)");
     863              :       break;
     864              : 
     865         1911 :     case OMP_CLAUSE_LINEAR:
     866         1911 :       pp_string (pp, "linear(");
     867         1911 :       if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause))
     868            4 :         switch (OMP_CLAUSE_LINEAR_KIND (clause))
     869              :           {
     870              :           case OMP_CLAUSE_LINEAR_DEFAULT:
     871              :             break;
     872            4 :           case OMP_CLAUSE_LINEAR_REF:
     873            4 :             pp_string (pp, "ref(");
     874            4 :             break;
     875            0 :           case OMP_CLAUSE_LINEAR_VAL:
     876            0 :             pp_string (pp, "val(");
     877            0 :             break;
     878            0 :           case OMP_CLAUSE_LINEAR_UVAL:
     879            0 :             pp_string (pp, "uval(");
     880            0 :             break;
     881            0 :           default:
     882            0 :             gcc_unreachable ();
     883              :           }
     884         1911 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
     885              :                          spc, flags, false);
     886         1911 :       if (OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
     887         1911 :           && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
     888            4 :         pp_right_paren (pp);
     889         1911 :       pp_colon (pp);
     890         1911 :       if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
     891         1911 :           && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
     892           81 :         switch (OMP_CLAUSE_LINEAR_KIND (clause))
     893              :           {
     894           60 :             case OMP_CLAUSE_LINEAR_REF:
     895           60 :               pp_string (pp, "ref,step(");
     896           60 :               break;
     897           13 :             case OMP_CLAUSE_LINEAR_VAL:
     898           13 :               pp_string (pp, "val,step(");
     899           13 :               break;
     900            8 :             case OMP_CLAUSE_LINEAR_UVAL:
     901            8 :               pp_string (pp, "uval,step(");
     902            8 :               break;
     903            0 :             default:
     904            0 :               gcc_unreachable ();
     905              :           }
     906         1911 :       dump_generic_node (pp, OMP_CLAUSE_LINEAR_STEP (clause),
     907              :                          spc, flags, false);
     908         1911 :       if (!OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER (clause)
     909         1911 :           && OMP_CLAUSE_LINEAR_KIND (clause) != OMP_CLAUSE_LINEAR_DEFAULT)
     910           81 :         pp_right_paren (pp);
     911         1911 :       pp_right_paren (pp);
     912         1911 :       break;
     913              : 
     914          338 :     case OMP_CLAUSE_ALIGNED:
     915          338 :       pp_string (pp, "aligned(");
     916          338 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
     917              :                          spc, flags, false);
     918          338 :       if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause))
     919              :         {
     920          338 :           pp_colon (pp);
     921          338 :           dump_generic_node (pp, OMP_CLAUSE_ALIGNED_ALIGNMENT (clause),
     922              :                              spc, flags, false);
     923              :         }
     924          338 :       pp_right_paren (pp);
     925          338 :       break;
     926              : 
     927           89 :     case OMP_CLAUSE_ALLOCATE:
     928           89 :       pp_string (pp, "allocate(");
     929           89 :       if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause))
     930              :         {
     931           88 :           pp_string (pp, "allocator(");
     932           88 :           dump_generic_node (pp, OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause),
     933              :                              spc, flags, false);
     934           88 :           pp_right_paren (pp);
     935              :         }
     936           89 :       if (OMP_CLAUSE_ALLOCATE_ALIGN (clause))
     937              :         {
     938           57 :           if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause))
     939           56 :             pp_comma (pp);
     940           57 :           pp_string (pp, "align(");
     941           57 :           dump_generic_node (pp, OMP_CLAUSE_ALLOCATE_ALIGN (clause),
     942              :                              spc, flags, false);
     943           57 :           pp_right_paren (pp);
     944              :         }
     945           89 :       if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause)
     946           89 :           || OMP_CLAUSE_ALLOCATE_ALIGN (clause))
     947           89 :         pp_colon (pp);
     948           89 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
     949              :                          spc, flags, false);
     950           89 :       pp_right_paren (pp);
     951           89 :       break;
     952              : 
     953           98 :     case OMP_CLAUSE_USES_ALLOCATORS:
     954           98 :       pp_string (pp, "uses_allocators(memspace(");
     955           98 :       dump_generic_node (pp, OMP_CLAUSE_USES_ALLOCATORS_MEMSPACE (clause),
     956              :                          spc, flags, false);
     957           98 :       pp_string (pp, "), traits(");
     958           98 :       dump_generic_node (pp, OMP_CLAUSE_USES_ALLOCATORS_TRAITS (clause),
     959              :                          spc, flags, false);
     960           98 :       pp_string (pp, ") : ");
     961           98 :       dump_generic_node (pp, OMP_CLAUSE_USES_ALLOCATORS_ALLOCATOR (clause),
     962              :                          spc, flags, false);
     963           98 :       pp_right_paren (pp);
     964           98 :       break;
     965              : 
     966           68 :     case OMP_CLAUSE_AFFINITY:
     967           68 :       pp_string (pp, "affinity(");
     968           68 :       {
     969           68 :         tree t = OMP_CLAUSE_DECL (clause);
     970           68 :         if (OMP_ITERATOR_DECL_P (t))
     971              :           {
     972           18 :             dump_omp_iterators (pp, TREE_PURPOSE (t), spc, flags);
     973           18 :             pp_colon (pp);
     974           18 :             t = TREE_VALUE (t);
     975              :           }
     976           68 :         dump_generic_node (pp, t, spc, flags, false);
     977              :       }
     978           68 :       pp_right_paren (pp);
     979           68 :       break;
     980          176 :     case OMP_CLAUSE_DEPEND:
     981          176 :       pp_string (pp, "depend(");
     982          176 :       switch (OMP_CLAUSE_DEPEND_KIND (clause))
     983              :         {
     984              :         case OMP_CLAUSE_DEPEND_DEPOBJ:
     985              :           name = "depobj";
     986              :           break;
     987            5 :         case OMP_CLAUSE_DEPEND_IN:
     988            5 :           name = "in";
     989            5 :           break;
     990          123 :         case OMP_CLAUSE_DEPEND_OUT:
     991          123 :           name = "out";
     992          123 :           break;
     993           28 :         case OMP_CLAUSE_DEPEND_INOUT:
     994           28 :           name = "inout";
     995           28 :           break;
     996            0 :         case OMP_CLAUSE_DEPEND_MUTEXINOUTSET:
     997            0 :           name = "mutexinoutset";
     998            0 :           break;
     999            0 :         case OMP_CLAUSE_DEPEND_INOUTSET:
    1000            0 :           name = "inoutset";
    1001            0 :           break;
    1002            0 :         case OMP_CLAUSE_DEPEND_LAST:
    1003            0 :           name = "__internal__";
    1004            0 :           break;
    1005            0 :         default:
    1006            0 :           gcc_unreachable ();
    1007              :         }
    1008          176 :       {
    1009          176 :         tree t = OMP_CLAUSE_DECL (clause);
    1010          176 :         if (OMP_ITERATOR_DECL_P (t))
    1011              :           {
    1012            0 :             dump_omp_iterators (pp, TREE_PURPOSE (t), spc, flags);
    1013            0 :             pp_colon (pp);
    1014            0 :             t = TREE_VALUE (t);
    1015              :           }
    1016          176 :         if (name[0])
    1017              :           {
    1018          176 :             pp_string (pp, name);
    1019          176 :             pp_colon (pp);
    1020              :           }
    1021          176 :         if (t == null_pointer_node)
    1022            0 :           pp_string (pp, "omp_all_memory");
    1023              :         else
    1024          176 :           dump_generic_node (pp, t, spc, flags, false);
    1025          176 :         pp_right_paren (pp);
    1026              :       }
    1027          176 :       break;
    1028              : 
    1029           22 :     case OMP_CLAUSE_DOACROSS:
    1030           22 :       pp_string (pp, OMP_CLAUSE_DOACROSS_DEPEND (clause)
    1031              :                      ? "depend(" : "doacross(");
    1032           22 :       switch (OMP_CLAUSE_DOACROSS_KIND (clause))
    1033              :         {
    1034            9 :         case OMP_CLAUSE_DOACROSS_SOURCE:
    1035            9 :           if (OMP_CLAUSE_DOACROSS_DEPEND (clause))
    1036            9 :             pp_string (pp, "source)");
    1037              :           else
    1038            0 :             pp_string (pp, "source:)");
    1039              :           break;
    1040           13 :         case OMP_CLAUSE_DOACROSS_SINK:
    1041           13 :           pp_string (pp, "sink:");
    1042           13 :           if (OMP_CLAUSE_DECL (clause) == NULL_TREE)
    1043              :             {
    1044            0 :               pp_string (pp, "omp_cur_iteration-1)");
    1045            0 :               break;
    1046              :             }
    1047           34 :           for (tree t = OMP_CLAUSE_DECL (clause); t; t = TREE_CHAIN (t))
    1048           21 :             if (TREE_CODE (t) == TREE_LIST)
    1049              :               {
    1050           21 :                 dump_generic_node (pp, TREE_VALUE (t), spc, flags, false);
    1051           21 :                 if (TREE_PURPOSE (t) != integer_zero_node)
    1052              :                   {
    1053           19 :                     if (OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (t))
    1054            8 :                       pp_minus (pp);
    1055              :                     else
    1056           11 :                       pp_plus (pp);
    1057           19 :                     dump_generic_node (pp, TREE_PURPOSE (t), spc, flags,
    1058              :                                        false);
    1059              :                   }
    1060           21 :                 if (TREE_CHAIN (t))
    1061            8 :                   pp_comma (pp);
    1062              :               }
    1063              :             else
    1064            0 :               gcc_unreachable ();
    1065           13 :           pp_right_paren (pp);
    1066           13 :           break;
    1067            0 :         default:
    1068            0 :           gcc_unreachable ();
    1069              :         }
    1070              :       break;
    1071              : 
    1072         6537 :     case OMP_CLAUSE_MAP:
    1073         6537 :       pp_string (pp, "map(");
    1074         6537 :       if (OMP_CLAUSE_MAP_READONLY (clause))
    1075           70 :         pp_string (pp, "readonly,");
    1076         6537 :       if (OMP_CLAUSE_ITERATORS (clause))
    1077              :         {
    1078           84 :           dump_omp_iterators (pp, OMP_CLAUSE_ITERATORS (clause), spc, flags);
    1079           84 :           pp_colon (pp);
    1080              :         }
    1081         6537 :       switch (OMP_CLAUSE_MAP_KIND (clause))
    1082              :         {
    1083         1007 :         case GOMP_MAP_ALLOC:
    1084         1007 :         case GOMP_MAP_POINTER:
    1085         1007 :         case GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION:
    1086         1007 :           pp_string (pp, "alloc");
    1087         1007 :           break;
    1088            4 :         case GOMP_MAP_IF_PRESENT:
    1089            4 :           pp_string (pp, "no_alloc");
    1090            4 :           break;
    1091          825 :         case GOMP_MAP_TO:
    1092          825 :         case GOMP_MAP_TO_PSET:
    1093          825 :           pp_string (pp, "to");
    1094          825 :           break;
    1095          602 :         case GOMP_MAP_FROM:
    1096          602 :           pp_string (pp, "from");
    1097          602 :           break;
    1098         2249 :         case GOMP_MAP_TOFROM:
    1099         2249 :           pp_string (pp, "tofrom");
    1100         2249 :           break;
    1101            3 :         case GOMP_MAP_FORCE_ALLOC:
    1102            3 :           pp_string (pp, "force_alloc");
    1103            3 :           break;
    1104           17 :         case GOMP_MAP_FORCE_TO:
    1105           17 :           pp_string (pp, "force_to");
    1106           17 :           break;
    1107           26 :         case GOMP_MAP_FORCE_FROM:
    1108           26 :           pp_string (pp, "force_from");
    1109           26 :           break;
    1110           61 :         case GOMP_MAP_FORCE_TOFROM:
    1111           61 :           pp_string (pp, "force_tofrom");
    1112           61 :           break;
    1113          229 :         case GOMP_MAP_FORCE_PRESENT:
    1114          229 :           pp_string (pp, "force_present");
    1115          229 :           break;
    1116           83 :         case GOMP_MAP_DELETE:
    1117           83 :           pp_string (pp, "delete");
    1118           83 :           break;
    1119            8 :         case GOMP_MAP_FORCE_DEVICEPTR:
    1120            8 :           pp_string (pp, "force_deviceptr");
    1121            8 :           break;
    1122          158 :         case GOMP_MAP_ALWAYS_TO:
    1123          158 :           pp_string (pp, "always,to");
    1124          158 :           break;
    1125           40 :         case GOMP_MAP_ALWAYS_FROM:
    1126           40 :           pp_string (pp, "always,from");
    1127           40 :           break;
    1128           14 :         case GOMP_MAP_ALWAYS_TOFROM:
    1129           14 :           pp_string (pp, "always,tofrom");
    1130           14 :           break;
    1131          190 :         case GOMP_MAP_RELEASE:
    1132          190 :           pp_string (pp, "release");
    1133          190 :           break;
    1134          347 :         case GOMP_MAP_FIRSTPRIVATE_POINTER:
    1135          347 :           pp_string (pp, "firstprivate");
    1136          347 :           break;
    1137            0 :         case GOMP_MAP_FIRSTPRIVATE_REFERENCE:
    1138            0 :           pp_string (pp, "firstprivate ref");
    1139            0 :           break;
    1140          151 :         case GOMP_MAP_STRUCT:
    1141          151 :           pp_string (pp, "struct");
    1142          151 :           break;
    1143            3 :         case GOMP_MAP_STRUCT_UNORD:
    1144            3 :           pp_string (pp, "struct_unord");
    1145            3 :           break;
    1146           67 :         case GOMP_MAP_ALWAYS_POINTER:
    1147           67 :           pp_string (pp, "always_pointer");
    1148           67 :           break;
    1149            0 :         case GOMP_MAP_DEVICE_RESIDENT:
    1150            0 :           pp_string (pp, "device_resident");
    1151            0 :           break;
    1152            0 :         case GOMP_MAP_LINK:
    1153            0 :           pp_string (pp, "link");
    1154            0 :           break;
    1155          162 :         case GOMP_MAP_ATTACH:
    1156          162 :           pp_string (pp, "attach");
    1157          162 :           break;
    1158           42 :         case GOMP_MAP_DETACH:
    1159           42 :           pp_string (pp, "detach");
    1160           42 :           break;
    1161            8 :         case GOMP_MAP_FORCE_DETACH:
    1162            8 :           pp_string (pp, "force_detach");
    1163            8 :           break;
    1164           46 :         case GOMP_MAP_ATTACH_DETACH:
    1165           46 :           pp_string (pp, "attach_detach");
    1166           46 :           break;
    1167            8 :         case GOMP_MAP_ATTACH_ZERO_LENGTH_ARRAY_SECTION:
    1168            8 :           pp_string (pp, "attach_zero_length_array_section");
    1169            8 :           break;
    1170           29 :         case GOMP_MAP_PRESENT_ALLOC:
    1171           29 :           pp_string (pp, "present,alloc");
    1172           29 :           break;
    1173           29 :         case GOMP_MAP_PRESENT_TO:
    1174           29 :           pp_string (pp, "present,to");
    1175           29 :           break;
    1176           16 :         case GOMP_MAP_PRESENT_FROM:
    1177           16 :           pp_string (pp, "present,from");
    1178           16 :           break;
    1179           15 :         case GOMP_MAP_PRESENT_TOFROM:
    1180           15 :           pp_string (pp, "present,tofrom");
    1181           15 :           break;
    1182           40 :         case GOMP_MAP_ALWAYS_PRESENT_TO:
    1183           40 :           pp_string (pp, "always,present,to");
    1184           40 :           break;
    1185           30 :         case GOMP_MAP_ALWAYS_PRESENT_FROM:
    1186           30 :           pp_string (pp, "always,present,from");
    1187           30 :           break;
    1188           12 :         case GOMP_MAP_ALWAYS_PRESENT_TOFROM:
    1189           12 :           pp_string (pp, "always,present,tofrom");
    1190           12 :           break;
    1191           16 :         case GOMP_MAP_UNSET:
    1192           16 :           pp_string (pp, "unset");
    1193           16 :           break;
    1194            0 :         case GOMP_MAP_PUSH_MAPPER_NAME:
    1195            0 :           pp_string (pp, "push_mapper");
    1196            0 :           break;
    1197            0 :         case GOMP_MAP_POP_MAPPER_NAME:
    1198            0 :           pp_string (pp, "pop_mapper");
    1199            0 :           break;
    1200            0 :         case GOMP_MAP_USES_ALLOCATORS:
    1201            0 :           pp_string (pp, "uses_allocators");
    1202            0 :           break;
    1203            0 :         default:
    1204            0 :           gcc_unreachable ();
    1205              :         }
    1206         6537 :       pp_colon (pp);
    1207         6537 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
    1208              :                          spc, flags, false);
    1209         6795 :      print_clause_size:
    1210         6795 :       if (OMP_CLAUSE_SIZE (clause))
    1211              :         {
    1212        11423 :           switch (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
    1213         5782 :                   ? OMP_CLAUSE_MAP_KIND (clause) : GOMP_MAP_TO)
    1214              :             {
    1215          999 :             case GOMP_MAP_POINTER:
    1216          999 :             case GOMP_MAP_FIRSTPRIVATE_POINTER:
    1217          999 :             case GOMP_MAP_FIRSTPRIVATE_REFERENCE:
    1218          999 :             case GOMP_MAP_ALWAYS_POINTER:
    1219          999 :               pp_string (pp, " [pointer assign, bias: ");
    1220          999 :               break;
    1221            4 :             case GOMP_MAP_POINTER_TO_ZERO_LENGTH_ARRAY_SECTION:
    1222            4 :               pp_string (pp, " [pointer assign, zero-length array section, bias: ");
    1223            4 :               break;
    1224          141 :             case GOMP_MAP_TO_PSET:
    1225          141 :               pp_string (pp, " [pointer set, len: ");
    1226          141 :               break;
    1227          266 :             case GOMP_MAP_ATTACH:
    1228          266 :             case GOMP_MAP_DETACH:
    1229          266 :             case GOMP_MAP_FORCE_DETACH:
    1230          266 :             case GOMP_MAP_ATTACH_DETACH:
    1231          266 :             case GOMP_MAP_ATTACH_ZERO_LENGTH_ARRAY_SECTION:
    1232          266 :               pp_string (pp, " [bias: ");
    1233          266 :               break;
    1234          179 :             case GOMP_MAP_RELEASE:
    1235          179 :             case GOMP_MAP_DELETE:
    1236          179 :               if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
    1237          179 :                   && OMP_CLAUSE_RELEASE_DESCRIPTOR (clause))
    1238              :                 {
    1239           25 :                   pp_string (pp, " [pointer set, len: ");
    1240           25 :                   break;
    1241              :                 }
    1242              :               /* Fallthrough.  */
    1243         4347 :             default:
    1244         4347 :               pp_string (pp, " [len: ");
    1245         4347 :               break;
    1246              :             }
    1247         5782 :           dump_generic_node (pp, OMP_CLAUSE_SIZE (clause),
    1248              :                              spc, flags, false);
    1249         5782 :           if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
    1250         5782 :               && OMP_CLAUSE_MAP_SIZE_NEEDS_ADJUSTMENT (clause))
    1251            2 :             pp_string (pp, " (needs adjustment)");
    1252         5782 :           pp_right_bracket (pp);
    1253              :         }
    1254         6795 :       if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP)
    1255              :         {
    1256         6537 :           if (OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P (clause))
    1257          841 :             pp_string (pp, " [runtime_implicit]");
    1258         6537 :           if (OMP_CLAUSE_MAP_GIMPLE_ONLY (clause))
    1259            1 :             pp_string (pp, " [gimple only]");
    1260              :         }
    1261         6795 :       pp_right_paren (pp);
    1262         6795 :       break;
    1263              : 
    1264           91 :     case OMP_CLAUSE_FROM:
    1265           91 :       pp_string (pp, "from(");
    1266           91 :       if (OMP_CLAUSE_MOTION_PRESENT (clause))
    1267           37 :         pp_string (pp, "present:");
    1268           91 :       if (OMP_CLAUSE_ITERATORS (clause))
    1269              :         {
    1270           10 :           dump_omp_iterators (pp, OMP_CLAUSE_ITERATORS (clause), spc, flags);
    1271           10 :           pp_colon (pp);
    1272              :         }
    1273           91 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
    1274              :                          spc, flags, false);
    1275           91 :       goto print_clause_size;
    1276              : 
    1277          111 :     case OMP_CLAUSE_TO:
    1278          111 :       pp_string (pp, "to(");
    1279          111 :       if (OMP_CLAUSE_MOTION_PRESENT (clause))
    1280           37 :         pp_string (pp, "present:");
    1281          111 :       if (OMP_CLAUSE_ITERATORS (clause))
    1282              :         {
    1283           25 :           dump_omp_iterators (pp, OMP_CLAUSE_ITERATORS (clause), spc, flags);
    1284           25 :           pp_colon (pp);
    1285              :         }
    1286          111 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
    1287              :                          spc, flags, false);
    1288          111 :       goto print_clause_size;
    1289              : 
    1290           56 :     case OMP_CLAUSE__CACHE_:
    1291           56 :       pp_string (pp, "(");
    1292           56 :       if (OMP_CLAUSE__CACHE__READONLY (clause))
    1293           32 :         pp_string (pp, "readonly:");
    1294           56 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause),
    1295              :                          spc, flags, false);
    1296           56 :       goto print_clause_size;
    1297              : 
    1298           24 :     case OMP_CLAUSE__MAPPER_BINDING_:
    1299           24 :       pp_string (pp, "mapper_binding(");
    1300           24 :       if (OMP_CLAUSE__MAPPER_BINDING__ID (clause))
    1301              :         {
    1302            0 :           dump_generic_node (pp, OMP_CLAUSE__MAPPER_BINDING__ID (clause), spc,
    1303              :                              flags, false);
    1304            0 :           pp_comma (pp);
    1305              :         }
    1306           24 :       dump_generic_node (pp,
    1307           24 :                          TREE_TYPE (OMP_CLAUSE__MAPPER_BINDING__DECL (clause)),
    1308              :                          spc, flags, false);
    1309           24 :       pp_comma (pp);
    1310           24 :       dump_generic_node (pp, OMP_CLAUSE__MAPPER_BINDING__MAPPER (clause), spc,
    1311              :                          flags, false);
    1312           24 :       pp_right_paren (pp);
    1313           24 :       break;
    1314              : 
    1315         1250 :     case OMP_CLAUSE_NUM_TEAMS:
    1316         1250 :       pp_string (pp, "num_teams(");
    1317         1250 :       if (OMP_CLAUSE_NUM_TEAMS_DIMS (clause))
    1318           35 :         pp_string (pp, "dims():");
    1319         1250 :       if (OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (clause))
    1320              :         {
    1321           19 :           dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR (clause),
    1322              :                              spc, flags, false);
    1323           19 :           pp_colon (pp);
    1324              :         }
    1325         1250 :       dump_generic_node (pp, OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR (clause),
    1326              :                          spc, flags, false);
    1327         1250 :       pp_right_paren (pp);
    1328         1250 :       break;
    1329              : 
    1330         1261 :     case OMP_CLAUSE_THREAD_LIMIT:
    1331         1261 :       pp_string (pp, "thread_limit(");
    1332         1261 :       if (OMP_CLAUSE_THREAD_LIMIT_STRICT (clause))
    1333           29 :         pp_string (pp, "strict");
    1334         1261 :       if (OMP_CLAUSE_THREAD_LIMIT_STRICT (clause)
    1335         1261 :           && OMP_CLAUSE_THREAD_LIMIT_DIMS (clause))
    1336           12 :         pp_comma (pp);
    1337         1261 :       if (OMP_CLAUSE_THREAD_LIMIT_DIMS (clause))
    1338           18 :         pp_string (pp, "dims()");
    1339         1261 :       if (OMP_CLAUSE_THREAD_LIMIT_STRICT (clause)
    1340         1261 :           || OMP_CLAUSE_THREAD_LIMIT_DIMS (clause))
    1341           35 :         pp_colon (pp);
    1342         1261 :       dump_generic_node (pp, OMP_CLAUSE_THREAD_LIMIT_EXPR (clause),
    1343              :                          spc, flags, false);
    1344         1261 :       pp_right_paren (pp);
    1345         1261 :       break;
    1346              : 
    1347           67 :     case OMP_CLAUSE_DEVICE:
    1348           67 :       pp_string (pp, "device(");
    1349           67 :       if (OMP_CLAUSE_DEVICE_ANCESTOR (clause))
    1350           13 :         pp_string (pp, "ancestor:");
    1351           67 :       dump_generic_node (pp, OMP_CLAUSE_DEVICE_ID (clause),
    1352              :                          spc, flags, false);
    1353           67 :       pp_right_paren (pp);
    1354           67 :       break;
    1355              : 
    1356            0 :     case OMP_CLAUSE_DIST_SCHEDULE:
    1357            0 :       pp_string (pp, "dist_schedule(static");
    1358            0 :       if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause))
    1359              :         {
    1360            0 :           pp_comma (pp);
    1361            0 :           dump_generic_node (pp,
    1362            0 :                              OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause),
    1363              :                              spc, flags, false);
    1364              :         }
    1365            0 :       pp_right_paren (pp);
    1366            0 :       break;
    1367              : 
    1368            4 :     case OMP_CLAUSE_PROC_BIND:
    1369            4 :       pp_string (pp, "proc_bind(");
    1370            4 :       switch (OMP_CLAUSE_PROC_BIND_KIND (clause))
    1371              :         {
    1372            0 :         case OMP_CLAUSE_PROC_BIND_MASTER:
    1373              :           /* Same enum value: case OMP_CLAUSE_PROC_BIND_PRIMARY: */
    1374              :           /* TODO: Change to 'primary' for OpenMP 5.1.  */
    1375            0 :           pp_string (pp, "master");
    1376            0 :           break;
    1377            0 :         case OMP_CLAUSE_PROC_BIND_CLOSE:
    1378            0 :           pp_string (pp, "close");
    1379            0 :           break;
    1380            4 :         case OMP_CLAUSE_PROC_BIND_SPREAD:
    1381            4 :           pp_string (pp, "spread");
    1382            4 :           break;
    1383            0 :         default:
    1384            0 :           gcc_unreachable ();
    1385              :         }
    1386            4 :       pp_right_paren (pp);
    1387            4 :       break;
    1388              : 
    1389           16 :     case OMP_CLAUSE_DEVICE_TYPE:
    1390           16 :       pp_string (pp, "device_type(");
    1391           16 :       switch (OMP_CLAUSE_DEVICE_TYPE_KIND (clause))
    1392              :         {
    1393            5 :         case OMP_CLAUSE_DEVICE_TYPE_HOST:
    1394            5 :           pp_string (pp, "host");
    1395            5 :           break;
    1396            6 :         case OMP_CLAUSE_DEVICE_TYPE_NOHOST:
    1397            6 :           pp_string (pp, "nohost");
    1398            6 :           break;
    1399            5 :         case OMP_CLAUSE_DEVICE_TYPE_ANY:
    1400            5 :           pp_string (pp, "any");
    1401            5 :           break;
    1402            0 :         default:
    1403            0 :           gcc_unreachable ();
    1404              :         }
    1405           16 :       pp_right_paren (pp);
    1406           16 :       break;
    1407              : 
    1408           58 :     case OMP_CLAUSE_DYN_GROUPPRIVATE:
    1409           58 :       pp_string (pp, "dyn_groupprivate(");
    1410           58 :       switch (OMP_CLAUSE_DYN_GROUPPRIVATE_KIND (clause))
    1411              :         {
    1412            9 :         case OMP_CLAUSE_FALLBACK_ABORT:
    1413            9 :           pp_string (pp, "fallback(abort):");
    1414            9 :           break;
    1415           11 :         case OMP_CLAUSE_FALLBACK_DEFAULT_MEM:
    1416           11 :           pp_string (pp, "fallback(default_mem):");
    1417           11 :           break;
    1418           16 :         case OMP_CLAUSE_FALLBACK_NULL:
    1419           16 :           pp_string (pp, "fallback(null):");
    1420           16 :           break;
    1421              :         case OMP_CLAUSE_FALLBACK_UNSPECIFIED:
    1422              :           break;
    1423              :         }
    1424           58 :       dump_generic_node (pp, OMP_CLAUSE_DYN_GROUPPRIVATE_EXPR (clause),
    1425              :                          spc, flags, false);
    1426           58 :       pp_right_paren (pp);
    1427           58 :       break;
    1428              : 
    1429           23 :     case OMP_CLAUSE_SAFELEN:
    1430           23 :       pp_string (pp, "safelen(");
    1431           23 :       dump_generic_node (pp, OMP_CLAUSE_SAFELEN_EXPR (clause),
    1432              :                          spc, flags, false);
    1433           23 :       pp_right_paren (pp);
    1434           23 :       break;
    1435              : 
    1436          506 :     case OMP_CLAUSE_SIMDLEN:
    1437          506 :       pp_string (pp, "simdlen(");
    1438          506 :       if (OMP_CLAUSE_SIMDLEN_TYPE (clause))
    1439              :         {
    1440           64 :           pp_string (pp, "scaled(");
    1441           64 :           dump_generic_node (pp, OMP_CLAUSE_SIMDLEN_TYPE (clause),
    1442              :                              spc, flags, false);
    1443           64 :           if (OMP_CLAUSE_SIMDLEN_DIVISOR (clause))
    1444              :             {
    1445           43 :               pp_comma (pp);
    1446           43 :               dump_generic_node (pp, OMP_CLAUSE_SIMDLEN_DIVISOR (clause),
    1447              :                                  spc, flags, false);
    1448              :             }
    1449           64 :           pp_right_paren (pp);
    1450           64 :           pp_colon (pp);
    1451              :         }
    1452          506 :       dump_generic_node (pp, OMP_CLAUSE_SIMDLEN_EXPR (clause),
    1453              :                          spc, flags, false);
    1454          506 :       pp_right_paren (pp);
    1455          506 :       break;
    1456              : 
    1457            4 :     case OMP_CLAUSE_PRIORITY:
    1458            4 :       pp_string (pp, "priority(");
    1459            4 :       dump_generic_node (pp, OMP_CLAUSE_PRIORITY_EXPR (clause),
    1460              :                          spc, flags, false);
    1461            4 :       pp_right_paren (pp);
    1462            4 :       break;
    1463              : 
    1464           10 :     case OMP_CLAUSE_GRAINSIZE:
    1465           10 :       pp_string (pp, "grainsize(");
    1466           10 :       if (OMP_CLAUSE_GRAINSIZE_STRICT (clause))
    1467            0 :         pp_string (pp, "strict:");
    1468           10 :       dump_generic_node (pp, OMP_CLAUSE_GRAINSIZE_EXPR (clause),
    1469              :                          spc, flags, false);
    1470           10 :       pp_right_paren (pp);
    1471           10 :       break;
    1472              : 
    1473            0 :     case OMP_CLAUSE_NUM_TASKS:
    1474            0 :       pp_string (pp, "num_tasks(");
    1475            0 :       if (OMP_CLAUSE_NUM_TASKS_STRICT (clause))
    1476            0 :         pp_string (pp, "strict:");
    1477            0 :       dump_generic_node (pp, OMP_CLAUSE_NUM_TASKS_EXPR (clause),
    1478              :                          spc, flags, false);
    1479            0 :       pp_right_paren (pp);
    1480            0 :       break;
    1481              : 
    1482           24 :     case OMP_CLAUSE_HINT:
    1483           24 :       pp_string (pp, "hint(");
    1484           24 :       dump_generic_node (pp, OMP_CLAUSE_HINT_EXPR (clause),
    1485              :                          spc, flags, false);
    1486           24 :       pp_right_paren (pp);
    1487           24 :       break;
    1488              : 
    1489           43 :     case OMP_CLAUSE_FILTER:
    1490           43 :       pp_string (pp, "filter(");
    1491           43 :       dump_generic_node (pp, OMP_CLAUSE_FILTER_EXPR (clause),
    1492              :                          spc, flags, false);
    1493           43 :       pp_right_paren (pp);
    1494           43 :       break;
    1495              : 
    1496          597 :     case OMP_CLAUSE_DEFAULTMAP:
    1497          597 :       pp_string (pp, "defaultmap(");
    1498          597 :       switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (clause))
    1499              :         {
    1500           12 :         case OMP_CLAUSE_DEFAULTMAP_ALLOC:
    1501           12 :           pp_string (pp, "alloc");
    1502           12 :           break;
    1503           13 :         case OMP_CLAUSE_DEFAULTMAP_TO:
    1504           13 :           pp_string (pp, "to");
    1505           13 :           break;
    1506            4 :         case OMP_CLAUSE_DEFAULTMAP_FROM:
    1507            4 :           pp_string (pp, "from");
    1508            4 :           break;
    1509           39 :         case OMP_CLAUSE_DEFAULTMAP_TOFROM:
    1510           39 :           pp_string (pp, "tofrom");
    1511           39 :           break;
    1512           58 :         case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE:
    1513           58 :           pp_string (pp, "firstprivate");
    1514           58 :           break;
    1515          446 :         case OMP_CLAUSE_DEFAULTMAP_NONE:
    1516          446 :           pp_string (pp, "none");
    1517          446 :           break;
    1518           11 :         case OMP_CLAUSE_DEFAULTMAP_PRESENT:
    1519           11 :           pp_string (pp, "present");
    1520           11 :           break;
    1521           14 :         case OMP_CLAUSE_DEFAULTMAP_DEFAULT:
    1522           14 :           pp_string (pp, "default");
    1523           14 :           break;
    1524            0 :         default:
    1525            0 :           gcc_unreachable ();
    1526              :         }
    1527          597 :       switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (clause))
    1528              :         {
    1529              :         case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED:
    1530              :           break;
    1531           20 :         case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL:
    1532           20 :           pp_string (pp, ":all");
    1533           20 :           break;
    1534           44 :         case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR:
    1535           44 :           pp_string (pp, ":scalar");
    1536           44 :           break;
    1537           49 :         case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE:
    1538           49 :           pp_string (pp, ":aggregate");
    1539           49 :           break;
    1540           12 :         case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE:
    1541           12 :           pp_string (pp, ":allocatable");
    1542           12 :           break;
    1543           33 :         case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER:
    1544           33 :           pp_string (pp, ":pointer");
    1545           33 :           break;
    1546            0 :         default:
    1547            0 :           gcc_unreachable ();
    1548              :         }
    1549          597 :       pp_right_paren (pp);
    1550          597 :       break;
    1551              : 
    1552          303 :     case OMP_CLAUSE_ORDER:
    1553          303 :       pp_string (pp, "order(");
    1554          303 :       if (OMP_CLAUSE_ORDER_UNCONSTRAINED (clause))
    1555           20 :         pp_string (pp, "unconstrained:");
    1556          283 :       else if (OMP_CLAUSE_ORDER_REPRODUCIBLE (clause))
    1557           20 :         pp_string (pp, "reproducible:");
    1558          303 :       pp_string (pp, "concurrent)");
    1559          303 :       break;
    1560              : 
    1561          261 :     case OMP_CLAUSE_BIND:
    1562          261 :       pp_string (pp, "bind(");
    1563          261 :       switch (OMP_CLAUSE_BIND_KIND (clause))
    1564              :         {
    1565          143 :         case OMP_CLAUSE_BIND_TEAMS:
    1566          143 :           pp_string (pp, "teams");
    1567          143 :           break;
    1568           97 :         case OMP_CLAUSE_BIND_PARALLEL:
    1569           97 :           pp_string (pp, "parallel");
    1570           97 :           break;
    1571           21 :         case OMP_CLAUSE_BIND_THREAD:
    1572           21 :           pp_string (pp, "thread");
    1573           21 :           break;
    1574            0 :         default:
    1575            0 :           gcc_unreachable ();
    1576              :         }
    1577          261 :       pp_right_paren (pp);
    1578          261 :       break;
    1579              : 
    1580            8 :     case OMP_CLAUSE__SIMDUID_:
    1581            8 :       pp_string (pp, "_simduid_(");
    1582            8 :       dump_generic_node (pp, OMP_CLAUSE__SIMDUID__DECL (clause),
    1583              :                          spc, flags, false);
    1584            8 :       pp_right_paren (pp);
    1585            8 :       break;
    1586              : 
    1587            0 :     case OMP_CLAUSE__SIMT_:
    1588            0 :       pp_string (pp, "_simt_");
    1589            0 :       break;
    1590              : 
    1591          349 :     case OMP_CLAUSE_GANG:
    1592          349 :       pp_string (pp, "gang");
    1593          349 :       if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE)
    1594              :         {
    1595           64 :           pp_string (pp, "(num: ");
    1596           64 :           dump_generic_node (pp, OMP_CLAUSE_GANG_EXPR (clause),
    1597              :                              spc, flags, false);
    1598              :         }
    1599          349 :       if (OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE)
    1600              :         {
    1601           12 :           if (OMP_CLAUSE_GANG_EXPR (clause) == NULL_TREE)
    1602           10 :             pp_left_paren (pp);
    1603              :           else
    1604            2 :             pp_space (pp);
    1605           12 :           pp_string (pp, "static:");
    1606           12 :           if (OMP_CLAUSE_GANG_STATIC_EXPR (clause)
    1607           12 :               == integer_minus_one_node)
    1608            3 :             pp_character (pp, '*');
    1609              :           else
    1610            9 :             dump_generic_node (pp, OMP_CLAUSE_GANG_STATIC_EXPR (clause),
    1611              :                                spc, flags, false);
    1612              :         }
    1613          349 :       if (OMP_CLAUSE_GANG_EXPR (clause) != NULL_TREE
    1614          349 :           || OMP_CLAUSE_GANG_STATIC_EXPR (clause) != NULL_TREE)
    1615           74 :         pp_right_paren (pp);
    1616              :       break;
    1617              : 
    1618           97 :     case OMP_CLAUSE_ASYNC:
    1619           97 :       pp_string (pp, "async");
    1620           97 :       if (OMP_CLAUSE_ASYNC_EXPR (clause))
    1621              :         {
    1622           97 :           pp_character(pp, '(');
    1623           97 :           dump_generic_node (pp, OMP_CLAUSE_ASYNC_EXPR (clause),
    1624              :                              spc, flags, false);
    1625           97 :           pp_character(pp, ')');
    1626              :         }
    1627              :       break;
    1628              : 
    1629           58 :     case OMP_CLAUSE_AUTO:
    1630           58 :     case OMP_CLAUSE_SEQ:
    1631           58 :       pp_string (pp, omp_clause_code_name[OMP_CLAUSE_CODE (clause)]);
    1632           58 :       break;
    1633              : 
    1634          100 :     case OMP_CLAUSE_WAIT:
    1635          100 :       pp_string (pp, "wait(");
    1636          100 :       dump_generic_node (pp, OMP_CLAUSE_WAIT_EXPR (clause),
    1637              :                          spc, flags, false);
    1638          100 :       pp_character(pp, ')');
    1639          100 :       break;
    1640              : 
    1641          192 :     case OMP_CLAUSE_WORKER:
    1642          192 :       pp_string (pp, "worker");
    1643          192 :       if (OMP_CLAUSE_WORKER_EXPR (clause) != NULL_TREE)
    1644              :         {
    1645           62 :           pp_left_paren (pp);
    1646           62 :           dump_generic_node (pp, OMP_CLAUSE_WORKER_EXPR (clause),
    1647              :                              spc, flags, false);
    1648           62 :           pp_right_paren (pp);
    1649              :         }
    1650              :       break;
    1651              : 
    1652          179 :     case OMP_CLAUSE_VECTOR:
    1653          179 :       pp_string (pp, "vector");
    1654          179 :       if (OMP_CLAUSE_VECTOR_EXPR (clause) != NULL_TREE)
    1655              :         {
    1656           62 :           pp_left_paren (pp);
    1657           62 :           dump_generic_node (pp, OMP_CLAUSE_VECTOR_EXPR (clause),
    1658              :                              spc, flags, false);
    1659           62 :           pp_right_paren (pp);
    1660              :         }
    1661              :       break;
    1662              : 
    1663           25 :     case OMP_CLAUSE_NUM_GANGS:
    1664           25 :       pp_string (pp, "num_gangs(");
    1665           25 :       dump_generic_node (pp, OMP_CLAUSE_NUM_GANGS_EXPR (clause),
    1666              :                          spc, flags, false);
    1667           25 :       pp_character (pp, ')');
    1668           25 :       break;
    1669              : 
    1670            2 :     case OMP_CLAUSE_NUM_WORKERS:
    1671            2 :       pp_string (pp, "num_workers(");
    1672            2 :       dump_generic_node (pp, OMP_CLAUSE_NUM_WORKERS_EXPR (clause),
    1673              :                          spc, flags, false);
    1674            2 :       pp_character (pp, ')');
    1675            2 :       break;
    1676              : 
    1677            2 :     case OMP_CLAUSE_VECTOR_LENGTH:
    1678            2 :       pp_string (pp, "vector_length(");
    1679            2 :       dump_generic_node (pp, OMP_CLAUSE_VECTOR_LENGTH_EXPR (clause),
    1680              :                          spc, flags, false);
    1681            2 :       pp_character (pp, ')');
    1682            2 :       break;
    1683              : 
    1684          175 :     case OMP_CLAUSE_INBRANCH:
    1685          175 :       pp_string (pp, "inbranch");
    1686          175 :       break;
    1687          925 :     case OMP_CLAUSE_NOTINBRANCH:
    1688          925 :       pp_string (pp, "notinbranch");
    1689          925 :       break;
    1690            0 :     case OMP_CLAUSE_FOR:
    1691            0 :       pp_string (pp, "for");
    1692            0 :       break;
    1693            0 :     case OMP_CLAUSE_PARALLEL:
    1694            0 :       pp_string (pp, "parallel");
    1695            0 :       break;
    1696            0 :     case OMP_CLAUSE_SECTIONS:
    1697            0 :       pp_string (pp, "sections");
    1698            0 :       break;
    1699            0 :     case OMP_CLAUSE_TASKGROUP:
    1700            0 :       pp_string (pp, "taskgroup");
    1701            0 :       break;
    1702            0 :     case OMP_CLAUSE_NOGROUP:
    1703            0 :       pp_string (pp, "nogroup");
    1704            0 :       break;
    1705            0 :     case OMP_CLAUSE_THREADS:
    1706            0 :       pp_string (pp, "threads");
    1707            0 :       break;
    1708           10 :     case OMP_CLAUSE_SIMD:
    1709           10 :       pp_string (pp, "simd");
    1710           10 :       break;
    1711          431 :     case OMP_CLAUSE_INDEPENDENT:
    1712          431 :       pp_string (pp, "independent");
    1713          431 :       break;
    1714           55 :     case OMP_CLAUSE_TILE:
    1715           55 :       pp_string (pp, "tile(");
    1716           55 :       dump_generic_node (pp, OMP_CLAUSE_TILE_LIST (clause),
    1717              :                          spc, flags, false);
    1718           55 :       pp_right_paren (pp);
    1719           55 :       break;
    1720          135 :     case OMP_CLAUSE_PARTIAL:
    1721          135 :       pp_string (pp, "partial");
    1722          135 :       if (OMP_CLAUSE_PARTIAL_EXPR (clause))
    1723              :         {
    1724          130 :           pp_left_paren (pp);
    1725          130 :           dump_generic_node (pp, OMP_CLAUSE_PARTIAL_EXPR (clause),
    1726              :                              spc, flags, false);
    1727          130 :           pp_right_paren (pp);
    1728              :         }
    1729              :       break;
    1730           55 :     case OMP_CLAUSE_FULL:
    1731           55 :       pp_string (pp, "full");
    1732           55 :       break;
    1733          188 :     case OMP_CLAUSE_SIZES:
    1734          188 :       pp_string (pp, "sizes(");
    1735          188 :       dump_generic_node (pp, OMP_CLAUSE_SIZES_LIST (clause),
    1736              :                          spc, flags, false);
    1737          188 :       pp_right_paren (pp);
    1738          188 :       break;
    1739          351 :     case OMP_CLAUSE_INTEROP:
    1740          351 :       pp_string (pp, "interop(");
    1741          351 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause), spc, flags, false);
    1742          351 :       pp_right_paren (pp);
    1743          351 :       break;
    1744           58 :     case OMP_CLAUSE_IF_PRESENT:
    1745           58 :       pp_string (pp, "if_present");
    1746           58 :       break;
    1747           50 :     case OMP_CLAUSE_FINALIZE:
    1748           50 :       pp_string (pp, "finalize");
    1749           50 :       break;
    1750            5 :     case OMP_CLAUSE_NOHOST:
    1751            5 :       pp_string (pp, "nohost");
    1752            5 :       break;
    1753            0 :     case OMP_CLAUSE_DETACH:
    1754            0 :       pp_string (pp, "detach(");
    1755            0 :       dump_generic_node (pp, OMP_CLAUSE_DECL (clause), spc, flags,
    1756              :                          false);
    1757            0 :       pp_right_paren (pp);
    1758            0 :       break;
    1759            0 :     default:
    1760            0 :       gcc_unreachable ();
    1761              :     }
    1762        30503 : }
    1763              : 
    1764              : 
    1765              : /* Dump chain of OMP clauses.
    1766              : 
    1767              :    PP, SPC and FLAGS are as in dump_generic_node.  */
    1768              : 
    1769              : void
    1770        13236 : dump_omp_clauses (pretty_printer *pp, tree clause, int spc, dump_flags_t flags,
    1771              :                   bool leading_space)
    1772              : {
    1773        43716 :   while (clause)
    1774              :     {
    1775        30480 :       if (leading_space)
    1776        28890 :         pp_space (pp);
    1777        30480 :       dump_omp_clause (pp, clause, spc, flags);
    1778        30480 :       leading_space = true;
    1779              : 
    1780        30480 :       clause = OMP_CLAUSE_CHAIN (clause);
    1781              :     }
    1782        13236 : }
    1783              : 
    1784              : /* Dump an OpenMP context selector CTX to PP.  */
    1785              : static void
    1786          432 : dump_omp_context_selector (pretty_printer *pp, tree ctx, int spc,
    1787              :                            dump_flags_t flags)
    1788              : {
    1789          968 :   for (tree set = ctx; set && set != error_mark_node; set = TREE_CHAIN (set))
    1790              :     {
    1791          536 :       pp_string (pp, OMP_TSS_NAME (set));
    1792          536 :       pp_string (pp, " = {");
    1793          536 :       for (tree sel = OMP_TSS_TRAIT_SELECTORS (set);
    1794         1156 :            sel && sel != error_mark_node; sel = TREE_CHAIN (sel))
    1795              :         {
    1796          620 :           if (OMP_TS_CODE (sel) == OMP_TRAIT_INVALID)
    1797            0 :             pp_string (pp, "<unknown selector>");
    1798              :           else
    1799          620 :             pp_string (pp, OMP_TS_NAME (sel));
    1800          620 :           tree score = OMP_TS_SCORE (sel);
    1801          620 :           tree props = OMP_TS_PROPERTIES (sel);
    1802          620 :           enum omp_tp_type tp_type = omp_ts_map[OMP_TS_CODE (sel)].tp_type;
    1803          620 :           if (props)
    1804              :             {
    1805          311 :               pp_string (pp, " (");
    1806          311 :               if (score)
    1807              :                 {
    1808           55 :                   pp_string (pp, "score(");
    1809           55 :                   dump_generic_node (pp, score, spc + 4, flags, false);
    1810           55 :                   pp_string (pp, "): ");
    1811              :                 }
    1812          638 :               for (tree prop = props; prop; prop = TREE_CHAIN (prop))
    1813              :                 {
    1814          327 :                   if (tp_type == OMP_TRAIT_PROPERTY_CLAUSE_LIST)
    1815           23 :                     dump_omp_clause (pp, prop, spc + 4, flags);
    1816          304 :                   else if (OMP_TP_NAME (prop) == OMP_TP_NAMELIST_NODE)
    1817              :                     {
    1818          169 :                       const char *str = omp_context_name_list_prop (prop);
    1819          169 :                       pp_string (pp, "\"");
    1820          169 :                       pretty_print_string (pp, str, strlen (str) + 1);
    1821          169 :                       pp_string (pp, "\"");
    1822              :                     }
    1823          135 :                   else if (OMP_TP_NAME (prop))
    1824            6 :                     dump_generic_node (pp, OMP_TP_NAME (prop), spc + 4,
    1825              :                                        flags, false);
    1826          129 :                   else if (OMP_TP_VALUE (prop))
    1827          129 :                     dump_generic_node (pp, OMP_TP_VALUE (prop), spc + 4,
    1828              :                                        flags, false);
    1829          327 :                   if (TREE_CHAIN (prop))
    1830              :                     {
    1831           16 :                       pp_comma (pp);
    1832           16 :                       pp_space (pp);
    1833              :                     }
    1834              :                 }
    1835          311 :               pp_string (pp, ")");
    1836              :             }
    1837          620 :           if (TREE_CHAIN (sel))
    1838              :             {
    1839           84 :               pp_comma (pp);
    1840           84 :               pp_space (pp);
    1841              :             }
    1842              :         }
    1843          536 :       pp_string (pp, "}");
    1844          536 :       if (TREE_CHAIN (set))
    1845              :         {
    1846          116 :           pp_comma (pp);
    1847          116 :           newline_and_indent (pp, spc);
    1848              :         }
    1849              :     }
    1850          432 : }
    1851              : 
    1852              : /* Wrapper for above, used for "declare variant".  Compare to
    1853              :    print_generic_expr.  */
    1854              : void
    1855          332 : print_omp_context_selector (FILE *file, tree t, dump_flags_t flags)
    1856              : {
    1857          332 :   maybe_init_pretty_print (file);
    1858          332 :   dump_omp_context_selector (tree_pp, t, 0, flags);
    1859          332 :   pp_flush (tree_pp);
    1860          332 : }
    1861              : 
    1862              : /* Dump location LOC to PP.  */
    1863              : 
    1864              : void
    1865         2329 : dump_location (pretty_printer *pp, location_t loc, dump_flags_t flags)
    1866              : {
    1867         2329 :   expanded_location xloc = expand_location (loc);
    1868         2329 :   int discriminator = get_discriminator_from_loc (loc);
    1869              : 
    1870         2329 :   pp_left_bracket (pp);
    1871         2329 :   if (xloc.file)
    1872              :     {
    1873         2329 :       pp_string (pp, xloc.file);
    1874         2329 :       pp_string (pp, ":");
    1875              :     }
    1876         2329 :   pp_decimal_int (pp, xloc.line);
    1877         2329 :   pp_colon (pp);
    1878         2329 :   pp_decimal_int (pp, xloc.column);
    1879         2329 :   if (discriminator && (flags & TDF_COMPARE_DEBUG) == 0)
    1880              :   {
    1881           12 :     pp_string (pp, " discrim ");
    1882           12 :     pp_decimal_int (pp, discriminator);
    1883              :   }
    1884         2329 :   pp_string (pp, "] ");
    1885         2329 : }
    1886              : 
    1887              : 
    1888              : /* Dump lexical block BLOCK.  PP, SPC and FLAGS are as in
    1889              :    dump_generic_node.  */
    1890              : 
    1891              : static void
    1892            6 : dump_block_node (pretty_printer *pp, tree block, int spc, dump_flags_t flags)
    1893              : {
    1894            6 :   tree t;
    1895              : 
    1896            6 :   pp_string (pp, "BLOCK #");
    1897            6 :   pp_decimal_int (pp, BLOCK_NUMBER (block));
    1898            6 :   pp_character (pp, ' ');
    1899              : 
    1900            6 :   if (flags & TDF_ADDRESS)
    1901              :     {
    1902            0 :       pp_character (pp, '[');
    1903            0 :       pp_scalar (pp, "%p", (void *) block);
    1904            0 :       pp_string (pp, "] ");
    1905              :     }
    1906              : 
    1907            6 :   if (TREE_ASM_WRITTEN (block))
    1908            0 :     pp_string (pp, "[written] ");
    1909              : 
    1910            6 :   if (flags & TDF_SLIM)
    1911            6 :     return;
    1912              : 
    1913            0 :   if (BLOCK_SOURCE_LOCATION (block))
    1914            0 :     dump_location (pp, BLOCK_SOURCE_LOCATION (block), flags);
    1915              : 
    1916            0 :   newline_and_indent (pp, spc + 2);
    1917              : 
    1918            0 :   if (BLOCK_SUPERCONTEXT (block))
    1919              :     {
    1920            0 :       pp_string (pp, "SUPERCONTEXT: ");
    1921            0 :       dump_generic_node (pp, BLOCK_SUPERCONTEXT (block), 0,
    1922              :                          flags | TDF_SLIM, false);
    1923            0 :       newline_and_indent (pp, spc + 2);
    1924              :     }
    1925              : 
    1926            0 :   if (BLOCK_SUBBLOCKS (block)
    1927            0 :       && (!lang_GNU_Fortran ()
    1928            0 :           || TREE_CODE (BLOCK_SUBBLOCKS (block)) != STATEMENT_LIST))
    1929              :     {
    1930            0 :       pp_string (pp, "SUBBLOCKS: ");
    1931            0 :       for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
    1932              :         {
    1933            0 :           dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
    1934            0 :           pp_space (pp);
    1935              :         }
    1936            0 :       newline_and_indent (pp, spc + 2);
    1937              :     }
    1938              : 
    1939            0 :   if (BLOCK_CHAIN (block))
    1940              :     {
    1941            0 :       pp_string (pp, "SIBLINGS: ");
    1942            0 :       for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))
    1943              :         {
    1944            0 :           dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
    1945            0 :           pp_space (pp);
    1946              :         }
    1947            0 :       newline_and_indent (pp, spc + 2);
    1948              :     }
    1949              : 
    1950            0 :   if (BLOCK_VARS (block))
    1951              :     {
    1952            0 :       pp_string (pp, "VARS: ");
    1953            0 :       for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
    1954              :         {
    1955            0 :           dump_generic_node (pp, t, 0, flags, false);
    1956            0 :           pp_space (pp);
    1957              :         }
    1958            0 :       newline_and_indent (pp, spc + 2);
    1959              :     }
    1960              : 
    1961            0 :   if (vec_safe_length (BLOCK_NONLOCALIZED_VARS (block)) > 0)
    1962              :     {
    1963            0 :       unsigned i;
    1964            0 :       vec<tree, va_gc> *nlv = BLOCK_NONLOCALIZED_VARS (block);
    1965              : 
    1966            0 :       pp_string (pp, "NONLOCALIZED_VARS: ");
    1967            0 :       FOR_EACH_VEC_ELT (*nlv, i, t)
    1968              :         {
    1969            0 :           dump_generic_node (pp, t, 0, flags, false);
    1970            0 :           pp_space (pp);
    1971              :         }
    1972            0 :       newline_and_indent (pp, spc + 2);
    1973              :     }
    1974              : 
    1975            0 :   if (BLOCK_ABSTRACT_ORIGIN (block))
    1976              :     {
    1977            0 :       pp_string (pp, "ABSTRACT_ORIGIN: ");
    1978            0 :       dump_generic_node (pp, BLOCK_ABSTRACT_ORIGIN (block), 0,
    1979              :                          flags | TDF_SLIM, false);
    1980            0 :       newline_and_indent (pp, spc + 2);
    1981              :     }
    1982              : 
    1983            0 :   if (BLOCK_FRAGMENT_ORIGIN (block))
    1984              :     {
    1985            0 :       pp_string (pp, "FRAGMENT_ORIGIN: ");
    1986            0 :       dump_generic_node (pp, BLOCK_FRAGMENT_ORIGIN (block), 0,
    1987              :                          flags | TDF_SLIM, false);
    1988            0 :       newline_and_indent (pp, spc + 2);
    1989              :     }
    1990              : 
    1991            0 :   if (BLOCK_FRAGMENT_CHAIN (block))
    1992              :     {
    1993            0 :       pp_string (pp, "FRAGMENT_CHAIN: ");
    1994            0 :       for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))
    1995              :         {
    1996            0 :           dump_generic_node (pp, t, 0, flags | TDF_SLIM, false);
    1997            0 :           pp_space (pp);
    1998              :         }
    1999            0 :       newline_and_indent (pp, spc + 2);
    2000              :     }
    2001              : }
    2002              : 
    2003              : /* Dump #pragma omp atomic memory order clause.  */
    2004              : 
    2005              : void
    2006         1343 : dump_omp_atomic_memory_order (pretty_printer *pp, enum omp_memory_order mo)
    2007              : {
    2008         1343 :   switch (mo & OMP_MEMORY_ORDER_MASK)
    2009              :     {
    2010         1158 :     case OMP_MEMORY_ORDER_RELAXED:
    2011         1158 :       pp_string (pp, " relaxed");
    2012         1158 :       break;
    2013           52 :     case OMP_MEMORY_ORDER_SEQ_CST:
    2014           52 :       pp_string (pp, " seq_cst");
    2015           52 :       break;
    2016           37 :     case OMP_MEMORY_ORDER_ACQ_REL:
    2017           37 :       pp_string (pp, " acq_rel");
    2018           37 :       break;
    2019           32 :     case OMP_MEMORY_ORDER_ACQUIRE:
    2020           32 :       pp_string (pp, " acquire");
    2021           32 :       break;
    2022           64 :     case OMP_MEMORY_ORDER_RELEASE:
    2023           64 :       pp_string (pp, " release");
    2024           64 :       break;
    2025              :     case OMP_MEMORY_ORDER_UNSPECIFIED:
    2026              :       break;
    2027            0 :     default:
    2028            0 :       gcc_unreachable ();
    2029              :     }
    2030         1343 :   switch (mo & OMP_FAIL_MEMORY_ORDER_MASK)
    2031              :     {
    2032            0 :     case OMP_FAIL_MEMORY_ORDER_RELAXED:
    2033            0 :       pp_string (pp, " fail(relaxed)");
    2034            0 :       break;
    2035            0 :     case OMP_FAIL_MEMORY_ORDER_SEQ_CST:
    2036            0 :       pp_string (pp, " fail(seq_cst)");
    2037            0 :       break;
    2038            0 :     case OMP_FAIL_MEMORY_ORDER_ACQUIRE:
    2039            0 :       pp_string (pp, " fail(acquire)");
    2040            0 :       break;
    2041              :     case OMP_FAIL_MEMORY_ORDER_UNSPECIFIED:
    2042              :       break;
    2043            0 :     default:
    2044            0 :       gcc_unreachable ();
    2045              :     }
    2046         1343 : }
    2047              : 
    2048              : /* Helper to dump a MEM_REF node.  */
    2049              : 
    2050              : static void
    2051      1355135 : dump_mem_ref (pretty_printer *pp, tree node, int spc, dump_flags_t flags)
    2052              : {
    2053      1355135 :   if ((TREE_CODE (node) == MEM_REF
    2054      1355135 :        || TREE_CODE (node) == TARGET_MEM_REF)
    2055      1355135 :       && (flags & TDF_GIMPLE))
    2056              :     {
    2057            3 :       pp_string (pp, "__MEM <");
    2058            3 :       dump_generic_node (pp, TREE_TYPE (node),
    2059              :                          spc, flags | TDF_SLIM, false);
    2060            6 :       if (TYPE_ALIGN (TREE_TYPE (node))
    2061            3 :           != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
    2062              :         {
    2063            3 :           pp_string (pp, ", ");
    2064            3 :           pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
    2065              :         }
    2066            3 :       pp_greater (pp);
    2067            3 :       pp_string (pp, " (");
    2068            3 :       if (TREE_TYPE (TREE_OPERAND (node, 0))
    2069            3 :           != TREE_TYPE (TREE_OPERAND (node, 1)))
    2070              :         {
    2071            3 :           pp_left_paren (pp);
    2072            3 :           dump_generic_node (pp, TREE_TYPE (TREE_OPERAND (node, 1)),
    2073              :                              spc, flags | TDF_SLIM, false);
    2074            3 :           pp_right_paren (pp);
    2075              :         }
    2076            3 :       dump_generic_node (pp, TREE_OPERAND (node, 0),
    2077              :                          spc, flags | TDF_SLIM, false);
    2078            3 :       if (! integer_zerop (TREE_OPERAND (node, 1)))
    2079              :         {
    2080            0 :           pp_string (pp, " + ");
    2081            0 :           dump_generic_node (pp, TREE_OPERAND (node, 1),
    2082              :                              spc, flags | TDF_SLIM, false);
    2083              :         }
    2084            3 :       if (TREE_CODE (node) == TARGET_MEM_REF)
    2085              :         {
    2086            0 :           if (TREE_OPERAND (node, 2))
    2087              :             {
    2088              :               /* INDEX * STEP  */
    2089            0 :               pp_string (pp, " + ");
    2090            0 :               dump_generic_node (pp, TREE_OPERAND (node, 2),
    2091              :                                  spc, flags | TDF_SLIM, false);
    2092            0 :               pp_string (pp, " * ");
    2093            0 :               dump_generic_node (pp, TREE_OPERAND (node, 3),
    2094              :                                  spc, flags | TDF_SLIM, false);
    2095              :             }
    2096            0 :           if (TREE_OPERAND (node, 4))
    2097              :             {
    2098              :               /* INDEX2  */
    2099            0 :               pp_string (pp, " + ");
    2100            0 :               dump_generic_node (pp, TREE_OPERAND (node, 4),
    2101              :                                  spc, flags | TDF_SLIM, false);
    2102              :             }
    2103              :         }
    2104            3 :       if (TREE_CODE (node) == MEM_REF
    2105            3 :           && REF_REVERSE_STORAGE_ORDER (node))
    2106              :         {
    2107            0 :           pp_string (pp, ", ");
    2108            0 :           pp_decimal_int (pp, REF_REVERSE_STORAGE_ORDER (node));
    2109              :         }
    2110            3 :       if (MR_DEPENDENCE_CLIQUE (node) != 0)
    2111              :         {
    2112            0 :           pp_string (pp, ", ");
    2113            0 :           pp_decimal_int (pp, MR_DEPENDENCE_CLIQUE (node));
    2114            0 :           pp_colon (pp);
    2115            0 :           pp_decimal_int (pp, MR_DEPENDENCE_BASE (node));
    2116              :         }
    2117            3 :       pp_right_paren (pp);
    2118              :     }
    2119      1355132 :   else if (TREE_CODE (node) == MEM_REF
    2120      1328105 :            && integer_zerop (TREE_OPERAND (node, 1))
    2121              :            /* Dump the types of INTEGER_CSTs explicitly, for we can't
    2122              :               infer them and MEM_ATTR caching will share MEM_REFs
    2123              :               with differently-typed op0s.  */
    2124      1002865 :            && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
    2125              :            /* Released SSA_NAMES have no TREE_TYPE.  */
    2126      1002726 :            && TREE_TYPE (TREE_OPERAND (node, 0)) != NULL_TREE
    2127              :            /* Same pointer types, but ignoring POINTER_TYPE vs.
    2128              :               REFERENCE_TYPE.  */
    2129      1002726 :            && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
    2130      1002726 :                == TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1))))
    2131      1603104 :            && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 0)))
    2132       801552 :                == TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
    2133       801552 :            && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
    2134       801552 :                == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
    2135              :            /* Same value types ignoring qualifiers.  */
    2136       801403 :            && (TYPE_MAIN_VARIANT (TREE_TYPE (node))
    2137       801403 :                == TYPE_MAIN_VARIANT
    2138              :                (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 1)))))
    2139      2140036 :            && (!(flags & TDF_ALIAS)
    2140         1483 :                || MR_DEPENDENCE_CLIQUE (node) == 0))
    2141              :     {
    2142       783590 :       if (TREE_CODE (TREE_OPERAND (node, 0)) != ADDR_EXPR)
    2143              :         {
    2144              :           /* Enclose pointers to arrays in parentheses.  */
    2145       689839 :           tree op0 = TREE_OPERAND (node, 0);
    2146       689839 :           tree op0type = TREE_TYPE (op0);
    2147       689839 :           if (POINTER_TYPE_P (op0type)
    2148       689839 :               && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
    2149        30459 :             pp_left_paren (pp);
    2150       689839 :           pp_star (pp);
    2151       689839 :           dump_generic_node (pp, op0, spc, flags, false);
    2152       689839 :           if (POINTER_TYPE_P (op0type)
    2153       689839 :               && TREE_CODE (TREE_TYPE (op0type)) == ARRAY_TYPE)
    2154        30459 :             pp_right_paren (pp);
    2155              :         }
    2156              :       else
    2157        93751 :         dump_generic_node (pp,
    2158        93751 :                            TREE_OPERAND (TREE_OPERAND (node, 0), 0),
    2159              :                            spc, flags, false);
    2160              :     }
    2161              :   else
    2162              :     {
    2163       571542 :       pp_string (pp, "MEM");
    2164              : 
    2165       571542 :       tree nodetype = TREE_TYPE (node);
    2166       571542 :       tree op0 = TREE_OPERAND (node, 0);
    2167       571542 :       tree op1 = TREE_OPERAND (node, 1);
    2168       571542 :       tree op1type = TYPE_MAIN_VARIANT (TREE_TYPE (op1));
    2169              : 
    2170       571542 :       tree op0size = TYPE_SIZE (nodetype);
    2171       571542 :       tree op1size = TYPE_SIZE (TREE_TYPE (op1type));
    2172              : 
    2173       571542 :       if (!op0size || !op1size
    2174       571542 :           || !operand_equal_p (op0size, op1size, 0))
    2175              :         {
    2176       228883 :           pp_string (pp, " <");
    2177              :           /* If the size of the type of the operand is not the same
    2178              :              as the size of the MEM_REF expression include the type
    2179              :              of the latter similar to the TDF_GIMPLE output to make
    2180              :              it clear how many bytes of memory are being accessed.  */
    2181       228883 :           dump_generic_node (pp, nodetype, spc, flags | TDF_SLIM, false);
    2182       228883 :           pp_string (pp, "> ");
    2183              :         }
    2184              : 
    2185       571542 :       pp_string (pp, "[(");
    2186       571542 :       dump_generic_node (pp, op1type, spc, flags | TDF_SLIM, false);
    2187       571542 :       pp_right_paren (pp);
    2188       571542 :       dump_generic_node (pp, op0, spc, flags, false);
    2189       571542 :       if (!integer_zerop (op1))
    2190              :         {
    2191       327953 :           pp_string (pp, " + ");
    2192       327953 :           dump_generic_node (pp, op1, spc, flags, false);
    2193              :         }
    2194       571542 :       if (TREE_CODE (node) == TARGET_MEM_REF)
    2195              :         {
    2196        27027 :           tree tmp = TMR_INDEX2 (node);
    2197        27027 :           if (tmp)
    2198              :             {
    2199          280 :               pp_string (pp, " + ");
    2200          280 :               dump_generic_node (pp, tmp, spc, flags, false);
    2201              :             }
    2202        27027 :           tmp = TMR_INDEX (node);
    2203        27027 :           if (tmp)
    2204              :             {
    2205        22386 :               pp_string (pp, " + ");
    2206        22386 :               dump_generic_node (pp, tmp, spc, flags, false);
    2207        22386 :               tmp = TMR_STEP (node);
    2208        22386 :               pp_string (pp, " * ");
    2209        22386 :               if (tmp)
    2210        22373 :                 dump_generic_node (pp, tmp, spc, flags, false);
    2211              :               else
    2212           13 :                 pp_string (pp, "1");
    2213              :             }
    2214              :         }
    2215       571542 :       if ((flags & TDF_ALIAS)
    2216       571542 :           && MR_DEPENDENCE_CLIQUE (node) != 0)
    2217              :         {
    2218         1347 :           pp_string (pp, " clique ");
    2219         1347 :           pp_unsigned_wide_integer (pp, MR_DEPENDENCE_CLIQUE (node));
    2220         1347 :           pp_string (pp, " base ");
    2221         1347 :           pp_unsigned_wide_integer (pp, MR_DEPENDENCE_BASE (node));
    2222              :         }
    2223       571542 :       pp_right_bracket (pp);
    2224              :     }
    2225      1355135 : }
    2226              : 
    2227              : /* Helper function for dump_generic_node.  Dump INIT or COND expression for
    2228              :    OpenMP loop non-rectangular iterators.  */
    2229              : 
    2230              : void
    2231           88 : dump_omp_loop_non_rect_expr (pretty_printer *pp, tree node, int spc,
    2232              :                              dump_flags_t flags)
    2233              : {
    2234           88 :   gcc_assert (TREE_CODE (node) == TREE_VEC);
    2235           88 :   dump_generic_node (pp, TREE_VEC_ELT (node, 0), spc, flags, false);
    2236           88 :   pp_string (pp, " * ");
    2237           88 :   if (op_prio (TREE_VEC_ELT (node, 1)) <= op_code_prio (MULT_EXPR))
    2238              :     {
    2239            0 :       pp_left_paren (pp);
    2240            0 :       dump_generic_node (pp, TREE_VEC_ELT (node, 1), spc, flags, false);
    2241            0 :       pp_right_paren (pp);
    2242              :     }
    2243              :   else
    2244           88 :     dump_generic_node (pp, TREE_VEC_ELT (node, 1), spc, flags, false);
    2245           88 :   pp_string (pp, " + ");
    2246           88 :   if (op_prio (TREE_VEC_ELT (node, 1)) <= op_code_prio (PLUS_EXPR))
    2247              :     {
    2248            0 :       pp_left_paren (pp);
    2249            0 :       dump_generic_node (pp, TREE_VEC_ELT (node, 2), spc, flags, false);
    2250            0 :       pp_right_paren (pp);
    2251              :     }
    2252              :   else
    2253           88 :     dump_generic_node (pp, TREE_VEC_ELT (node, 2), spc, flags, false);
    2254           88 : }
    2255              : 
    2256              : /* Dump the node NODE on the pretty_printer PP, SPC spaces of
    2257              :    indent.  FLAGS specifies details to show in the dump (see TDF_* in
    2258              :    dumpfile.h).  If IS_STMT is true, the object printed is considered
    2259              :    to be a statement and it is terminated by ';' if appropriate.  */
    2260              : 
    2261              : int
    2262     49719214 : dump_generic_node (pretty_printer *pp, tree node, int spc, dump_flags_t flags,
    2263              :                    bool is_stmt)
    2264              : {
    2265     49719214 :   tree type;
    2266     49719214 :   tree op0, op1;
    2267     49719214 :   const char *str;
    2268     49719214 :   bool is_expr;
    2269     49719214 :   enum tree_code code;
    2270              : 
    2271     49719214 :   if (node == NULL_TREE)
    2272              :     return spc;
    2273              : 
    2274     49698472 :   is_expr = EXPR_P (node);
    2275              : 
    2276     49698472 :   if (is_stmt && (flags & TDF_STMTADDR))
    2277              :     {
    2278            4 :       pp_string (pp, "<&");
    2279            4 :       pp_scalar (pp, "%p", (void *)node);
    2280            4 :       pp_string (pp, "> ");
    2281              :     }
    2282              : 
    2283     49698472 :   if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
    2284          931 :     dump_location (pp, EXPR_LOCATION (node), flags);
    2285              : 
    2286     49698472 :   code = TREE_CODE (node);
    2287     49698472 :   switch (code)
    2288              :     {
    2289           13 :     case ERROR_MARK:
    2290           13 :       pp_string (pp, "<<< error >>>");
    2291           13 :       break;
    2292              : 
    2293     10267460 :     case IDENTIFIER_NODE:
    2294     10267460 :       pp_tree_identifier (pp, node);
    2295     10267460 :       break;
    2296              : 
    2297              :     case TREE_LIST:
    2298        58898 :       while (node && node != error_mark_node)
    2299              :         {
    2300        58898 :           if (TREE_PURPOSE (node))
    2301              :             {
    2302        22172 :               dump_generic_node (pp, TREE_PURPOSE (node), spc, flags, false);
    2303        22172 :               pp_space (pp);
    2304              :             }
    2305        58898 :           dump_generic_node (pp, TREE_VALUE (node), spc, flags, false);
    2306        58898 :           node = TREE_CHAIN (node);
    2307        58898 :           if (node && TREE_CODE (node) == TREE_LIST)
    2308              :             {
    2309         2471 :               pp_comma (pp);
    2310         2471 :               pp_space (pp);
    2311              :             }
    2312              :         }
    2313              :       break;
    2314              : 
    2315            0 :     case TREE_BINFO:
    2316            0 :       dump_generic_node (pp, BINFO_TYPE (node), spc, flags, false);
    2317            0 :       break;
    2318              : 
    2319          159 :     case TREE_VEC:
    2320          159 :       {
    2321          159 :         size_t i;
    2322          159 :         pp_left_brace (pp);
    2323          159 :         if (TREE_VEC_LENGTH (node) > 0)
    2324              :           {
    2325          159 :             size_t len = TREE_VEC_LENGTH (node);
    2326          477 :             for (i = 0; i < len - 1; i++)
    2327              :               {
    2328          318 :                 dump_generic_node (pp, TREE_VEC_ELT (node, i), spc, flags,
    2329              :                                    false);
    2330          318 :                 pp_comma (pp);
    2331          318 :                 pp_space (pp);
    2332              :               }
    2333          159 :             dump_generic_node (pp, TREE_VEC_ELT (node, len - 1), spc,
    2334              :                                flags, false);
    2335              :           }
    2336          159 :         pp_right_brace (pp);
    2337              :       }
    2338          159 :       break;
    2339              : 
    2340      4676987 :     case VOID_TYPE:
    2341      4676987 :     case INTEGER_TYPE:
    2342      4676987 :     case REAL_TYPE:
    2343      4676987 :     case FIXED_POINT_TYPE:
    2344      4676987 :     case COMPLEX_TYPE:
    2345      4676987 :     case VECTOR_TYPE:
    2346      4676987 :     case ENUMERAL_TYPE:
    2347      4676987 :     case BOOLEAN_TYPE:
    2348      4676987 :     case BITINT_TYPE:
    2349      4676987 :     case OPAQUE_TYPE:
    2350      4676987 :     case NULLPTR_TYPE:
    2351      4676987 :       {
    2352      4676987 :         auto quals = TYPE_QUALS_NO_ADDR_SPACE (node);
    2353      4676987 :         enum tree_code_class tclass;
    2354              : 
    2355      4676987 :         if (quals & TYPE_QUAL_ATOMIC)
    2356          534 :           pp_string (pp, "atomic ");
    2357      4676987 :         if (quals & TYPE_QUAL_CONST)
    2358        44816 :           pp_string (pp, "const ");
    2359      4676987 :         if (quals & TYPE_QUAL_VOLATILE)
    2360         3791 :           pp_string (pp, "volatile ");
    2361      4676987 :         if (quals & TYPE_QUAL_RESTRICT)
    2362            0 :           pp_string (pp, "restrict ");
    2363              : 
    2364      4676987 :         if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
    2365              :           {
    2366          157 :             pp_string (pp, "<address-space-");
    2367          157 :             pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
    2368          157 :             pp_string (pp, "> ");
    2369              :           }
    2370              : 
    2371      4676987 :         tclass = TREE_CODE_CLASS (TREE_CODE (node));
    2372              : 
    2373      4676987 :         if (tclass == tcc_declaration)
    2374              :           {
    2375            0 :             if (DECL_NAME (node))
    2376            0 :               dump_decl_name (pp, node, flags);
    2377              :             else
    2378            0 :               pp_string (pp, "<unnamed type decl>");
    2379              :           }
    2380      4676987 :         else if (tclass == tcc_type)
    2381              :           {
    2382      4676987 :             if ((flags & TDF_GIMPLE) && node == sizetype)
    2383            0 :               pp_string (pp, "__SIZETYPE__");
    2384      4676987 :             else if (TYPE_NAME (node))
    2385              :               {
    2386      3093951 :                 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
    2387       877657 :                   pp_tree_identifier (pp, TYPE_NAME (node));
    2388      2216294 :                 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
    2389      2216294 :                          && DECL_NAME (TYPE_NAME (node)))
    2390      2216294 :                   dump_decl_name (pp, TYPE_NAME (node), flags);
    2391              :                 else
    2392            0 :                   pp_string (pp, "<unnamed type>");
    2393              :               }
    2394      1583036 :             else if (TREE_CODE (node) == VECTOR_TYPE)
    2395              :               {
    2396      1055986 :                 if (flags & TDF_GIMPLE)
    2397              :                   {
    2398            0 :                     dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
    2399            0 :                     pp_string (pp, " [[gnu::vector_size(");
    2400            0 :                     pp_wide_integer
    2401            0 :                       (pp, tree_to_poly_uint64 (TYPE_SIZE_UNIT (node)));
    2402            0 :                     pp_string (pp, ")]]");
    2403              :                   }
    2404              :                 else
    2405              :                   {
    2406      1055986 :                     pp_string (pp, "vector");
    2407      1055986 :                     pp_left_paren (pp);
    2408      1055986 :                     pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (node));
    2409      1055986 :                     pp_string (pp, ") ");
    2410      1055986 :                     dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
    2411              :                   }
    2412              :               }
    2413              :             else if (TREE_CODE (node) == INTEGER_TYPE)
    2414              :               {
    2415       448010 :                 if (TYPE_PRECISION (node) == CHAR_TYPE_SIZE)
    2416        56436 :                   pp_string (pp, (TYPE_UNSIGNED (node)
    2417              :                                       ? "unsigned char"
    2418              :                                       : "signed char"));
    2419       397762 :                 else if (TYPE_PRECISION (node) == SHORT_TYPE_SIZE)
    2420       184105 :                   pp_string (pp, (TYPE_UNSIGNED (node)
    2421              :                                       ? "unsigned short"
    2422              :                                       : "signed short"));
    2423       247959 :                 else if (TYPE_PRECISION (node) == INT_TYPE_SIZE)
    2424       203669 :                   pp_string (pp, (TYPE_UNSIGNED (node)
    2425              :                                       ? "unsigned int"
    2426              :                                       : "signed int"));
    2427        47992 :                 else if (TYPE_PRECISION (node) == LONG_TYPE_SIZE)
    2428        46159 :                   pp_string (pp, (TYPE_UNSIGNED (node)
    2429              :                                       ? "unsigned long"
    2430              :                                       : "signed long"));
    2431         4242 :                 else if (TYPE_PRECISION (node) == LONG_LONG_TYPE_SIZE)
    2432            0 :                   pp_string (pp, (TYPE_UNSIGNED (node)
    2433              :                                       ? "unsigned long long"
    2434              :                                       : "signed long long"));
    2435         4242 :                 else if (TYPE_PRECISION (node) >= CHAR_TYPE_SIZE
    2436         4242 :                          && pow2p_hwi (TYPE_PRECISION (node)))
    2437              :                   {
    2438         6149 :                     pp_string (pp, (TYPE_UNSIGNED (node) ? "uint" : "int"));
    2439         3689 :                     pp_decimal_int (pp, TYPE_PRECISION (node));
    2440         3689 :                     pp_string (pp, "_t");
    2441              :                   }
    2442              :                 else
    2443              :                   {
    2444          722 :                     pp_string (pp, (TYPE_UNSIGNED (node)
    2445              :                                         ? "<unnamed-unsigned:"
    2446              :                                         : "<unnamed-signed:"));
    2447          553 :                     pp_decimal_int (pp, TYPE_PRECISION (node));
    2448          553 :                     pp_greater (pp);
    2449              :                   }
    2450              :               }
    2451              :             else if (TREE_CODE (node) == COMPLEX_TYPE)
    2452              :               {
    2453         6975 :                 pp_string (pp, "__complex__ ");
    2454         6975 :                 dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
    2455              :               }
    2456              :             else if (TREE_CODE (node) == REAL_TYPE)
    2457              :               {
    2458            0 :                 pp_string (pp, "<float:");
    2459            0 :                 pp_decimal_int (pp, TYPE_PRECISION (node));
    2460            0 :                 pp_greater (pp);
    2461              :               }
    2462              :             else if (TREE_CODE (node) == FIXED_POINT_TYPE)
    2463              :               {
    2464            0 :                 pp_string (pp, "<fixed-point-");
    2465            0 :                 pp_string (pp, TYPE_SATURATING (node) ? "sat:" : "nonsat:");
    2466            0 :                 pp_decimal_int (pp, TYPE_PRECISION (node));
    2467            0 :                 pp_greater (pp);
    2468              :               }
    2469              :             else if (TREE_CODE (node) == BOOLEAN_TYPE)
    2470              :               {
    2471       137884 :                 pp_string (pp, (TYPE_UNSIGNED (node)
    2472              :                                 ? "<unsigned-boolean:"
    2473              :                                 : "<signed-boolean:"));
    2474        68942 :                 pp_decimal_int (pp, TYPE_PRECISION (node));
    2475        68942 :                 pp_greater (pp);
    2476              :               }
    2477              :             else if (TREE_CODE (node) == BITINT_TYPE)
    2478              :               {
    2479         2989 :                 if (TYPE_UNSIGNED (node))
    2480         1983 :                   pp_string (pp, "unsigned ");
    2481         2989 :                 pp_string (pp, "_BitInt(");
    2482         2989 :                 pp_decimal_int (pp, TYPE_PRECISION (node));
    2483         2989 :                 pp_right_paren (pp);
    2484              :               }
    2485              :             else if (TREE_CODE (node) == VOID_TYPE)
    2486           13 :               pp_string (pp, "void");
    2487              :             else if (TREE_CODE (node) == NULLPTR_TYPE)
    2488            0 :               pp_string (pp, "nullptr_t");
    2489              :             else
    2490          121 :               pp_string (pp, "<unnamed type>");
    2491              :           }
    2492              :         break;
    2493              :       }
    2494              : 
    2495       880014 :     case POINTER_TYPE:
    2496       880014 :     case REFERENCE_TYPE:
    2497       880014 :       str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
    2498              : 
    2499       880014 :       if (TREE_TYPE (node) == NULL)
    2500              :         {
    2501            0 :           pp_string (pp, str);
    2502            0 :           pp_string (pp, "<null type>");
    2503              :         }
    2504       880014 :       else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
    2505              :         {
    2506         7422 :           tree fnode = TREE_TYPE (node);
    2507              : 
    2508         7422 :           dump_generic_node (pp, TREE_TYPE (fnode), spc, flags, false);
    2509         7422 :           pp_space (pp);
    2510         7422 :           pp_left_paren (pp);
    2511         7422 :           pp_string (pp, str);
    2512         7422 :           if (TYPE_IDENTIFIER (node))
    2513         2448 :             dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
    2514         4974 :           else if (flags & TDF_NOUID)
    2515          129 :             pp_string (pp, "<Txxxx>");
    2516              :           else
    2517              :             {
    2518         4845 :               pp_string (pp, "<T");
    2519         4845 :               pp_scalar (pp, "%x", TYPE_UID (node));
    2520         4845 :               pp_character (pp, '>');
    2521              :             }
    2522              : 
    2523         7422 :           pp_right_paren (pp);
    2524         7422 :           dump_function_declaration (pp, fnode, spc, flags);
    2525              :         }
    2526              :       else
    2527              :         {
    2528       872592 :           auto quals = TYPE_QUALS (node);
    2529              : 
    2530       872592 :           dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
    2531       872592 :           pp_space (pp);
    2532       872592 :           pp_string (pp, str);
    2533              : 
    2534       872592 :           if (quals.has (TYPE_QUAL_CONST))
    2535         4255 :             pp_string (pp, " const");
    2536       872592 :           if (quals.has (TYPE_QUAL_VOLATILE))
    2537          209 :             pp_string (pp, " volatile");
    2538       872592 :           if (quals.has (TYPE_QUAL_RESTRICT))
    2539        47226 :             pp_string (pp, " restrict");
    2540              : 
    2541       872592 :           if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
    2542              :             {
    2543            0 :               pp_string (pp, " <address-space-");
    2544            0 :               pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
    2545            0 :               pp_greater (pp);
    2546              :             }
    2547              : 
    2548       872592 :           if (TYPE_REF_CAN_ALIAS_ALL (node))
    2549         5115 :             pp_string (pp, " {ref-all}");
    2550              :         }
    2551              :       break;
    2552              : 
    2553            0 :     case OFFSET_TYPE:
    2554            0 :       NIY;
    2555            0 :       break;
    2556              : 
    2557      1355135 :     case MEM_REF:
    2558      1355135 :     case TARGET_MEM_REF:
    2559      1355135 :       dump_mem_ref (pp, node, spc, flags);
    2560      1355135 :       break;
    2561              : 
    2562        72700 :     case ARRAY_TYPE:
    2563        72700 :       {
    2564        72700 :         auto quals = TYPE_QUALS_NO_ADDR_SPACE (node);
    2565        72700 :         tree tmp;
    2566              : 
    2567        72700 :         if (quals & TYPE_QUAL_ATOMIC)
    2568            0 :           pp_string (pp, "atomic ");
    2569        72700 :         if (quals & TYPE_QUAL_CONST)
    2570            1 :           pp_string (pp, "const ");
    2571        72700 :         if (quals & TYPE_QUAL_VOLATILE)
    2572            0 :           pp_string (pp, "volatile ");
    2573              : 
    2574              :         /* Print the innermost component type.  */
    2575        77663 :         for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
    2576         4963 :              tmp = TREE_TYPE (tmp))
    2577              :           ;
    2578              : 
    2579              :         /* Avoid to print recursively the array.  */
    2580              :         /* FIXME : Not implemented correctly, see print_struct_decl.  */
    2581        72700 :         if (TREE_CODE (tmp) != POINTER_TYPE || TREE_TYPE (tmp) != node)
    2582        72700 :           dump_generic_node (pp, tmp, spc, flags, false);
    2583              : 
    2584              :         /* Print the dimensions.  */
    2585       150363 :         for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
    2586        77663 :           dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
    2587              :         break;
    2588              :       }
    2589              : 
    2590       131440 :     case RECORD_TYPE:
    2591       131440 :     case UNION_TYPE:
    2592       131440 :     case QUAL_UNION_TYPE:
    2593       131440 :       {
    2594       131440 :         auto quals = TYPE_QUALS_NO_ADDR_SPACE (node);
    2595              : 
    2596       131440 :         if (quals & TYPE_QUAL_ATOMIC)
    2597            0 :           pp_string (pp, "atomic ");
    2598       131440 :         if (quals & TYPE_QUAL_CONST)
    2599        12558 :           pp_string (pp, "const ");
    2600       131440 :         if (quals & TYPE_QUAL_VOLATILE)
    2601           63 :           pp_string (pp, "volatile ");
    2602              : 
    2603       131440 :         if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
    2604              :           {
    2605            1 :             pp_string (pp, "<address-space-");
    2606            1 :             pp_decimal_int (pp, TYPE_ADDR_SPACE (node));
    2607            1 :             pp_string (pp, "> ");
    2608              :           }
    2609              : 
    2610              :         /* Print the name of the structure.  */
    2611       131440 :         if (TREE_CODE (node) == RECORD_TYPE)
    2612       129599 :           pp_string (pp, "struct ");
    2613         1841 :         else if (TREE_CODE (node) == UNION_TYPE)
    2614         1841 :           pp_string (pp, "union ");
    2615              : 
    2616       131440 :         if (TYPE_NAME (node))
    2617       128298 :           dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
    2618         3142 :         else if (!(flags & TDF_SLIM))
    2619              :           /* FIXME: If we eliminate the 'else' above and attempt
    2620              :              to show the fields for named types, we may get stuck
    2621              :              following a cycle of pointers to structs.  The alleged
    2622              :              self-reference check in print_struct_decl will not detect
    2623              :              cycles involving more than one pointer or struct type.  */
    2624          580 :           print_struct_decl (pp, node, spc, flags);
    2625              :         break;
    2626              :       }
    2627              : 
    2628            0 :     case LANG_TYPE:
    2629            0 :       NIY;
    2630            0 :       break;
    2631              : 
    2632      5737072 :     case INTEGER_CST:
    2633      5737072 :       if (flags & TDF_GIMPLE
    2634      5737072 :           && (POINTER_TYPE_P (TREE_TYPE (node))
    2635           47 :               || (TYPE_PRECISION (TREE_TYPE (node))
    2636           47 :                   < TYPE_PRECISION (integer_type_node))
    2637           47 :               || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1
    2638           47 :               || tree_int_cst_sgn (node) < 0))
    2639              :         {
    2640            0 :           pp_string (pp, "_Literal (");
    2641            0 :           dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
    2642            0 :           pp_string (pp, ") ");
    2643              :         }
    2644      5737072 :       if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE
    2645      5737072 :           && ! (flags & TDF_GIMPLE))
    2646              :         {
    2647              :           /* In the case of a pointer, one may want to divide by the
    2648              :              size of the pointed-to type.  Unfortunately, this not
    2649              :              straightforward.  The C front-end maps expressions
    2650              : 
    2651              :              (int *) 5
    2652              :              int *p; (p + 5)
    2653              : 
    2654              :              in such a way that the two INTEGER_CST nodes for "5" have
    2655              :              different values but identical types.  In the latter
    2656              :              case, the 5 is multiplied by sizeof (int) in c-common.cc
    2657              :              (pointer_int_sum) to convert it to a byte address, and
    2658              :              yet the type of the node is left unchanged.  Argh.  What
    2659              :              is consistent though is that the number value corresponds
    2660              :              to bytes (UNITS) offset.
    2661              : 
    2662              :              NB: Neither of the following divisors can be trivially
    2663              :              used to recover the original literal:
    2664              : 
    2665              :              TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
    2666              :              TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node)))  */
    2667       449138 :           pp_wide_integer (pp, TREE_INT_CST_LOW (node));
    2668       449138 :           pp_string (pp, "B"); /* pseudo-unit */
    2669              :         }
    2670      5287934 :       else if (tree_fits_shwi_p (node))
    2671      5267472 :         pp_wide_integer (pp, tree_to_shwi (node));
    2672        20462 :       else if (tree_fits_uhwi_p (node))
    2673        19904 :         pp_unsigned_wide_integer (pp, tree_to_uhwi (node));
    2674              :       else
    2675              :         {
    2676          558 :           wide_int val = wi::to_wide (node);
    2677              : 
    2678          558 :           if (wi::neg_p (val, TYPE_SIGN (TREE_TYPE (node))))
    2679              :             {
    2680           11 :               pp_minus (pp);
    2681           11 :               val = -val;
    2682              :             }
    2683          558 :           unsigned int len;
    2684          558 :           print_hex_buf_size (val, &len);
    2685          558 :           if (UNLIKELY (len > sizeof (pp_buffer (pp)->m_digit_buffer)))
    2686              :             {
    2687            0 :               char *buf = XALLOCAVEC (char, len);
    2688            0 :               print_hex (val, buf);
    2689            0 :               pp_string (pp, buf);
    2690              :             }
    2691              :           else
    2692              :             {
    2693          558 :               print_hex (val, pp_buffer (pp)->m_digit_buffer);
    2694          558 :               pp_string (pp, pp_buffer (pp)->m_digit_buffer);
    2695              :             }
    2696          558 :         }
    2697      5737072 :       if ((flags & TDF_GIMPLE)
    2698      5737072 :           && ! (POINTER_TYPE_P (TREE_TYPE (node))
    2699           47 :                 || (TYPE_PRECISION (TREE_TYPE (node))
    2700           47 :                     < TYPE_PRECISION (integer_type_node))
    2701           47 :                 || exact_log2 (TYPE_PRECISION (TREE_TYPE (node))) == -1))
    2702              :         {
    2703           47 :           if (TYPE_UNSIGNED (TREE_TYPE (node)))
    2704            0 :             pp_character (pp, 'u');
    2705           47 :           if (TYPE_PRECISION (TREE_TYPE (node))
    2706           47 :               == TYPE_PRECISION (unsigned_type_node))
    2707              :             ;
    2708            0 :           else if (TYPE_PRECISION (TREE_TYPE (node))
    2709            0 :                    == TYPE_PRECISION (long_unsigned_type_node))
    2710            0 :             pp_character (pp, 'l');
    2711            0 :           else if (TYPE_PRECISION (TREE_TYPE (node))
    2712            0 :                    == TYPE_PRECISION (long_long_unsigned_type_node))
    2713            0 :             pp_string (pp, "ll");
    2714              :         }
    2715      5737072 :       if (TREE_OVERFLOW (node))
    2716          251 :         pp_string (pp, "(OVF)");
    2717              :       break;
    2718              : 
    2719            0 :     case POLY_INT_CST:
    2720            0 :       pp_string (pp, "POLY_INT_CST [");
    2721            0 :       dump_generic_node (pp, POLY_INT_CST_COEFF (node, 0), spc, flags, false);
    2722            0 :       for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
    2723              :         {
    2724              :           pp_string (pp, ", ");
    2725              :           dump_generic_node (pp, POLY_INT_CST_COEFF (node, i),
    2726              :                              spc, flags, false);
    2727              :         }
    2728            0 :       pp_string (pp, "]");
    2729            0 :       break;
    2730              : 
    2731       151938 :     case REAL_CST:
    2732              :       /* Code copied from print_node.  */
    2733       151938 :       {
    2734       151938 :         REAL_VALUE_TYPE d;
    2735       151938 :         if (TREE_OVERFLOW (node))
    2736            0 :           pp_string (pp, " overflow");
    2737              : 
    2738       151938 :         d = TREE_REAL_CST (node);
    2739       151938 :         if (REAL_VALUE_ISINF (d))
    2740         6550 :           pp_string (pp, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
    2741       145874 :         else if (REAL_VALUE_ISNAN (d))
    2742         2285 :           pp_string (pp, " Nan");
    2743              :         else
    2744              :           {
    2745       143589 :             char string[100];
    2746       143589 :             real_to_decimal (string, &d, sizeof (string), 0, 1);
    2747       143589 :             pp_string (pp, string);
    2748              :           }
    2749       151938 :         break;
    2750              :       }
    2751              : 
    2752            0 :     case FIXED_CST:
    2753            0 :       {
    2754            0 :         char string[100];
    2755            0 :         fixed_to_decimal (string, TREE_FIXED_CST_PTR (node), sizeof (string));
    2756            0 :         pp_string (pp, string);
    2757            0 :         break;
    2758              :       }
    2759              : 
    2760         1554 :     case COMPLEX_CST:
    2761         1554 :       pp_string (pp, "__complex__ (");
    2762         1554 :       dump_generic_node (pp, TREE_REALPART (node), spc, flags, false);
    2763         1554 :       pp_string (pp, ", ");
    2764         1554 :       dump_generic_node (pp, TREE_IMAGPART (node), spc, flags, false);
    2765         1554 :       pp_right_paren (pp);
    2766         1554 :       break;
    2767              : 
    2768        62383 :     case STRING_CST:
    2769        62383 :       {
    2770        62383 :         pp_string (pp, "\"");
    2771        62383 :         if (unsigned nbytes = TREE_STRING_LENGTH (node))
    2772        62140 :           pretty_print_string (pp, TREE_STRING_POINTER (node), nbytes);
    2773        62383 :         pp_string (pp, "\"");
    2774        62383 :         break;
    2775              :       }
    2776              : 
    2777       149417 :     case VECTOR_CST:
    2778       149417 :       {
    2779       149417 :         unsigned i;
    2780       149417 :         if (flags & TDF_GIMPLE)
    2781              :           {
    2782            0 :             pp_string (pp, "_Literal (");
    2783            0 :             dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
    2784            0 :             pp_string (pp, ") ");
    2785              :           }
    2786       149417 :         pp_string (pp, "{ ");
    2787       149417 :         unsigned HOST_WIDE_INT nunits;
    2788       149417 :         if (!VECTOR_CST_NELTS (node).is_constant (&nunits))
    2789              :           nunits = vector_cst_encoded_nelts (node);
    2790      1084406 :         for (i = 0; i < nunits; ++i)
    2791              :           {
    2792       934989 :             if (i != 0)
    2793       785572 :               pp_string (pp, ", ");
    2794       934989 :             dump_generic_node (pp, VECTOR_CST_ELT (node, i),
    2795              :                                spc, flags, false);
    2796              :           }
    2797       149417 :         if (!VECTOR_CST_NELTS (node).is_constant ())
    2798              :           pp_string (pp, ", ...");
    2799       149417 :         pp_string (pp, " }");
    2800              :       }
    2801       149417 :       break;
    2802              : 
    2803              :     case RAW_DATA_CST:
    2804           36 :       for (unsigned i = 0; i < (unsigned) RAW_DATA_LENGTH (node); ++i)
    2805              :         {
    2806           36 :           if (TYPE_UNSIGNED (TREE_TYPE (node))
    2807           36 :               || TYPE_PRECISION (TREE_TYPE (node)) > CHAR_BIT)
    2808           36 :             pp_decimal_int (pp, RAW_DATA_UCHAR_ELT (node, i));
    2809              :           else
    2810            0 :             pp_decimal_int (pp, RAW_DATA_SCHAR_ELT (node, i));
    2811           36 :           if (i == RAW_DATA_LENGTH (node) - 1U)
    2812              :             break;
    2813           28 :           else if (i == 9 && RAW_DATA_LENGTH (node) > 20)
    2814              :             {
    2815            0 :               pp_string (pp, ", ..., ");
    2816            0 :               i = RAW_DATA_LENGTH (node) - 11;
    2817              :             }
    2818              :           else
    2819           28 :             pp_string (pp, ", ");
    2820              :         }
    2821              :       break;
    2822              : 
    2823           70 :     case FUNCTION_TYPE:
    2824           70 :     case METHOD_TYPE:
    2825           70 :       dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
    2826           70 :       pp_space (pp);
    2827           70 :       if (TREE_CODE (node) == METHOD_TYPE)
    2828              :         {
    2829           70 :           if (TYPE_METHOD_BASETYPE (node))
    2830           70 :             dump_generic_node (pp, TYPE_NAME (TYPE_METHOD_BASETYPE (node)),
    2831              :                                spc, flags, false);
    2832              :           else
    2833            0 :             pp_string (pp, "<null method basetype>");
    2834           70 :           pp_colon_colon (pp);
    2835              :         }
    2836           70 :       if (TYPE_IDENTIFIER (node))
    2837            0 :         dump_generic_node (pp, TYPE_NAME (node), spc, flags, false);
    2838           70 :       else if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
    2839            0 :         dump_decl_name (pp, TYPE_NAME (node), flags);
    2840           70 :       else if (flags & TDF_NOUID)
    2841            0 :         pp_string (pp, "<Txxxx>");
    2842              :       else
    2843              :         {
    2844           70 :           pp_string (pp, "<T");
    2845           70 :           pp_scalar (pp, "%x", TYPE_UID (node));
    2846           70 :           pp_character (pp, '>');
    2847              :         }
    2848           70 :       dump_function_declaration (pp, node, spc, flags);
    2849           70 :       break;
    2850              : 
    2851        23762 :     case FUNCTION_DECL:
    2852        23762 :     case CONST_DECL:
    2853        23762 :       dump_decl_name (pp, node, flags);
    2854        23762 :       break;
    2855              : 
    2856       125842 :     case LABEL_DECL:
    2857       125842 :       if (DECL_NAME (node))
    2858        55001 :         dump_decl_name (pp, node, flags);
    2859        70841 :       else if (LABEL_DECL_UID (node) != -1)
    2860              :         {
    2861        24560 :           if (flags & TDF_GIMPLE)
    2862              :             {
    2863           35 :               pp_character (pp, 'L');
    2864           35 :               pp_decimal_int (pp, (int) LABEL_DECL_UID (node));
    2865              :             }
    2866              :           else
    2867              :             {
    2868        24525 :               pp_string (pp, "<L");
    2869        24525 :               pp_decimal_int (pp, (int) LABEL_DECL_UID (node));
    2870        24525 :               pp_character (pp, '>');
    2871              :             }
    2872              :         }
    2873              :       else
    2874              :         {
    2875        46281 :           if (flags & TDF_NOUID)
    2876            6 :             pp_string (pp, "<D.xxxx>");
    2877              :           else
    2878              :             {
    2879        46275 :               if (flags & TDF_GIMPLE)
    2880              :                 {
    2881            6 :                   pp_character (pp, 'D');
    2882            6 :                   pp_scalar (pp, "%u", DECL_UID (node));
    2883              :                 }
    2884              :               else
    2885              :                 {
    2886        46269 :                   pp_string (pp, "<D.");
    2887        46269 :                   pp_scalar (pp, "%u", DECL_UID (node));
    2888        46269 :                   pp_character (pp, '>');
    2889              :                 }
    2890              :             }
    2891              :         }
    2892              :       break;
    2893              : 
    2894        78000 :     case TYPE_DECL:
    2895        78000 :       if (DECL_IS_UNDECLARED_BUILTIN (node))
    2896              :         {
    2897              :           /* Don't print the declaration of built-in types.  */
    2898              :           break;
    2899              :         }
    2900        72814 :       if (DECL_NAME (node))
    2901        72759 :         dump_decl_name (pp, node, flags);
    2902           55 :       else if (TYPE_NAME (TREE_TYPE (node)) != node)
    2903              :         {
    2904           95 :           pp_string (pp, (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
    2905              :                           ? "union" : "struct "));
    2906           49 :           dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
    2907              :         }
    2908              :       else
    2909            6 :         pp_string (pp, "<anon>");
    2910              :       break;
    2911              : 
    2912      3738971 :     case VAR_DECL:
    2913      3738971 :     case PARM_DECL:
    2914      3738971 :     case FIELD_DECL:
    2915      3738971 :     case DEBUG_EXPR_DECL:
    2916      3738971 :     case NAMESPACE_DECL:
    2917      3738971 :     case NAMELIST_DECL:
    2918      3738971 :       dump_decl_name (pp, node, flags);
    2919      3738971 :       break;
    2920              : 
    2921        23476 :     case RESULT_DECL:
    2922        23476 :       pp_string (pp, "<retval>");
    2923        23476 :       break;
    2924              : 
    2925       639222 :     case COMPONENT_REF:
    2926       639222 :       op0 = TREE_OPERAND (node, 0);
    2927       639222 :       str = ".";
    2928       639222 :       if (op0
    2929       639222 :           && (TREE_CODE (op0) == INDIRECT_REF
    2930       597745 :               || (TREE_CODE (op0) == MEM_REF
    2931       197900 :                   && TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
    2932       164893 :                   && integer_zerop (TREE_OPERAND (op0, 1))
    2933              :                   /* Dump the types of INTEGER_CSTs explicitly, for we
    2934              :                      can't infer them and MEM_ATTR caching will share
    2935              :                      MEM_REFs with differently-typed op0s.  */
    2936       159555 :                   && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
    2937              :                   /* Released SSA_NAMES have no TREE_TYPE.  */
    2938       159519 :                   && TREE_TYPE (TREE_OPERAND (op0, 0)) != NULL_TREE
    2939              :                   /* Same pointer types, but ignoring POINTER_TYPE vs.
    2940              :                      REFERENCE_TYPE.  */
    2941       159519 :                   && (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
    2942       159519 :                       == TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1))))
    2943       307682 :                   && (TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 0)))
    2944       153841 :                       == TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
    2945       153841 :                   && (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
    2946       153841 :                       == TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
    2947              :                   /* Same value types ignoring qualifiers.  */
    2948       153841 :                   && (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
    2949       153841 :                       == TYPE_MAIN_VARIANT
    2950              :                           (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 1)))))
    2951       153841 :                   && MR_DEPENDENCE_CLIQUE (op0) == 0)))
    2952              :         {
    2953       182145 :           op0 = TREE_OPERAND (op0, 0);
    2954       182145 :           str = "->";
    2955              :         }
    2956       639222 :       if (op_prio (op0) < op_prio (node))
    2957         7105 :         pp_left_paren (pp);
    2958       639222 :       dump_generic_node (pp, op0, spc, flags, false);
    2959       639222 :       if (op_prio (op0) < op_prio (node))
    2960         7105 :         pp_right_paren (pp);
    2961       639222 :       pp_string (pp, str);
    2962       639222 :       op1 = TREE_OPERAND (node, 1);
    2963       639222 :       dump_generic_node (pp, op1, spc, flags, false);
    2964       639222 :       if (DECL_P (op1)) /* Not always a decl in the C++ FE.  */
    2965       639222 :         if (tree off = component_ref_field_offset (node))
    2966       639122 :           if (TREE_CODE (off) != INTEGER_CST)
    2967              :             {
    2968           16 :               pp_string (pp, "{off: ");
    2969           16 :               dump_generic_node (pp, off, spc, flags, false);
    2970           16 :               pp_right_brace (pp);
    2971              :             }
    2972              :       break;
    2973              : 
    2974        24053 :     case BIT_FIELD_REF:
    2975        24053 :       if (flags & TDF_GIMPLE)
    2976              :         {
    2977            0 :           pp_string (pp, "__BIT_FIELD_REF <");
    2978            0 :           dump_generic_node (pp, TREE_TYPE (node),
    2979              :                              spc, flags | TDF_SLIM, false);
    2980            0 :           if (TYPE_ALIGN (TREE_TYPE (node))
    2981            0 :               != TYPE_ALIGN (TYPE_MAIN_VARIANT (TREE_TYPE (node))))
    2982              :             {
    2983            0 :               pp_string (pp, ", ");
    2984            0 :               pp_decimal_int (pp, TYPE_ALIGN (TREE_TYPE (node)));
    2985              :             }
    2986            0 :           pp_greater (pp);
    2987            0 :           pp_string (pp, " (");
    2988            0 :           dump_generic_node (pp, TREE_OPERAND (node, 0), spc,
    2989              :                              flags | TDF_SLIM, false);
    2990            0 :           pp_string (pp, ", ");
    2991            0 :           dump_generic_node (pp, TREE_OPERAND (node, 1), spc,
    2992              :                              flags | TDF_SLIM, false);
    2993            0 :           pp_string (pp, ", ");
    2994            0 :           dump_generic_node (pp, TREE_OPERAND (node, 2), spc,
    2995              :                              flags | TDF_SLIM, false);
    2996            0 :           pp_right_paren (pp);
    2997              :         }
    2998              :       else
    2999              :         {
    3000        24053 :           pp_string (pp, "BIT_FIELD_REF <");
    3001        24053 :           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3002        24053 :           pp_string (pp, ", ");
    3003        24053 :           dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    3004        24053 :           pp_string (pp, ", ");
    3005        24053 :           dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
    3006        24053 :           pp_greater (pp);
    3007              :         }
    3008              :       break;
    3009              : 
    3010            0 :     case BIT_INSERT_EXPR:
    3011            0 :       pp_string (pp, "BIT_INSERT_EXPR <");
    3012            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3013            0 :       pp_string (pp, ", ");
    3014            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    3015            0 :       pp_string (pp, ", ");
    3016            0 :       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
    3017            0 :       pp_string (pp, " (");
    3018            0 :       if (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (node, 1))))
    3019            0 :         pp_decimal_int (pp,
    3020              :                         TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (node, 1))));
    3021              :       else
    3022            0 :         dump_generic_node (pp, TYPE_SIZE (TREE_TYPE (TREE_OPERAND (node, 1))),
    3023              :                            spc, flags, false);
    3024            0 :       pp_string (pp, " bits)>");
    3025            0 :       break;
    3026              : 
    3027      2039927 :     case ARRAY_REF:
    3028      2039927 :     case ARRAY_RANGE_REF:
    3029      2039927 :       op0 = TREE_OPERAND (node, 0);
    3030      2039927 :       if (op_prio (op0) < op_prio (node))
    3031         9617 :         pp_left_paren (pp);
    3032      2039927 :       dump_generic_node (pp, op0, spc, flags, false);
    3033      2039927 :       if (op_prio (op0) < op_prio (node))
    3034         9617 :         pp_right_paren (pp);
    3035      2039927 :       pp_left_bracket (pp);
    3036      2039927 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    3037      2039927 :       if (TREE_CODE (node) == ARRAY_RANGE_REF)
    3038          134 :         pp_string (pp, " ...");
    3039      2039927 :       pp_right_bracket (pp);
    3040              : 
    3041      2039927 :       op0 = array_ref_low_bound (node);
    3042      2039927 :       op1 = array_ref_element_size (node);
    3043              : 
    3044      2039927 :       if (!integer_zerop (op0)
    3045      2018831 :           || TREE_OPERAND (node, 2)
    3046      4058758 :           || TREE_OPERAND (node, 3))
    3047              :         {
    3048        21136 :           pp_string (pp, "{lb: ");
    3049        21136 :           dump_generic_node (pp, op0, spc, flags, false);
    3050        21136 :           pp_string (pp, " sz: ");
    3051        21136 :           dump_generic_node (pp, op1, spc, flags, false);
    3052        21136 :           pp_right_brace (pp);
    3053              :         }
    3054              :       break;
    3055              : 
    3056           13 :     case OMP_ARRAY_SECTION:
    3057           13 :       op0 = TREE_OPERAND (node, 0);
    3058           13 :       if (op_prio (op0) < op_prio (node))
    3059           13 :         pp_left_paren (pp);
    3060           13 :       dump_generic_node (pp, op0, spc, flags, false);
    3061           13 :       if (op_prio (op0) < op_prio (node))
    3062           13 :         pp_right_paren (pp);
    3063           13 :       pp_left_bracket (pp);
    3064           13 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    3065           13 :       pp_colon (pp);
    3066           13 :       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
    3067           13 :       pp_right_bracket (pp);
    3068           13 :       break;
    3069              : 
    3070        59472 :     case CONSTRUCTOR:
    3071        59472 :       {
    3072        59472 :         unsigned HOST_WIDE_INT ix;
    3073        59472 :         tree field, val;
    3074        59472 :         bool is_struct_init = false;
    3075        59472 :         bool is_array_init = false;
    3076        59472 :         widest_int curidx;
    3077        59472 :         if (flags & TDF_GIMPLE)
    3078              :           {
    3079            0 :             if (TREE_CLOBBER_P (node))
    3080              :               {
    3081            0 :                 pp_string (pp, "__CLOBBER");
    3082            0 :                 switch (CLOBBER_KIND (node))
    3083              :                   {
    3084            0 :                   case CLOBBER_STORAGE_BEGIN:
    3085            0 :                     pp_string (pp, "(bos)");
    3086            0 :                     break;
    3087            0 :                   case CLOBBER_STORAGE_END:
    3088            0 :                     pp_string (pp, "(eos)");
    3089            0 :                     break;
    3090            0 :                   case CLOBBER_OBJECT_BEGIN:
    3091            0 :                     pp_string (pp, "(bob)");
    3092            0 :                     break;
    3093            0 :                   case CLOBBER_OBJECT_END:
    3094            0 :                     pp_string (pp, "(eob)");
    3095            0 :                     break;
    3096              :                   default:
    3097              :                     break;
    3098              :                   }
    3099            0 :                 break;
    3100              :               }
    3101            0 :             pp_string (pp, "_Literal (");
    3102            0 :             dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
    3103            0 :             pp_string (pp, ") ");
    3104              :           }
    3105        59472 :         pp_left_brace (pp);
    3106        59472 :         if (TREE_CLOBBER_P (node))
    3107              :           {
    3108        23363 :             pp_string (pp, "CLOBBER");
    3109        23363 :             switch (CLOBBER_KIND (node))
    3110              :               {
    3111            0 :               case CLOBBER_STORAGE_BEGIN:
    3112            0 :                 pp_string (pp, "(bos)");
    3113            0 :                 break;
    3114        15725 :               case CLOBBER_STORAGE_END:
    3115        15725 :                 pp_string (pp, "(eos)");
    3116        15725 :                 break;
    3117         1285 :               case CLOBBER_OBJECT_BEGIN:
    3118         1285 :                 pp_string (pp, "(bob)");
    3119         1285 :                 break;
    3120          769 :               case CLOBBER_OBJECT_END:
    3121          769 :                 pp_string (pp, "(eob)");
    3122          769 :                 break;
    3123              :               default:
    3124              :                 break;
    3125              :               }
    3126              :           }
    3127        36109 :         else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
    3128        36109 :                  || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
    3129              :           is_struct_init = true;
    3130        25622 :         else if (TREE_CODE (TREE_TYPE (node)) == ARRAY_TYPE
    3131         6733 :                  && TYPE_DOMAIN (TREE_TYPE (node))
    3132         6733 :                  && TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)))
    3133        32355 :                  && TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node))))
    3134              :                     == INTEGER_CST)
    3135              :           {
    3136         6733 :             tree minv = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (node)));
    3137         6733 :             is_array_init = true;
    3138         6733 :             curidx = wi::to_widest (minv);
    3139              :           }
    3140       231220 :         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
    3141              :           {
    3142       171748 :             if (field)
    3143              :               {
    3144        79733 :                 if (is_struct_init)
    3145              :                   {
    3146        36158 :                     pp_dot (pp);
    3147        36158 :                     dump_generic_node (pp, field, spc, flags, false);
    3148        36158 :                     pp_equal (pp);
    3149              :                   }
    3150        43575 :                 else if (is_array_init
    3151        43575 :                          && (TREE_CODE (field) != INTEGER_CST
    3152        43575 :                              || curidx != wi::to_widest (field)))
    3153              :                   {
    3154           94 :                     pp_left_bracket (pp);
    3155           94 :                     if (TREE_CODE (field) == RANGE_EXPR)
    3156              :                       {
    3157           94 :                         dump_generic_node (pp, TREE_OPERAND (field, 0), spc,
    3158              :                                            flags, false);
    3159           94 :                         pp_string (pp, " ... ");
    3160           94 :                         dump_generic_node (pp, TREE_OPERAND (field, 1), spc,
    3161              :                                            flags, false);
    3162           94 :                         if (TREE_CODE (TREE_OPERAND (field, 1)) == INTEGER_CST)
    3163           94 :                           curidx = wi::to_widest (TREE_OPERAND (field, 1));
    3164              :                       }
    3165              :                     else
    3166            0 :                       dump_generic_node (pp, field, spc, flags, false);
    3167           94 :                     if (TREE_CODE (field) == INTEGER_CST)
    3168            0 :                       curidx = wi::to_widest (field);
    3169           94 :                     pp_string (pp, "]=");
    3170              :                   }
    3171              :               }
    3172       171748 :             if (is_array_init)
    3173        53373 :               curidx += 1;
    3174       171748 :             if (val && TREE_CODE (val) == ADDR_EXPR)
    3175         2640 :               if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
    3176          146 :                 val = TREE_OPERAND (val, 0);
    3177       171748 :             if (val && TREE_CODE (val) == FUNCTION_DECL)
    3178          146 :                 dump_decl_name (pp, val, flags);
    3179              :             else
    3180       171602 :                 dump_generic_node (pp, val, spc, flags, false);
    3181       343496 :             if (ix != CONSTRUCTOR_NELTS (node) - 1)
    3182              :               {
    3183       137629 :                 pp_comma (pp);
    3184       137629 :                 pp_space (pp);
    3185              :               }
    3186              :           }
    3187        59472 :         pp_right_brace (pp);
    3188            0 :       }
    3189        59472 :       break;
    3190              : 
    3191          604 :     case COMPOUND_EXPR:
    3192          604 :       {
    3193          604 :         tree *tp;
    3194          604 :         if (flags & TDF_SLIM)
    3195              :           {
    3196            0 :             pp_string (pp, "<COMPOUND_EXPR>");
    3197            0 :             break;
    3198              :           }
    3199              : 
    3200          604 :         dump_generic_node (pp, TREE_OPERAND (node, 0),
    3201              :                            spc, flags, false);
    3202          604 :         pp_comma (pp);
    3203          604 :         pp_space (pp);
    3204              : 
    3205          604 :         for (tp = &TREE_OPERAND (node, 1);
    3206          627 :              TREE_CODE (*tp) == COMPOUND_EXPR;
    3207           23 :              tp = &TREE_OPERAND (*tp, 1))
    3208              :           {
    3209           23 :             dump_generic_node (pp, TREE_OPERAND (*tp, 0),
    3210              :                                spc, flags, false);
    3211           23 :             pp_comma (pp);
    3212           23 :             pp_space (pp);
    3213              :           }
    3214              : 
    3215          604 :         dump_generic_node (pp, *tp, spc, flags, false);
    3216              :       }
    3217          604 :       break;
    3218              : 
    3219        66195 :     case STATEMENT_LIST:
    3220        66195 :       {
    3221        66195 :         tree_stmt_iterator si;
    3222        66195 :         bool first = true;
    3223              : 
    3224        66195 :         if (flags & TDF_SLIM)
    3225              :           {
    3226            1 :             pp_string (pp, "<STATEMENT_LIST>");
    3227            1 :             break;
    3228              :           }
    3229              : 
    3230       436335 :         for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
    3231              :           {
    3232       370141 :             if (!first)
    3233       304681 :               newline_and_indent (pp, spc);
    3234              :             else
    3235              :               first = false;
    3236       370141 :             dump_generic_node (pp, tsi_stmt (si), spc, flags, true);
    3237              :           }
    3238              :       }
    3239        66194 :       break;
    3240              : 
    3241       212361 :     case MODIFY_EXPR:
    3242       212361 :     case INIT_EXPR:
    3243       212361 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags,
    3244              :                          false);
    3245       212361 :       pp_space (pp);
    3246       212361 :       pp_equal (pp);
    3247       212361 :       pp_space (pp);
    3248       212361 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags,
    3249              :                          false);
    3250       212361 :       break;
    3251              : 
    3252         2187 :     case TARGET_EXPR:
    3253         2187 :       pp_string (pp, "TARGET_EXPR <");
    3254         2187 :       dump_generic_node (pp, TARGET_EXPR_SLOT (node), spc, flags, false);
    3255         2187 :       pp_comma (pp);
    3256         2187 :       pp_space (pp);
    3257         2187 :       dump_generic_node (pp, TARGET_EXPR_INITIAL (node), spc, flags, false);
    3258         2187 :       pp_greater (pp);
    3259         2187 :       break;
    3260              : 
    3261        12293 :     case DECL_EXPR:
    3262        12293 :       print_declaration (pp, DECL_EXPR_DECL (node), spc, flags);
    3263        12293 :       is_stmt = false;
    3264        12293 :       break;
    3265              : 
    3266        49094 :     case COND_EXPR:
    3267        49094 :       if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
    3268              :         {
    3269        44288 :           pp_string (pp, "if (");
    3270        44288 :           dump_generic_node (pp, COND_EXPR_COND (node), spc, flags, false);
    3271        44288 :           pp_right_paren (pp);
    3272              :           /* The lowered cond_exprs should always be printed in full.  */
    3273        44288 :           if (COND_EXPR_THEN (node)
    3274        44288 :               && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
    3275        43412 :                   || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
    3276        16086 :               && COND_EXPR_ELSE (node)
    3277        60373 :               && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
    3278         2384 :                   || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
    3279              :             {
    3280        15195 :               pp_space (pp);
    3281        15195 :               dump_generic_node (pp, COND_EXPR_THEN (node),
    3282              :                                  0, flags, true);
    3283        15195 :               if (!IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
    3284              :                 {
    3285         1494 :                   pp_string (pp, " else ");
    3286         1494 :                   dump_generic_node (pp, COND_EXPR_ELSE (node),
    3287              :                                      0, flags, true);
    3288              :                 }
    3289              :             }
    3290        29093 :           else if (!(flags & TDF_SLIM))
    3291              :             {
    3292              :               /* Output COND_EXPR_THEN.  */
    3293        29093 :               if (COND_EXPR_THEN (node))
    3294              :                 {
    3295        29093 :                   newline_and_indent (pp, spc+2);
    3296        29093 :                   pp_left_brace (pp);
    3297        29093 :                   newline_and_indent (pp, spc+4);
    3298        29093 :                   dump_generic_node (pp, COND_EXPR_THEN (node), spc+4,
    3299              :                                      flags, true);
    3300        29093 :                   newline_and_indent (pp, spc+2);
    3301        29093 :                   pp_right_brace (pp);
    3302              :                 }
    3303              : 
    3304              :               /* Output COND_EXPR_ELSE.  */
    3305        29093 :               if (COND_EXPR_ELSE (node)
    3306        29093 :                   && !IS_EMPTY_STMT (COND_EXPR_ELSE (node)))
    3307              :                 {
    3308         8096 :                   newline_and_indent (pp, spc);
    3309         8096 :                   pp_string (pp, "else");
    3310         8096 :                   newline_and_indent (pp, spc+2);
    3311         8096 :                   pp_left_brace (pp);
    3312         8096 :                   newline_and_indent (pp, spc+4);
    3313         8096 :                   dump_generic_node (pp, COND_EXPR_ELSE (node), spc+4,
    3314              :                                      flags, true);
    3315         8096 :                   newline_and_indent (pp, spc+2);
    3316         8096 :                   pp_right_brace (pp);
    3317              :                 }
    3318              :             }
    3319              :           is_expr = false;
    3320              :         }
    3321              :       else
    3322              :         {
    3323         4806 :           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3324         4806 :           pp_space (pp);
    3325         4806 :           pp_question (pp);
    3326         4806 :           pp_space (pp);
    3327         4806 :           dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    3328         4806 :           pp_space (pp);
    3329         4806 :           pp_colon (pp);
    3330         4806 :           pp_space (pp);
    3331         4806 :           dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
    3332              :         }
    3333              :       break;
    3334              : 
    3335        43411 :     case BIND_EXPR:
    3336        43411 :       pp_left_brace (pp);
    3337        43411 :       if (!(flags & TDF_SLIM))
    3338              :         {
    3339        43411 :           if (BIND_EXPR_VARS (node))
    3340              :             {
    3341        35533 :               pp_newline (pp);
    3342              : 
    3343       152084 :               for (op0 = BIND_EXPR_VARS (node); op0; op0 = DECL_CHAIN (op0))
    3344              :                 {
    3345       116551 :                   print_declaration (pp, op0, spc+2, flags);
    3346       116551 :                   pp_newline (pp);
    3347              :                 }
    3348              :             }
    3349              : 
    3350        43411 :           newline_and_indent (pp, spc+2);
    3351        43411 :           dump_generic_node (pp, BIND_EXPR_BODY (node), spc+2, flags, true);
    3352        43411 :           newline_and_indent (pp, spc);
    3353        43411 :           pp_right_brace (pp);
    3354              :         }
    3355              :       is_expr = false;
    3356              :       break;
    3357              : 
    3358        66804 :     case CALL_EXPR:
    3359        66804 :       if (CALL_EXPR_FN (node) != NULL_TREE)
    3360        66650 :         print_call_name (pp, CALL_EXPR_FN (node), flags);
    3361              :       else
    3362              :         {
    3363          154 :           pp_dot (pp);
    3364          154 :           pp_string (pp, internal_fn_name (CALL_EXPR_IFN (node)));
    3365              :         }
    3366              : 
    3367              :       /* Print parameters.  */
    3368        66804 :       pp_space (pp);
    3369        66804 :       pp_left_paren (pp);
    3370        66804 :       {
    3371        66804 :         tree arg;
    3372        66804 :         call_expr_arg_iterator iter;
    3373       256647 :         FOR_EACH_CALL_EXPR_ARG (arg, iter, node)
    3374              :           {
    3375       123039 :             dump_generic_node (pp, arg, spc, flags, false);
    3376       123039 :             if (more_call_expr_args_p (&iter))
    3377              :               {
    3378        63577 :                 pp_comma (pp);
    3379        63577 :                 pp_space (pp);
    3380              :               }
    3381              :           }
    3382              :       }
    3383        66804 :       if (CALL_EXPR_VA_ARG_PACK (node))
    3384              :         {
    3385            0 :           if (call_expr_nargs (node) > 0)
    3386              :             {
    3387            0 :               pp_comma (pp);
    3388            0 :               pp_space (pp);
    3389              :             }
    3390            0 :           pp_string (pp, "__builtin_va_arg_pack ()");
    3391              :         }
    3392        66804 :       pp_right_paren (pp);
    3393              : 
    3394        66804 :       op1 = CALL_EXPR_STATIC_CHAIN (node);
    3395        66804 :       if (op1)
    3396              :         {
    3397            0 :           pp_string (pp, " [static-chain: ");
    3398            0 :           dump_generic_node (pp, op1, spc, flags, false);
    3399            0 :           pp_right_bracket (pp);
    3400              :         }
    3401              : 
    3402        66804 :       if (CALL_EXPR_RETURN_SLOT_OPT (node))
    3403            0 :         pp_string (pp, " [return slot optimization]");
    3404        66804 :       if (CALL_EXPR_TAILCALL (node))
    3405            0 :         pp_string (pp, " [tail call]");
    3406        66804 :       if (CALL_EXPR_MUST_TAIL_CALL (node))
    3407            0 :         pp_string (pp, " [must tail call]");
    3408              :       break;
    3409              : 
    3410            0 :     case WITH_CLEANUP_EXPR:
    3411            0 :       NIY;
    3412            0 :       break;
    3413              : 
    3414        16913 :     case CLEANUP_POINT_EXPR:
    3415        16913 :       pp_string (pp, "<<cleanup_point ");
    3416        16913 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3417        16913 :       pp_string (pp, ">>");
    3418        16913 :       break;
    3419              : 
    3420            0 :     case PLACEHOLDER_EXPR:
    3421            0 :       pp_string (pp, "<PLACEHOLDER_EXPR ");
    3422            0 :       dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
    3423            0 :       pp_greater (pp);
    3424            0 :       break;
    3425              : 
    3426              :       /* Binary arithmetic and logic expressions.  */
    3427       261086 :     case WIDEN_SUM_EXPR:
    3428       261086 :     case WIDEN_MULT_EXPR:
    3429       261086 :     case MULT_EXPR:
    3430       261086 :     case MULT_HIGHPART_EXPR:
    3431       261086 :     case PLUS_EXPR:
    3432       261086 :     case POINTER_PLUS_EXPR:
    3433       261086 :     case POINTER_DIFF_EXPR:
    3434       261086 :     case MINUS_EXPR:
    3435       261086 :     case TRUNC_DIV_EXPR:
    3436       261086 :     case CEIL_DIV_EXPR:
    3437       261086 :     case FLOOR_DIV_EXPR:
    3438       261086 :     case ROUND_DIV_EXPR:
    3439       261086 :     case TRUNC_MOD_EXPR:
    3440       261086 :     case CEIL_MOD_EXPR:
    3441       261086 :     case FLOOR_MOD_EXPR:
    3442       261086 :     case ROUND_MOD_EXPR:
    3443       261086 :     case RDIV_EXPR:
    3444       261086 :     case EXACT_DIV_EXPR:
    3445       261086 :     case LSHIFT_EXPR:
    3446       261086 :     case RSHIFT_EXPR:
    3447       261086 :     case LROTATE_EXPR:
    3448       261086 :     case RROTATE_EXPR:
    3449       261086 :     case WIDEN_LSHIFT_EXPR:
    3450       261086 :     case BIT_IOR_EXPR:
    3451       261086 :     case BIT_XOR_EXPR:
    3452       261086 :     case BIT_AND_EXPR:
    3453       261086 :     case TRUTH_ANDIF_EXPR:
    3454       261086 :     case TRUTH_ORIF_EXPR:
    3455       261086 :     case TRUTH_AND_EXPR:
    3456       261086 :     case TRUTH_OR_EXPR:
    3457       261086 :     case TRUTH_XOR_EXPR:
    3458       261086 :     case LT_EXPR:
    3459       261086 :     case LE_EXPR:
    3460       261086 :     case GT_EXPR:
    3461       261086 :     case GE_EXPR:
    3462       261086 :     case EQ_EXPR:
    3463       261086 :     case NE_EXPR:
    3464       261086 :     case UNLT_EXPR:
    3465       261086 :     case UNLE_EXPR:
    3466       261086 :     case UNGT_EXPR:
    3467       261086 :     case UNGE_EXPR:
    3468       261086 :     case UNEQ_EXPR:
    3469       261086 :     case LTGT_EXPR:
    3470       261086 :     case ORDERED_EXPR:
    3471       261086 :     case UNORDERED_EXPR:
    3472       261086 :       {
    3473       522172 :         const char *op = op_symbol (node);
    3474       261086 :         op0 = TREE_OPERAND (node, 0);
    3475       261086 :         op1 = TREE_OPERAND (node, 1);
    3476              : 
    3477              :         /* When the operands are expressions with less priority,
    3478              :            keep semantics of the tree representation.  */
    3479       261086 :         if (op_prio (op0) <= op_prio (node))
    3480              :           {
    3481        35517 :             pp_left_paren (pp);
    3482        35517 :             dump_generic_node (pp, op0, spc, flags, false);
    3483        35517 :             pp_right_paren (pp);
    3484              :           }
    3485              :         else
    3486       225569 :           dump_generic_node (pp, op0, spc, flags, false);
    3487              : 
    3488       261086 :         pp_space (pp);
    3489       261086 :         pp_string (pp, op);
    3490       261086 :         pp_space (pp);
    3491              : 
    3492              :         /* When the operands are expressions with less priority,
    3493              :            keep semantics of the tree representation.  */
    3494       261086 :         if (op_prio (op1) <= op_prio (node))
    3495              :           {
    3496         3118 :             pp_left_paren (pp);
    3497         3118 :             dump_generic_node (pp, op1, spc, flags, false);
    3498         3118 :             pp_right_paren (pp);
    3499              :           }
    3500              :         else
    3501       257968 :           dump_generic_node (pp, op1, spc, flags, false);
    3502              :       }
    3503              :       break;
    3504              : 
    3505              :       /* Unary arithmetic and logic expressions.  */
    3506       330521 :     case ADDR_EXPR:
    3507       330521 :       if (flags & TDF_GIMPLE_VAL)
    3508              :         {
    3509            0 :           pp_string (pp, "_Literal (");
    3510            0 :           dump_generic_node (pp, TREE_TYPE (node), spc,
    3511              :                              flags & ~TDF_GIMPLE_VAL, false);
    3512            0 :           pp_character (pp, ')');
    3513              :         }
    3514              :       /* Fallthru.  */
    3515       358112 :     case NEGATE_EXPR:
    3516       358112 :     case BIT_NOT_EXPR:
    3517       358112 :     case TRUTH_NOT_EXPR:
    3518       358112 :     case PREDECREMENT_EXPR:
    3519       358112 :     case PREINCREMENT_EXPR:
    3520       358112 :     case INDIRECT_REF:
    3521       358112 :       if (!(flags & TDF_GIMPLE)
    3522       358112 :           && TREE_CODE (node) == ADDR_EXPR
    3523       688633 :           && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
    3524       323868 :               || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
    3525              :         /* Do not output '&' for strings and function pointers when not
    3526              :            dumping GIMPLE FE syntax.  */
    3527              :         ;
    3528              :       else
    3529       341493 :         pp_string (pp, op_symbol (node));
    3530              : 
    3531       358112 :       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
    3532              :         {
    3533         4086 :           pp_left_paren (pp);
    3534         4086 :           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3535         4086 :           pp_right_paren (pp);
    3536              :         }
    3537              :       else
    3538       354026 :         dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3539              :       break;
    3540              : 
    3541         1535 :     case POSTDECREMENT_EXPR:
    3542         1535 :     case POSTINCREMENT_EXPR:
    3543         1535 :       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
    3544              :         {
    3545            0 :           pp_left_paren (pp);
    3546            0 :           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3547            0 :           pp_right_paren (pp);
    3548              :         }
    3549              :       else
    3550         1535 :         dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3551         3070 :       pp_string (pp, op_symbol (node));
    3552         1535 :       break;
    3553              : 
    3554          368 :     case MIN_EXPR:
    3555          368 :       pp_string (pp, "MIN_EXPR <");
    3556          368 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3557          368 :       pp_string (pp, ", ");
    3558          368 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    3559          368 :       pp_greater (pp);
    3560          368 :       break;
    3561              : 
    3562         6096 :     case MAX_EXPR:
    3563         6096 :       pp_string (pp, "MAX_EXPR <");
    3564         6096 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3565         6096 :       pp_string (pp, ", ");
    3566         6096 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    3567         6096 :       pp_greater (pp);
    3568         6096 :       break;
    3569              : 
    3570          529 :     case ABS_EXPR:
    3571          529 :       pp_string (pp, "ABS_EXPR <");
    3572          529 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3573          529 :       pp_greater (pp);
    3574          529 :       break;
    3575              : 
    3576           24 :     case ABSU_EXPR:
    3577           24 :       pp_string (pp, "ABSU_EXPR <");
    3578           24 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3579           24 :       pp_greater (pp);
    3580           24 :       break;
    3581              : 
    3582            0 :     case RANGE_EXPR:
    3583            0 :       NIY;
    3584            0 :       break;
    3585              : 
    3586       181185 :     case ADDR_SPACE_CONVERT_EXPR:
    3587       181185 :     case FIXED_CONVERT_EXPR:
    3588       181185 :     case FIX_TRUNC_EXPR:
    3589       181185 :     case FLOAT_EXPR:
    3590       181185 :     CASE_CONVERT:
    3591       181185 :       type = TREE_TYPE (node);
    3592       181185 :       op0 = TREE_OPERAND (node, 0);
    3593       181185 :       if (type != TREE_TYPE (op0))
    3594              :         {
    3595       181163 :           pp_left_paren (pp);
    3596       181163 :           dump_generic_node (pp, type, spc, flags, false);
    3597       181163 :           pp_string (pp, ") ");
    3598              :         }
    3599       181185 :       if (op_prio (op0) < op_prio (node))
    3600        38912 :         pp_left_paren (pp);
    3601       181185 :       dump_generic_node (pp, op0, spc, flags, false);
    3602       181185 :       if (op_prio (op0) < op_prio (node))
    3603        38912 :         pp_right_paren (pp);
    3604              :       break;
    3605              : 
    3606        38453 :     case VIEW_CONVERT_EXPR:
    3607        38453 :       if (flags & TDF_GIMPLE)
    3608            0 :         pp_string (pp, "__VIEW_CONVERT <");
    3609              :       else
    3610        38453 :         pp_string (pp, "VIEW_CONVERT_EXPR<");
    3611        38453 :       dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
    3612        38453 :       pp_string (pp, ">(");
    3613        38453 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3614        38453 :       pp_right_paren (pp);
    3615        38453 :       break;
    3616              : 
    3617           14 :     case PAREN_EXPR:
    3618           14 :       pp_string (pp, "((");
    3619           14 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3620           14 :       pp_string (pp, "))");
    3621           14 :       break;
    3622              : 
    3623        17398 :     case NON_LVALUE_EXPR:
    3624        17398 :       pp_string (pp, "NON_LVALUE_EXPR <");
    3625        17398 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3626        17398 :       pp_greater (pp);
    3627        17398 :       break;
    3628              : 
    3629         1582 :     case SAVE_EXPR:
    3630         1582 :       pp_string (pp, "SAVE_EXPR <");
    3631         1582 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3632         1582 :       pp_greater (pp);
    3633         1582 :       break;
    3634              : 
    3635           26 :     case COMPLEX_EXPR:
    3636           26 :       pp_string (pp, "COMPLEX_EXPR <");
    3637           26 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3638           26 :       pp_string (pp, ", ");
    3639           26 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    3640           26 :       pp_greater (pp);
    3641           26 :       break;
    3642              : 
    3643            0 :     case CONJ_EXPR:
    3644            0 :       pp_string (pp, "CONJ_EXPR <");
    3645            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3646            0 :       pp_greater (pp);
    3647            0 :       break;
    3648              : 
    3649        51194 :     case REALPART_EXPR:
    3650        51194 :       if (flags & TDF_GIMPLE)
    3651              :         {
    3652            1 :           pp_string (pp, "__real ");
    3653            1 :           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3654              :         }
    3655              :       else
    3656              :         {
    3657        51193 :           pp_string (pp, "REALPART_EXPR <");
    3658        51193 :           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3659        51193 :           pp_greater (pp);
    3660              :         }
    3661              :       break;
    3662              : 
    3663        41376 :     case IMAGPART_EXPR:
    3664        41376 :       if (flags & TDF_GIMPLE)
    3665              :         {
    3666            1 :           pp_string (pp, "__imag ");
    3667            1 :           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3668              :         }
    3669              :       else
    3670              :         {
    3671        41375 :           pp_string (pp, "IMAGPART_EXPR <");
    3672        41375 :           dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3673        41375 :           pp_greater (pp);
    3674              :         }
    3675              :       break;
    3676              : 
    3677            0 :     case VA_ARG_EXPR:
    3678            0 :       pp_string (pp, "VA_ARG_EXPR <");
    3679            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3680            0 :       pp_greater (pp);
    3681            0 :       break;
    3682              : 
    3683         1618 :     case TRY_FINALLY_EXPR:
    3684         1618 :     case TRY_CATCH_EXPR:
    3685         1618 :       pp_string (pp, "try");
    3686         1618 :       newline_and_indent (pp, spc+2);
    3687         1618 :       pp_left_brace (pp);
    3688         1618 :       newline_and_indent (pp, spc+4);
    3689         1618 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4, flags, true);
    3690         1618 :       newline_and_indent (pp, spc+2);
    3691         1618 :       pp_right_brace (pp);
    3692         1618 :       newline_and_indent (pp, spc);
    3693         1618 :       if (TREE_CODE (node) == TRY_CATCH_EXPR)
    3694              :         {
    3695           79 :           node = TREE_OPERAND (node, 1);
    3696           79 :           pp_string (pp, "catch");
    3697              :         }
    3698              :       else
    3699              :         {
    3700         1539 :           gcc_assert (TREE_CODE (node) == TRY_FINALLY_EXPR);
    3701         1539 :           node = TREE_OPERAND (node, 1);
    3702         1539 :           pp_string (pp, "finally");
    3703         1539 :           if (TREE_CODE (node) == EH_ELSE_EXPR)
    3704              :             {
    3705            0 :               newline_and_indent (pp, spc+2);
    3706            0 :               pp_left_brace (pp);
    3707            0 :               newline_and_indent (pp, spc+4);
    3708            0 :               dump_generic_node (pp, TREE_OPERAND (node, 0), spc+4,
    3709              :                                  flags, true);
    3710            0 :               newline_and_indent (pp, spc+2);
    3711            0 :               pp_right_brace (pp);
    3712            0 :               newline_and_indent (pp, spc);
    3713            0 :               node = TREE_OPERAND (node, 1);
    3714            0 :               pp_string (pp, "else");
    3715              :             }
    3716              :         }
    3717         1618 :       newline_and_indent (pp, spc+2);
    3718         1618 :       pp_left_brace (pp);
    3719         1618 :       newline_and_indent (pp, spc+4);
    3720         1618 :       dump_generic_node (pp, node, spc+4, flags, true);
    3721         1618 :       newline_and_indent (pp, spc+2);
    3722         1618 :       pp_right_brace (pp);
    3723         1618 :       is_expr = false;
    3724         1618 :       break;
    3725              : 
    3726            0 :     case CATCH_EXPR:
    3727            0 :       pp_string (pp, "catch (");
    3728            0 :       dump_generic_node (pp, CATCH_TYPES (node), spc+2, flags, false);
    3729            0 :       pp_right_paren (pp);
    3730            0 :       newline_and_indent (pp, spc+2);
    3731            0 :       pp_left_brace (pp);
    3732            0 :       newline_and_indent (pp, spc+4);
    3733            0 :       dump_generic_node (pp, CATCH_BODY (node), spc+4, flags, true);
    3734            0 :       newline_and_indent (pp, spc+2);
    3735            0 :       pp_right_brace (pp);
    3736            0 :       is_expr = false;
    3737            0 :       break;
    3738              : 
    3739            0 :     case EH_FILTER_EXPR:
    3740            0 :       pp_string (pp, "<<<eh_filter (");
    3741            0 :       dump_generic_node (pp, EH_FILTER_TYPES (node), spc+2, flags, false);
    3742            0 :       pp_string (pp, ")>>>");
    3743            0 :       newline_and_indent (pp, spc+2);
    3744            0 :       pp_left_brace (pp);
    3745            0 :       newline_and_indent (pp, spc+4);
    3746            0 :       dump_generic_node (pp, EH_FILTER_FAILURE (node), spc+4, flags, true);
    3747            0 :       newline_and_indent (pp, spc+2);
    3748            0 :       pp_right_brace (pp);
    3749            0 :       is_expr = false;
    3750            0 :       break;
    3751              : 
    3752        33221 :     case LABEL_EXPR:
    3753        33221 :       op0 = TREE_OPERAND (node, 0);
    3754              :       /* If this is for break or continue, don't bother printing it.  */
    3755        33221 :       if (DECL_NAME (op0))
    3756              :         {
    3757        28708 :           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
    3758        28708 :           if (strcmp (name, "break") == 0
    3759        28708 :               || strcmp (name, "continue") == 0)
    3760              :             break;
    3761              :         }
    3762        33221 :       dump_generic_node (pp, op0, spc, flags, false);
    3763        33221 :       pp_colon (pp);
    3764        33221 :       if (DECL_NONLOCAL (op0))
    3765            0 :         pp_string (pp, " [non-local]");
    3766              :       break;
    3767              : 
    3768        10671 :     case LOOP_EXPR:
    3769        10671 :       pp_string (pp, "while (1)");
    3770        10671 :       if (!(flags & TDF_SLIM))
    3771              :         {
    3772        10671 :           newline_and_indent (pp, spc+2);
    3773        10671 :           pp_left_brace (pp);
    3774        10671 :           newline_and_indent (pp, spc+4);
    3775        10671 :           dump_generic_node (pp, LOOP_EXPR_BODY (node), spc+4, flags, true);
    3776        10671 :           newline_and_indent (pp, spc+2);
    3777        10671 :           pp_right_brace (pp);
    3778              :         }
    3779              :       is_expr = false;
    3780              :       break;
    3781              : 
    3782           26 :     case PREDICT_EXPR:
    3783           26 :       pp_string (pp, "// predicted ");
    3784           26 :       if (PREDICT_EXPR_OUTCOME (node))
    3785            7 :         pp_string (pp, "likely by ");
    3786              :       else
    3787           19 :         pp_string (pp, "unlikely by ");
    3788           26 :       pp_string (pp, predictor_name (PREDICT_EXPR_PREDICTOR (node)));
    3789           26 :       pp_string (pp, " predictor.");
    3790           26 :       break;
    3791              : 
    3792           52 :     case ANNOTATE_EXPR:
    3793           52 :       pp_string (pp, "ANNOTATE_EXPR <");
    3794           52 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3795           52 :       switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (node, 1)))
    3796              :         {
    3797           44 :         case annot_expr_ivdep_kind:
    3798           44 :           pp_string (pp, ", ivdep");
    3799           44 :           break;
    3800            2 :         case annot_expr_unroll_kind:
    3801            2 :           {
    3802            2 :             pp_string (pp, ", unroll ");
    3803            2 :             pp_decimal_int (pp,
    3804              :                             (int) TREE_INT_CST_LOW (TREE_OPERAND (node, 2)));
    3805            2 :             break;
    3806              :           }
    3807            3 :         case annot_expr_no_vector_kind:
    3808            3 :           pp_string (pp, ", no-vector");
    3809            3 :           break;
    3810            3 :         case annot_expr_vector_kind:
    3811            3 :           pp_string (pp, ", vector");
    3812            3 :           break;
    3813            0 :         case annot_expr_parallel_kind:
    3814            0 :           pp_string (pp, ", parallel");
    3815            0 :           break;
    3816            0 :         case annot_expr_maybe_infinite_kind:
    3817            0 :           pp_string (pp, ", maybe-infinite");
    3818            0 :           break;
    3819            0 :         default:
    3820            0 :           gcc_unreachable ();
    3821              :         }
    3822           52 :       pp_greater (pp);
    3823           52 :       break;
    3824              : 
    3825         9797 :     case RETURN_EXPR:
    3826         9797 :       pp_string (pp, "return");
    3827         9797 :       op0 = TREE_OPERAND (node, 0);
    3828         9797 :       if (op0)
    3829              :         {
    3830         9610 :           pp_space (pp);
    3831         9610 :           if (TREE_CODE (op0) == MODIFY_EXPR)
    3832         2840 :             dump_generic_node (pp, TREE_OPERAND (op0, 1),
    3833              :                                spc, flags, false);
    3834              :           else
    3835         6770 :             dump_generic_node (pp, op0, spc, flags, false);
    3836              :         }
    3837              :       break;
    3838              : 
    3839            0 :     case EXIT_EXPR:
    3840            0 :       pp_string (pp, "if (");
    3841            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3842            0 :       pp_string (pp, ") break");
    3843            0 :       break;
    3844              : 
    3845           66 :     case SWITCH_EXPR:
    3846           66 :       pp_string (pp, "switch (");
    3847           66 :       dump_generic_node (pp, SWITCH_COND (node), spc, flags, false);
    3848           66 :       pp_right_paren (pp);
    3849           66 :       if (!(flags & TDF_SLIM))
    3850              :         {
    3851           66 :           newline_and_indent (pp, spc+2);
    3852           66 :           pp_left_brace (pp);
    3853           66 :           if (SWITCH_BODY (node))
    3854              :             {
    3855           66 :               newline_and_indent (pp, spc+4);
    3856           66 :               dump_generic_node (pp, SWITCH_BODY (node), spc+4, flags,
    3857              :                                  true);
    3858              :             }
    3859           66 :           newline_and_indent (pp, spc+2);
    3860           66 :           pp_right_brace (pp);
    3861              :         }
    3862              :       is_expr = false;
    3863              :       break;
    3864              : 
    3865        22823 :     case GOTO_EXPR:
    3866        22823 :       op0 = GOTO_DESTINATION (node);
    3867        22823 :       if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
    3868              :         {
    3869        18038 :           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
    3870        18038 :           if (strcmp (name, "break") == 0
    3871        18038 :               || strcmp (name, "continue") == 0)
    3872              :             {
    3873            0 :               pp_string (pp, name);
    3874            0 :               break;
    3875              :             }
    3876              :         }
    3877        22823 :       pp_string (pp, "goto ");
    3878        22823 :       dump_generic_node (pp, op0, spc, flags, false);
    3879        22823 :       break;
    3880              : 
    3881          292 :     case ASM_EXPR:
    3882          292 :       pp_string (pp, "__asm__");
    3883          292 :       if (ASM_VOLATILE_P (node))
    3884          292 :         pp_string (pp, " __volatile__");
    3885          292 :       pp_left_paren (pp);
    3886          292 :       dump_generic_node (pp, ASM_STRING (node), spc, flags, false);
    3887          292 :       pp_colon (pp);
    3888          292 :       dump_generic_node (pp, ASM_OUTPUTS (node), spc, flags, false);
    3889          292 :       pp_colon (pp);
    3890          292 :       dump_generic_node (pp, ASM_INPUTS (node), spc, flags, false);
    3891          292 :       if (ASM_CLOBBERS (node))
    3892              :         {
    3893          292 :           pp_colon (pp);
    3894          292 :           dump_generic_node (pp, ASM_CLOBBERS (node), spc, flags, false);
    3895              :         }
    3896          292 :       pp_right_paren (pp);
    3897          292 :       break;
    3898              : 
    3899         8975 :     case CASE_LABEL_EXPR:
    3900         8975 :       if (CASE_LOW (node) && CASE_HIGH (node))
    3901              :         {
    3902          121 :           pp_string (pp, "case ");
    3903          121 :           dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
    3904          121 :           pp_string (pp, " ... ");
    3905          121 :           dump_generic_node (pp, CASE_HIGH (node), spc, flags, false);
    3906              :         }
    3907         8854 :       else if (CASE_LOW (node))
    3908              :         {
    3909         7312 :           pp_string (pp, "case ");
    3910         7312 :           dump_generic_node (pp, CASE_LOW (node), spc, flags, false);
    3911              :         }
    3912              :       else
    3913         1542 :         pp_string (pp, "default");
    3914         8975 :       pp_colon (pp);
    3915         8975 :       break;
    3916              : 
    3917         1782 :     case OBJ_TYPE_REF:
    3918         1782 :       pp_string (pp, "OBJ_TYPE_REF(");
    3919         1782 :       dump_generic_node (pp, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
    3920         1782 :       pp_semicolon (pp);
    3921              :       /* We omit the class type for -fcompare-debug because we may
    3922              :          drop TYPE_BINFO early depending on debug info, and then
    3923              :          virtual_method_call_p would return false, whereas when
    3924              :          TYPE_BINFO is preserved it may still return true and then
    3925              :          we'd print the class type.  Compare tree and rtl dumps for
    3926              :          libstdc++-prettyprinters/shared_ptr.cc with and without -g,
    3927              :          for example, at occurrences of OBJ_TYPE_REF.  */
    3928         1782 :       if (!(flags & (TDF_SLIM | TDF_COMPARE_DEBUG))
    3929         1782 :           && virtual_method_call_p (node, true))
    3930              :         {
    3931         1479 :           pp_string (pp, "(");
    3932         1479 :           dump_generic_node (pp, obj_type_ref_class (node, true),
    3933              :                              spc, flags, false);
    3934         1479 :           pp_string (pp, ")");
    3935              :         }
    3936         1782 :       dump_generic_node (pp, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
    3937         1782 :       pp_arrow (pp);
    3938         1782 :       dump_generic_node (pp, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
    3939         1782 :       pp_right_paren (pp);
    3940         1782 :       break;
    3941              : 
    3942     17709474 :     case SSA_NAME:
    3943     17709474 :       if (SSA_NAME_IDENTIFIER (node))
    3944              :         {
    3945     10167682 :           if ((flags & TDF_NOUID)
    3946         7613 :               && SSA_NAME_VAR (node)
    3947     10172422 :               && DECL_NAMELESS (SSA_NAME_VAR (node)))
    3948         1202 :             dump_fancy_name (pp, SSA_NAME_IDENTIFIER (node));
    3949     10166480 :           else if (! (flags & TDF_GIMPLE)
    3950     10166480 :                    || SSA_NAME_VAR (node))
    3951     10166480 :             dump_generic_node (pp, SSA_NAME_IDENTIFIER (node),
    3952              :                                spc, flags, false);
    3953              :         }
    3954     17709474 :       pp_underscore (pp);
    3955     17709474 :       pp_decimal_int (pp, SSA_NAME_VERSION (node));
    3956     17709474 :       if (SSA_NAME_IS_DEFAULT_DEF (node))
    3957       723562 :         pp_string (pp, "(D)");
    3958     17709474 :       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
    3959          578 :         pp_string (pp, "(ab)");
    3960              :       break;
    3961              : 
    3962            0 :     case WITH_SIZE_EXPR:
    3963            0 :       pp_string (pp, "WITH_SIZE_EXPR <");
    3964            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3965            0 :       pp_string (pp, ", ");
    3966            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    3967            0 :       pp_greater (pp);
    3968            0 :       break;
    3969              : 
    3970            0 :     case SCEV_KNOWN:
    3971            0 :       pp_string (pp, "scev_known");
    3972            0 :       break;
    3973              : 
    3974         4803 :     case SCEV_NOT_KNOWN:
    3975         4803 :       pp_string (pp, "scev_not_known");
    3976         4803 :       break;
    3977              : 
    3978       151160 :     case POLYNOMIAL_CHREC:
    3979       151160 :       pp_left_brace (pp);
    3980       151160 :       dump_generic_node (pp, CHREC_LEFT (node), spc, flags, false);
    3981       151160 :       pp_string (pp, ", +, ");
    3982       151160 :       dump_generic_node (pp, CHREC_RIGHT (node), spc, flags, false);
    3983       160007 :       pp_string (pp, !CHREC_NOWRAP (node) ? "}_" : "}<nw>_");
    3984       151160 :       pp_scalar (pp, "%u", CHREC_VARIABLE (node));
    3985       151160 :       is_stmt = false;
    3986       151160 :       break;
    3987              : 
    3988            0 :     case REALIGN_LOAD_EXPR:
    3989            0 :       pp_string (pp, "REALIGN_LOAD <");
    3990            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    3991            0 :       pp_string (pp, ", ");
    3992            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    3993            0 :       pp_string (pp, ", ");
    3994            0 :       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
    3995            0 :       pp_greater (pp);
    3996            0 :       break;
    3997              : 
    3998            0 :     case VEC_COND_EXPR:
    3999            0 :       pp_string (pp, " VEC_COND_EXPR < ");
    4000            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4001            0 :       pp_string (pp, " , ");
    4002            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    4003            0 :       pp_string (pp, " , ");
    4004            0 :       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
    4005            0 :       pp_string (pp, " > ");
    4006            0 :       break;
    4007              : 
    4008            0 :     case VEC_PERM_EXPR:
    4009            0 :       pp_string (pp, " VEC_PERM_EXPR < ");
    4010            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4011            0 :       pp_string (pp, " , ");
    4012            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    4013            0 :       pp_string (pp, " , ");
    4014            0 :       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
    4015            0 :       pp_string (pp, " > ");
    4016            0 :       break;
    4017              : 
    4018            0 :     case DOT_PROD_EXPR:
    4019            0 :       pp_string (pp, " DOT_PROD_EXPR < ");
    4020            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4021            0 :       pp_string (pp, ", ");
    4022            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    4023            0 :       pp_string (pp, ", ");
    4024            0 :       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
    4025            0 :       pp_string (pp, " > ");
    4026            0 :       break;
    4027              : 
    4028            0 :     case WIDEN_MULT_PLUS_EXPR:
    4029            0 :       pp_string (pp, " WIDEN_MULT_PLUS_EXPR < ");
    4030            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4031            0 :       pp_string (pp, ", ");
    4032            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    4033            0 :       pp_string (pp, ", ");
    4034            0 :       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
    4035            0 :       pp_string (pp, " > ");
    4036            0 :       break;
    4037              : 
    4038            0 :     case WIDEN_MULT_MINUS_EXPR:
    4039            0 :       pp_string (pp, " WIDEN_MULT_MINUS_EXPR < ");
    4040            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4041            0 :       pp_string (pp, ", ");
    4042            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    4043            0 :       pp_string (pp, ", ");
    4044            0 :       dump_generic_node (pp, TREE_OPERAND (node, 2), spc, flags, false);
    4045            0 :       pp_string (pp, " > ");
    4046            0 :       break;
    4047              : 
    4048          117 :     case OACC_PARALLEL:
    4049          117 :       pp_string (pp, "#pragma acc parallel");
    4050          117 :       goto dump_omp_clauses_body;
    4051              : 
    4052           57 :     case OACC_KERNELS:
    4053           57 :       pp_string (pp, "#pragma acc kernels");
    4054           57 :       goto dump_omp_clauses_body;
    4055              : 
    4056           58 :     case OACC_SERIAL:
    4057           58 :       pp_string (pp, "#pragma acc serial");
    4058           58 :       goto dump_omp_clauses_body;
    4059              : 
    4060           21 :     case OACC_DATA:
    4061           21 :       pp_string (pp, "#pragma acc data");
    4062           21 :       dump_omp_clauses (pp, OACC_DATA_CLAUSES (node), spc, flags);
    4063           21 :       goto dump_omp_body;
    4064              : 
    4065           35 :     case OACC_HOST_DATA:
    4066           35 :       pp_string (pp, "#pragma acc host_data");
    4067           35 :       dump_omp_clauses (pp, OACC_HOST_DATA_CLAUSES (node), spc, flags);
    4068           35 :       goto dump_omp_body;
    4069              : 
    4070            4 :     case OACC_DECLARE:
    4071            4 :       pp_string (pp, "#pragma acc declare");
    4072            4 :       dump_omp_clauses (pp, OACC_DECLARE_CLAUSES (node), spc, flags);
    4073            4 :       break;
    4074              : 
    4075            0 :     case OACC_UPDATE:
    4076            0 :       pp_string (pp, "#pragma acc update");
    4077            0 :       dump_omp_clauses (pp, OACC_UPDATE_CLAUSES (node), spc, flags);
    4078            0 :       break;
    4079              : 
    4080           13 :     case OACC_ENTER_DATA:
    4081           13 :       pp_string (pp, "#pragma acc enter data");
    4082           13 :       dump_omp_clauses (pp, OACC_ENTER_DATA_CLAUSES (node), spc, flags);
    4083           13 :       break;
    4084              : 
    4085           38 :     case OACC_EXIT_DATA:
    4086           38 :       pp_string (pp, "#pragma acc exit data");
    4087           38 :       dump_omp_clauses (pp, OACC_EXIT_DATA_CLAUSES (node), spc, flags);
    4088           38 :       break;
    4089              : 
    4090           48 :     case OACC_CACHE:
    4091           48 :       pp_string (pp, "#pragma acc cache");
    4092           48 :       dump_omp_clauses (pp, OACC_CACHE_CLAUSES (node), spc, flags);
    4093           48 :       break;
    4094              : 
    4095          230 :     case OMP_PARALLEL:
    4096          230 :       pp_string (pp, "#pragma omp parallel");
    4097          230 :       dump_omp_clauses (pp, OMP_PARALLEL_CLAUSES (node), spc, flags);
    4098          230 :       goto dump_omp_body;
    4099              : 
    4100          232 :     dump_omp_clauses_body:
    4101          232 :       dump_omp_clauses (pp, OMP_CLAUSES (node), spc, flags);
    4102          232 :       goto dump_omp_body;
    4103              : 
    4104         1542 :     dump_omp_body:
    4105         1542 :       if (!(flags & TDF_SLIM) && OMP_BODY (node))
    4106              :         {
    4107         1541 :           newline_and_indent (pp, spc + 2);
    4108         1541 :           pp_left_brace (pp);
    4109         1541 :           newline_and_indent (pp, spc + 4);
    4110         1541 :           dump_generic_node (pp, OMP_BODY (node), spc + 4, flags, false);
    4111         1541 :           newline_and_indent (pp, spc + 2);
    4112         1541 :           pp_right_brace (pp);
    4113              :         }
    4114              :       is_expr = false;
    4115              :       break;
    4116              : 
    4117          161 :     case OMP_TASK:
    4118          162 :       pp_string (pp, OMP_TASK_BODY (node) ? "#pragma omp task"
    4119              :                                           : "#pragma omp taskwait");
    4120          161 :       dump_omp_clauses (pp, OMP_TASK_CLAUSES (node), spc, flags);
    4121          161 :       goto dump_omp_body;
    4122              : 
    4123          252 :     case OMP_FOR:
    4124          252 :       pp_string (pp, "#pragma omp for");
    4125          252 :       goto dump_omp_loop;
    4126              : 
    4127          235 :     case OMP_SIMD:
    4128          235 :       pp_string (pp, "#pragma omp simd");
    4129          235 :       goto dump_omp_loop;
    4130              : 
    4131           66 :     case OMP_DISTRIBUTE:
    4132           66 :       pp_string (pp, "#pragma omp distribute");
    4133           66 :       goto dump_omp_loop;
    4134              : 
    4135            5 :     case OMP_TASKLOOP:
    4136            5 :       pp_string (pp, "#pragma omp taskloop");
    4137            5 :       goto dump_omp_loop;
    4138              : 
    4139           26 :     case OMP_LOOP:
    4140           26 :       pp_string (pp, "#pragma omp loop");
    4141           26 :       goto dump_omp_loop;
    4142              : 
    4143          188 :     case OMP_TILE:
    4144          188 :       pp_string (pp, "#pragma omp tile");
    4145          188 :       goto dump_omp_loop;
    4146              : 
    4147          196 :     case OMP_UNROLL:
    4148          196 :       pp_string (pp, "#pragma omp unroll");
    4149          196 :       goto dump_omp_loop;
    4150              : 
    4151          307 :     case OACC_LOOP:
    4152          307 :       pp_string (pp, "#pragma acc loop");
    4153          307 :       goto dump_omp_loop;
    4154              : 
    4155          100 :     case OMP_TEAMS:
    4156          100 :       pp_string (pp, "#pragma omp teams");
    4157          100 :       dump_omp_clauses (pp, OMP_TEAMS_CLAUSES (node), spc, flags);
    4158          100 :       goto dump_omp_body;
    4159              : 
    4160           70 :     case OMP_TARGET_DATA:
    4161           70 :       pp_string (pp, "#pragma omp target data");
    4162           70 :       dump_omp_clauses (pp, OMP_TARGET_DATA_CLAUSES (node), spc, flags);
    4163           70 :       goto dump_omp_body;
    4164              : 
    4165           71 :     case OMP_TARGET_ENTER_DATA:
    4166           71 :       pp_string (pp, "#pragma omp target enter data");
    4167           71 :       dump_omp_clauses (pp, OMP_TARGET_ENTER_DATA_CLAUSES (node), spc, flags);
    4168           71 :       is_expr = false;
    4169           71 :       break;
    4170              : 
    4171           57 :     case OMP_TARGET_EXIT_DATA:
    4172           57 :       pp_string (pp, "#pragma omp target exit data");
    4173           57 :       dump_omp_clauses (pp, OMP_TARGET_EXIT_DATA_CLAUSES (node), spc, flags);
    4174           57 :       is_expr = false;
    4175           57 :       break;
    4176              : 
    4177          518 :     case OMP_TARGET:
    4178          518 :       pp_string (pp, "#pragma omp target");
    4179          518 :       dump_omp_clauses (pp, OMP_TARGET_CLAUSES (node), spc, flags);
    4180          518 :       goto dump_omp_body;
    4181              : 
    4182           42 :     case OMP_TARGET_UPDATE:
    4183           42 :       pp_string (pp, "#pragma omp target update");
    4184           42 :       dump_omp_clauses (pp, OMP_TARGET_UPDATE_CLAUSES (node), spc, flags);
    4185           42 :       is_expr = false;
    4186           42 :       break;
    4187              : 
    4188         1275 :     dump_omp_loop:
    4189         1275 :       dump_omp_clauses (pp, OMP_FOR_CLAUSES (node), spc, flags);
    4190         1275 :       if (!(flags & TDF_SLIM))
    4191              :         {
    4192         1275 :           int i;
    4193              : 
    4194         1275 :           if (OMP_FOR_PRE_BODY (node))
    4195              :             {
    4196          378 :               newline_and_indent (pp, spc + 2);
    4197          378 :               pp_left_brace (pp);
    4198          378 :               spc += 4;
    4199          378 :               newline_and_indent (pp, spc);
    4200          378 :               dump_generic_node (pp, OMP_FOR_PRE_BODY (node),
    4201              :                                  spc, flags, false);
    4202              :             }
    4203         1275 :           if (OMP_FOR_INIT (node))
    4204              :             {
    4205         1162 :               spc -= 2;
    4206         2582 :               for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (node)); i++)
    4207              :                 {
    4208         1420 :                   if (TREE_VEC_ELT (OMP_FOR_INIT (node), i) == NULL_TREE)
    4209          297 :                     continue;
    4210         1123 :                   spc += 2;
    4211         1123 :                   newline_and_indent (pp, spc);
    4212         1123 :                   pp_string (pp, "for (");
    4213         1123 :                   tree init = TREE_VEC_ELT (OMP_FOR_INIT (node), i);
    4214         1123 :                   if (TREE_CODE (init) != MODIFY_EXPR
    4215         1123 :                       || TREE_CODE (TREE_OPERAND (init, 1)) != TREE_VEC)
    4216         1076 :                     dump_generic_node (pp, init, spc, flags, false);
    4217              :                   else
    4218              :                     {
    4219           47 :                       dump_generic_node (pp, TREE_OPERAND (init, 0),
    4220              :                                          spc, flags, false);
    4221           47 :                       pp_string (pp, " = ");
    4222           47 :                       dump_omp_loop_non_rect_expr (pp, TREE_OPERAND (init, 1),
    4223              :                                                    spc, flags);
    4224              :                     }
    4225         1123 :                   pp_string (pp, "; ");
    4226         1123 :                   tree cond = TREE_VEC_ELT (OMP_FOR_COND (node), i);
    4227         1123 :                   if (!COMPARISON_CLASS_P (cond)
    4228         1123 :                       || TREE_CODE (TREE_OPERAND (cond, 1)) != TREE_VEC)
    4229         1082 :                     dump_generic_node (pp, cond, spc, flags, false);
    4230              :                   else
    4231              :                     {
    4232           41 :                       dump_generic_node (pp, TREE_OPERAND (cond, 0),
    4233              :                                          spc, flags, false);
    4234           82 :                       const char *op = op_symbol (cond);
    4235           41 :                       pp_space (pp);
    4236           41 :                       pp_string (pp, op);
    4237           41 :                       pp_space (pp);
    4238           41 :                       dump_omp_loop_non_rect_expr (pp, TREE_OPERAND (cond, 1),
    4239              :                                                    spc, flags);
    4240              :                     }
    4241         1123 :                   pp_string (pp, "; ");
    4242         1123 :                   dump_generic_node (pp,
    4243         1123 :                                      TREE_VEC_ELT (OMP_FOR_INCR (node), i),
    4244              :                                      spc, flags, false);
    4245         1123 :                   pp_right_paren (pp);
    4246              :                 }
    4247              :             }
    4248         1275 :           if (OMP_FOR_BODY (node))
    4249              :             {
    4250         1275 :               newline_and_indent (pp, spc + 2);
    4251         1275 :               pp_left_brace (pp);
    4252         1275 :               newline_and_indent (pp, spc + 4);
    4253         1275 :               dump_generic_node (pp, OMP_FOR_BODY (node), spc + 4, flags,
    4254              :                   false);
    4255         1275 :               newline_and_indent (pp, spc + 2);
    4256         1275 :               pp_right_brace (pp);
    4257              :             }
    4258         1275 :           if (OMP_FOR_INIT (node))
    4259         1162 :             spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
    4260         1275 :           if (OMP_FOR_PRE_BODY (node))
    4261              :             {
    4262          378 :               spc -= 4;
    4263          378 :               newline_and_indent (pp, spc + 2);
    4264          378 :               pp_right_brace (pp);
    4265              :             }
    4266              :         }
    4267              :       is_expr = false;
    4268              :       break;
    4269              : 
    4270           10 :     case OMP_SECTIONS:
    4271           10 :       pp_string (pp, "#pragma omp sections");
    4272           10 :       dump_omp_clauses (pp, OMP_SECTIONS_CLAUSES (node), spc, flags);
    4273           10 :       goto dump_omp_body;
    4274              : 
    4275           57 :     case OMP_DISPATCH:
    4276           57 :       pp_string (pp, "#pragma omp dispatch");
    4277           57 :       dump_omp_clauses (pp, OMP_DISPATCH_CLAUSES (node), spc, flags);
    4278           57 :       goto dump_omp_body;
    4279              : 
    4280           65 :     case OMP_INTEROP:
    4281           65 :       pp_string (pp, "#pragma omp interop");
    4282           65 :       dump_omp_clauses (pp, OMP_INTEROP_CLAUSES (node), spc, flags);
    4283           65 :       is_expr = false;
    4284           65 :       break;
    4285              : 
    4286           14 :     case OMP_SECTION:
    4287           14 :       pp_string (pp, "#pragma omp section");
    4288           14 :       goto dump_omp_body;
    4289              : 
    4290           10 :     case OMP_STRUCTURED_BLOCK:
    4291           10 :       pp_string (pp, "#pragma omp __structured_block");
    4292           10 :       goto dump_omp_body;
    4293              : 
    4294           10 :     case OMP_SCAN:
    4295           10 :       if (OMP_SCAN_CLAUSES (node))
    4296              :         {
    4297            5 :           pp_string (pp, "#pragma omp scan");
    4298            5 :           dump_omp_clauses (pp, OMP_SCAN_CLAUSES (node), spc, flags);
    4299              :         }
    4300           10 :       goto dump_omp_body;
    4301              : 
    4302            4 :     case OMP_MASTER:
    4303            4 :       pp_string (pp, "#pragma omp master");
    4304            4 :       goto dump_omp_body;
    4305              : 
    4306            1 :     case OMP_MASKED:
    4307            1 :       pp_string (pp, "#pragma omp masked");
    4308            1 :       dump_omp_clauses (pp, OMP_MASKED_CLAUSES (node), spc, flags);
    4309            1 :       goto dump_omp_body;
    4310              : 
    4311            5 :     case OMP_TASKGROUP:
    4312            5 :       pp_string (pp, "#pragma omp taskgroup");
    4313            5 :       dump_omp_clauses (pp, OMP_TASKGROUP_CLAUSES (node), spc, flags);
    4314            5 :       goto dump_omp_body;
    4315              : 
    4316           18 :     case OMP_ORDERED:
    4317           18 :       pp_string (pp, "#pragma omp ordered");
    4318           18 :       dump_omp_clauses (pp, OMP_ORDERED_CLAUSES (node), spc, flags);
    4319           18 :       goto dump_omp_body;
    4320              : 
    4321           27 :     case OMP_CRITICAL:
    4322           27 :       pp_string (pp, "#pragma omp critical");
    4323           27 :       if (OMP_CRITICAL_NAME (node))
    4324              :         {
    4325           24 :           pp_space (pp);
    4326           24 :           pp_left_paren (pp);
    4327           24 :           dump_generic_node (pp, OMP_CRITICAL_NAME (node), spc,
    4328              :                              flags, false);
    4329           24 :           pp_right_paren (pp);
    4330              :         }
    4331           27 :       dump_omp_clauses (pp, OMP_CRITICAL_CLAUSES (node), spc, flags);
    4332           27 :       goto dump_omp_body;
    4333              : 
    4334          191 :     case OMP_ATOMIC:
    4335          191 :       pp_string (pp, "#pragma omp atomic");
    4336          191 :       if (OMP_ATOMIC_WEAK (node))
    4337            0 :         pp_string (pp, " weak");
    4338          191 :       dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
    4339          191 :       newline_and_indent (pp, spc + 2);
    4340          191 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4341          191 :       pp_space (pp);
    4342          191 :       pp_equal (pp);
    4343          191 :       pp_space (pp);
    4344          191 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    4345          191 :       break;
    4346              : 
    4347           42 :     case OMP_ATOMIC_READ:
    4348           42 :       pp_string (pp, "#pragma omp atomic read");
    4349           42 :       dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
    4350           42 :       newline_and_indent (pp, spc + 2);
    4351           42 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4352           42 :       pp_space (pp);
    4353           42 :       break;
    4354              : 
    4355           56 :     case OMP_ATOMIC_CAPTURE_OLD:
    4356           56 :     case OMP_ATOMIC_CAPTURE_NEW:
    4357           56 :       pp_string (pp, "#pragma omp atomic capture");
    4358           56 :       if (OMP_ATOMIC_WEAK (node))
    4359            0 :         pp_string (pp, " weak");
    4360           56 :       dump_omp_atomic_memory_order (pp, OMP_ATOMIC_MEMORY_ORDER (node));
    4361           56 :       newline_and_indent (pp, spc + 2);
    4362           56 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4363           56 :       pp_space (pp);
    4364           56 :       pp_equal (pp);
    4365           56 :       pp_space (pp);
    4366           56 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    4367           56 :       break;
    4368              : 
    4369           17 :     case OMP_SINGLE:
    4370           17 :       pp_string (pp, "#pragma omp single");
    4371           17 :       dump_omp_clauses (pp, OMP_SINGLE_CLAUSES (node), spc, flags);
    4372           17 :       goto dump_omp_body;
    4373              : 
    4374            2 :     case OMP_SCOPE:
    4375            2 :       pp_string (pp, "#pragma omp scope");
    4376            2 :       dump_omp_clauses (pp, OMP_SCOPE_CLAUSES (node), spc, flags);
    4377            2 :       goto dump_omp_body;
    4378              : 
    4379         1590 :     case OMP_CLAUSE:
    4380              :       /* If we come here, we're dumping something that's not an OMP construct,
    4381              :          for example, OMP clauses attached to a function's '__attribute__'.
    4382              :          Dump the whole OMP clause chain.  */
    4383         1590 :       dump_omp_clauses (pp, node, spc, flags, false);
    4384         1590 :       is_expr = false;
    4385         1590 :       break;
    4386              : 
    4387           34 :     case OMP_METADIRECTIVE:
    4388           34 :       {
    4389           34 :         pp_string (pp, "#pragma omp metadirective");
    4390           34 :         newline_and_indent (pp, spc + 2);
    4391           34 :         pp_left_brace (pp);
    4392              : 
    4393           34 :         tree variant = OMP_METADIRECTIVE_VARIANTS (node);
    4394          120 :         while (variant != NULL_TREE)
    4395              :           {
    4396           86 :             tree selector = OMP_METADIRECTIVE_VARIANT_SELECTOR (variant);
    4397           86 :             tree directive = OMP_METADIRECTIVE_VARIANT_DIRECTIVE (variant);
    4398           86 :             tree body = OMP_METADIRECTIVE_VARIANT_BODY (variant);
    4399              : 
    4400           86 :             newline_and_indent (pp, spc + 4);
    4401           86 :             if (selector == NULL_TREE)
    4402           34 :               pp_string (pp, "otherwise:");
    4403              :             else
    4404              :               {
    4405           52 :                 pp_string (pp, "when (");
    4406           52 :                 dump_omp_context_selector (pp, selector, spc + 4, flags);
    4407           52 :                 pp_string (pp, "):");
    4408              :               }
    4409           86 :             newline_and_indent (pp, spc + 6);
    4410              : 
    4411           86 :             dump_generic_node (pp, directive, spc + 6, flags, false);
    4412           86 :             newline_and_indent (pp, spc + 6);
    4413           86 :             dump_generic_node (pp, body, spc + 6, flags, false);
    4414           86 :             variant = TREE_CHAIN (variant);
    4415              :           }
    4416           34 :         newline_and_indent (pp, spc + 2);
    4417           34 :         pp_right_brace (pp);
    4418              :       }
    4419           34 :       break;
    4420              : 
    4421           12 :     case OMP_NEXT_VARIANT:
    4422           12 :       {
    4423           12 :         pp_string (pp, "OMP_NEXT_VARIANT <");
    4424           12 :         dump_generic_node (pp, OMP_NEXT_VARIANT_INDEX (node), spc,
    4425              :                            flags, false);
    4426           12 :         pp_string (pp, ", ");
    4427           12 :         tree state = OMP_NEXT_VARIANT_STATE (node);
    4428           12 :         gcc_assert (state && TREE_CODE (state) == TREE_LIST);
    4429           12 :         if (TREE_PURPOSE (state))
    4430              :           {
    4431            0 :             newline_and_indent (pp, spc + 2);
    4432            0 :             pp_string (pp, "resolution map = ");
    4433            0 :             dump_generic_node (pp, TREE_PURPOSE (state), spc, flags, false);
    4434              :           }
    4435           12 :         newline_and_indent (pp, spc + 2);
    4436           12 :         pp_string (pp, "construct context = ");
    4437           12 :         if (TREE_VALUE (state))
    4438            0 :           dump_generic_node (pp, TREE_VALUE (state), spc, flags, false);
    4439              :         else
    4440           12 :           pp_string (pp, "NULL");
    4441              : 
    4442           12 :         tree selectors = TREE_CHAIN (state);
    4443           60 :         for (int i = 0; i < TREE_VEC_LENGTH (selectors); i++)
    4444              :           {
    4445           48 :             newline_and_indent (pp, spc + 2);
    4446           48 :             pp_decimal_int (pp, i + 1);
    4447           48 :             pp_string (pp, ": ");
    4448           48 :             dump_omp_context_selector (pp, TREE_VEC_ELT (selectors, i),
    4449              :                                        spc + 4, flags);
    4450              :           }
    4451           12 :         pp_string (pp, ">");
    4452              :       }
    4453           12 :       break;
    4454              : 
    4455            0 :     case OMP_TARGET_DEVICE_MATCHES:
    4456            0 :       pp_string (pp, "OMP_TARGET_DEVICE_MATCHES <");
    4457            0 :       dump_generic_node (pp, OMP_TARGET_DEVICE_MATCHES_SELECTOR (node), spc,
    4458              :                          flags, false);
    4459            0 :       for (tree p = OMP_TARGET_DEVICE_MATCHES_PROPERTIES (node);
    4460            0 :            p; p = TREE_CHAIN (p))
    4461              :         {
    4462            0 :           pp_string (pp, ", ");
    4463            0 :           dump_generic_node (pp, OMP_TP_VALUE (p), spc, flags, false);
    4464              :         }
    4465            0 :       pp_string (pp, ")>");
    4466            0 :       break;
    4467              : 
    4468           52 :     case OMP_DECLARE_MAPPER:
    4469           52 :       pp_string (pp, "#pragma omp declare mapper (");
    4470           52 :       if (OMP_DECLARE_MAPPER_ID (node))
    4471              :         {
    4472            8 :           dump_generic_node (pp, OMP_DECLARE_MAPPER_ID (node), spc, flags,
    4473              :                              false);
    4474            8 :           pp_colon (pp);
    4475              :         }
    4476           52 :       dump_generic_node (pp, TREE_TYPE (node), spc, flags, false);
    4477           52 :       pp_space (pp);
    4478           52 :       dump_generic_node (pp, OMP_DECLARE_MAPPER_DECL (node), spc, flags, false);
    4479           52 :       pp_right_paren (pp);
    4480           52 :       dump_omp_clauses (pp, OMP_DECLARE_MAPPER_CLAUSES (node), spc, flags);
    4481           52 :       break;
    4482              : 
    4483            0 :     case TRANSACTION_EXPR:
    4484            0 :       if (TRANSACTION_EXPR_OUTER (node))
    4485            0 :         pp_string (pp, "__transaction_atomic [[outer]]");
    4486            0 :       else if (TRANSACTION_EXPR_RELAXED (node))
    4487            0 :         pp_string (pp, "__transaction_relaxed");
    4488              :       else
    4489            0 :         pp_string (pp, "__transaction_atomic");
    4490            0 :       if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
    4491              :         {
    4492            0 :           newline_and_indent (pp, spc);
    4493            0 :           pp_left_brace (pp);
    4494            0 :           newline_and_indent (pp, spc + 2);
    4495            0 :           dump_generic_node (pp, TRANSACTION_EXPR_BODY (node),
    4496              :                              spc + 2, flags, false);
    4497            0 :           newline_and_indent (pp, spc);
    4498            0 :           pp_right_brace (pp);
    4499              :         }
    4500              :       is_expr = false;
    4501              :       break;
    4502              : 
    4503            0 :     case VEC_SERIES_EXPR:
    4504            0 :     case VEC_WIDEN_MULT_HI_EXPR:
    4505            0 :     case VEC_WIDEN_MULT_LO_EXPR:
    4506            0 :     case VEC_WIDEN_MULT_EVEN_EXPR:
    4507            0 :     case VEC_WIDEN_MULT_ODD_EXPR:
    4508            0 :     case VEC_WIDEN_LSHIFT_HI_EXPR:
    4509            0 :     case VEC_WIDEN_LSHIFT_LO_EXPR:
    4510            0 :       pp_space (pp);
    4511            0 :       for (str = get_tree_code_name (code); *str; str++)
    4512            0 :         pp_character (pp, TOUPPER (*str));
    4513            0 :       pp_string (pp, " < ");
    4514            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4515            0 :       pp_string (pp, ", ");
    4516            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    4517            0 :       pp_string (pp, " > ");
    4518            0 :       break;
    4519              : 
    4520            0 :     case VEC_DUPLICATE_EXPR:
    4521            0 :       pp_space (pp);
    4522            0 :       for (str = get_tree_code_name (code); *str; str++)
    4523            0 :         pp_character (pp, TOUPPER (*str));
    4524            0 :       pp_string (pp, " < ");
    4525            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4526            0 :       pp_string (pp, " > ");
    4527            0 :       break;
    4528              : 
    4529            0 :     case VEC_UNPACK_HI_EXPR:
    4530            0 :       pp_string (pp, " VEC_UNPACK_HI_EXPR < ");
    4531            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4532            0 :       pp_string (pp, " > ");
    4533            0 :       break;
    4534              : 
    4535            0 :     case VEC_UNPACK_LO_EXPR:
    4536            0 :       pp_string (pp, " VEC_UNPACK_LO_EXPR < ");
    4537            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4538            0 :       pp_string (pp, " > ");
    4539            0 :       break;
    4540              : 
    4541            0 :     case VEC_UNPACK_FLOAT_HI_EXPR:
    4542            0 :       pp_string (pp, " VEC_UNPACK_FLOAT_HI_EXPR < ");
    4543            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4544            0 :       pp_string (pp, " > ");
    4545            0 :       break;
    4546              : 
    4547            0 :     case VEC_UNPACK_FLOAT_LO_EXPR:
    4548            0 :       pp_string (pp, " VEC_UNPACK_FLOAT_LO_EXPR < ");
    4549            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4550            0 :       pp_string (pp, " > ");
    4551            0 :       break;
    4552              : 
    4553            0 :     case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
    4554            0 :       pp_string (pp, " VEC_UNPACK_FIX_TRUNC_HI_EXPR < ");
    4555            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4556            0 :       pp_string (pp, " > ");
    4557            0 :       break;
    4558              : 
    4559            0 :     case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
    4560            0 :       pp_string (pp, " VEC_UNPACK_FIX_TRUNC_LO_EXPR < ");
    4561            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4562            0 :       pp_string (pp, " > ");
    4563            0 :       break;
    4564              : 
    4565            0 :     case VEC_PACK_TRUNC_EXPR:
    4566            0 :       pp_string (pp, " VEC_PACK_TRUNC_EXPR < ");
    4567            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4568            0 :       pp_string (pp, ", ");
    4569            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    4570            0 :       pp_string (pp, " > ");
    4571            0 :       break;
    4572              : 
    4573            0 :     case VEC_PACK_SAT_EXPR:
    4574            0 :       pp_string (pp, " VEC_PACK_SAT_EXPR < ");
    4575            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4576            0 :       pp_string (pp, ", ");
    4577            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    4578            0 :       pp_string (pp, " > ");
    4579            0 :       break;
    4580              : 
    4581            0 :     case VEC_PACK_FIX_TRUNC_EXPR:
    4582            0 :       pp_string (pp, " VEC_PACK_FIX_TRUNC_EXPR < ");
    4583            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4584            0 :       pp_string (pp, ", ");
    4585            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    4586            0 :       pp_string (pp, " > ");
    4587            0 :       break;
    4588              : 
    4589            0 :     case VEC_PACK_FLOAT_EXPR:
    4590            0 :       pp_string (pp, " VEC_PACK_FLOAT_EXPR < ");
    4591            0 :       dump_generic_node (pp, TREE_OPERAND (node, 0), spc, flags, false);
    4592            0 :       pp_string (pp, ", ");
    4593            0 :       dump_generic_node (pp, TREE_OPERAND (node, 1), spc, flags, false);
    4594            0 :       pp_string (pp, " > ");
    4595            0 :       break;
    4596              : 
    4597            6 :     case BLOCK:
    4598            6 :       dump_block_node (pp, node, spc, flags);
    4599            6 :       break;
    4600              : 
    4601          888 :     case DEBUG_BEGIN_STMT:
    4602          888 :       pp_string (pp, "# DEBUG BEGIN STMT");
    4603          888 :       break;
    4604              : 
    4605        13331 :     default:
    4606        13331 :       NIY;
    4607              :     }
    4608              : 
    4609     49698472 :   if (is_stmt && is_expr)
    4610       330844 :     pp_semicolon (pp);
    4611              : 
    4612              :   return spc;
    4613              : }
    4614              : 
    4615              : /* Print the declaration of a variable.  */
    4616              : 
    4617              : void
    4618       463999 : print_declaration (pretty_printer *pp, tree t, int spc, dump_flags_t flags)
    4619              : {
    4620      2329935 :   INDENT (spc);
    4621              : 
    4622       463999 :   if (TREE_CODE(t) == NAMELIST_DECL)
    4623              :     {
    4624            1 :       pp_string(pp, "namelist ");
    4625            1 :       dump_decl_name (pp, t, flags);
    4626            1 :       pp_semicolon (pp);
    4627            1 :       return;
    4628              :     }
    4629              : 
    4630       463998 :   if (TREE_CODE (t) == TYPE_DECL)
    4631         2430 :     pp_string (pp, "typedef ");
    4632              : 
    4633       463998 :   if (HAS_RTL_P (t) && DECL_REGISTER (t))
    4634           39 :     pp_string (pp, "register ");
    4635              : 
    4636       463998 :   if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
    4637         5180 :     pp_string (pp, "extern ");
    4638       458818 :   else if (TREE_STATIC (t))
    4639        16875 :     pp_string (pp, "static ");
    4640              : 
    4641              :   /* Print the type and name.  */
    4642       463998 :   if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
    4643              :     {
    4644        26638 :       tree tmp;
    4645              : 
    4646              :       /* Print array's type.  */
    4647        26638 :       tmp = TREE_TYPE (t);
    4648        27484 :       while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
    4649          846 :         tmp = TREE_TYPE (tmp);
    4650        26638 :       dump_generic_node (pp, TREE_TYPE (tmp), spc, flags, false);
    4651              : 
    4652              :       /* Print variable's name.  */
    4653        26638 :       pp_space (pp);
    4654        26638 :       dump_generic_node (pp, t, spc, flags, false);
    4655              : 
    4656              :       /* Print the dimensions.  */
    4657        26638 :       tmp = TREE_TYPE (t);
    4658        54122 :       while (TREE_CODE (tmp) == ARRAY_TYPE)
    4659              :         {
    4660        27484 :           dump_array_domain (pp, TYPE_DOMAIN (tmp), spc, flags);
    4661        27484 :           tmp = TREE_TYPE (tmp);
    4662              :         }
    4663              :     }
    4664       437360 :   else if (TREE_CODE (t) == FUNCTION_DECL)
    4665              :     {
    4666         8906 :       dump_generic_node (pp, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
    4667         8906 :       pp_space (pp);
    4668         8906 :       dump_decl_name (pp, t, flags);
    4669         8906 :       dump_function_declaration (pp, TREE_TYPE (t), spc, flags);
    4670              :     }
    4671              :   else
    4672              :     {
    4673              :       /* Print type declaration.  */
    4674       428454 :       dump_generic_node (pp, TREE_TYPE (t), spc, flags, false);
    4675              : 
    4676              :       /* Print variable's name.  */
    4677       428454 :       pp_space (pp);
    4678       428454 :       dump_generic_node (pp, t, spc, flags, false);
    4679              :     }
    4680              : 
    4681       463998 :   if (VAR_P (t) && DECL_HARD_REGISTER (t))
    4682              :     {
    4683            5 :       pp_string (pp, " __asm__ ");
    4684            5 :       pp_left_paren (pp);
    4685            5 :       dump_generic_node (pp, DECL_ASSEMBLER_NAME (t), spc, flags, false);
    4686            5 :       pp_right_paren (pp);
    4687              :     }
    4688              : 
    4689              :   /* The initial value of a function serves to determine whether the function
    4690              :      is declared or defined.  So the following does not apply to function
    4691              :      nodes.  */
    4692       463998 :   if (TREE_CODE (t) != FUNCTION_DECL)
    4693              :     {
    4694              :       /* Print the initial value.  */
    4695       455092 :       if (DECL_INITIAL (t))
    4696              :         {
    4697        22097 :           pp_space (pp);
    4698        22097 :           pp_equal (pp);
    4699        22097 :           pp_space (pp);
    4700        22097 :           if (!(flags & TDF_SLIM))
    4701        21307 :             dump_generic_node (pp, DECL_INITIAL (t), spc, flags, false);
    4702              :           else
    4703          790 :             pp_string (pp, "<<< omitted >>>");
    4704              :         }
    4705              :     }
    4706              : 
    4707       463998 :   if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
    4708              :     {
    4709         2404 :       pp_string (pp, " [value-expr: ");
    4710         2404 :       dump_generic_node (pp, DECL_VALUE_EXPR (t), spc, flags, false);
    4711         2404 :       pp_right_bracket (pp);
    4712              :     }
    4713              : 
    4714       463998 :   pp_semicolon (pp);
    4715              : }
    4716              : 
    4717              : 
    4718              : /* Prints a structure: name, fields, and methods.
    4719              :    FIXME: Still incomplete.  */
    4720              : 
    4721              : static void
    4722          580 : print_struct_decl (pretty_printer *pp, const_tree node, int spc,
    4723              :                    dump_flags_t flags)
    4724              : {
    4725              :   /* Print the name of the structure.  */
    4726          580 :   if (TYPE_NAME (node))
    4727              :     {
    4728            0 :       INDENT (spc);
    4729            0 :       if (TREE_CODE (node) == RECORD_TYPE)
    4730            0 :         pp_string (pp, "struct ");
    4731            0 :       else if ((TREE_CODE (node) == UNION_TYPE
    4732            0 :                 || TREE_CODE (node) == QUAL_UNION_TYPE))
    4733            0 :         pp_string (pp, "union ");
    4734              : 
    4735            0 :       dump_generic_node (pp, TYPE_NAME (node), spc, TDF_NONE, false);
    4736              :     }
    4737              : 
    4738              :   /* Print the contents of the structure.  */
    4739          580 :   pp_newline (pp);
    4740         1908 :   INDENT (spc);
    4741          580 :   pp_left_brace (pp);
    4742          580 :   pp_newline (pp);
    4743              : 
    4744              :   /* Print the fields of the structure.  */
    4745          580 :   {
    4746          580 :     tree tmp;
    4747          580 :     tmp = TYPE_FIELDS (node);
    4748         3177 :     while (tmp)
    4749              :       {
    4750              :         /* Avoid to print recursively the structure.  */
    4751              :         /* FIXME : Not implemented correctly...,
    4752              :            what about the case when we have a cycle in the contain graph? ...
    4753              :            Maybe this could be solved by looking at the scope in which the
    4754              :            structure was declared.  */
    4755         2597 :         if (TREE_TYPE (tmp) != node
    4756         2597 :             && (TREE_CODE (TREE_TYPE (tmp)) != POINTER_TYPE
    4757           52 :                 || TREE_TYPE (TREE_TYPE (tmp)) != node))
    4758              :           {
    4759         2597 :             print_declaration (pp, tmp, spc+2, flags);
    4760         2597 :             pp_newline (pp);
    4761              :           }
    4762         2597 :         tmp = DECL_CHAIN (tmp);
    4763              :       }
    4764              :   }
    4765         1328 :   INDENT (spc);
    4766          580 :   pp_right_brace (pp);
    4767          580 : }
    4768              : 
    4769              : /* Return the priority of the operator CODE.
    4770              : 
    4771              :    From lowest to highest precedence with either left-to-right (L-R)
    4772              :    or right-to-left (R-L) associativity]:
    4773              : 
    4774              :      1  [L-R] ,
    4775              :      2  [R-L] = += -= *= /= %= &= ^= |= <<= >>=
    4776              :      3  [R-L] ?:
    4777              :      4  [L-R] ||
    4778              :      5  [L-R] &&
    4779              :      6  [L-R] |
    4780              :      7  [L-R] ^
    4781              :      8  [L-R] &
    4782              :      9  [L-R] == !=
    4783              :     10  [L-R] < <= > >=
    4784              :     11  [L-R] << >>
    4785              :     12  [L-R] + -
    4786              :     13  [L-R] * / %
    4787              :     14  [R-L] ! ~ ++ -- + - * & (type) sizeof
    4788              :     15  [L-R] fn() [] -> .
    4789              : 
    4790              :    unary +, - and * have higher precedence than the corresponding binary
    4791              :    operators.  */
    4792              : 
    4793              : int
    4794     22488202 : op_code_prio (enum tree_code code)
    4795              : {
    4796     22488202 :   switch (code)
    4797              :     {
    4798              :     case TREE_LIST:
    4799              :     case COMPOUND_EXPR:
    4800              :     case BIND_EXPR:
    4801              :       return 1;
    4802              : 
    4803              :     case MODIFY_EXPR:
    4804              :     case INIT_EXPR:
    4805              :       return 2;
    4806              : 
    4807              :     case COND_EXPR:
    4808              :       return 3;
    4809              : 
    4810              :     case TRUTH_OR_EXPR:
    4811              :     case TRUTH_ORIF_EXPR:
    4812              :       return 4;
    4813              : 
    4814              :     case TRUTH_AND_EXPR:
    4815              :     case TRUTH_ANDIF_EXPR:
    4816              :       return 5;
    4817              : 
    4818              :     case BIT_IOR_EXPR:
    4819              :       return 6;
    4820              : 
    4821              :     case BIT_XOR_EXPR:
    4822              :     case TRUTH_XOR_EXPR:
    4823              :       return 7;
    4824              : 
    4825              :     case BIT_AND_EXPR:
    4826              :       return 8;
    4827              : 
    4828              :     case EQ_EXPR:
    4829              :     case NE_EXPR:
    4830              :       return 9;
    4831              : 
    4832              :     case UNLT_EXPR:
    4833              :     case UNLE_EXPR:
    4834              :     case UNGT_EXPR:
    4835              :     case UNGE_EXPR:
    4836              :     case UNEQ_EXPR:
    4837              :     case LTGT_EXPR:
    4838              :     case ORDERED_EXPR:
    4839              :     case UNORDERED_EXPR:
    4840              :     case LT_EXPR:
    4841              :     case LE_EXPR:
    4842              :     case GT_EXPR:
    4843              :     case GE_EXPR:
    4844              :       return 10;
    4845              : 
    4846              :     case LSHIFT_EXPR:
    4847              :     case RSHIFT_EXPR:
    4848              :     case LROTATE_EXPR:
    4849              :     case RROTATE_EXPR:
    4850              :     case VEC_WIDEN_LSHIFT_HI_EXPR:
    4851              :     case VEC_WIDEN_LSHIFT_LO_EXPR:
    4852              :     case WIDEN_LSHIFT_EXPR:
    4853              :       return 11;
    4854              : 
    4855              :     case WIDEN_SUM_EXPR:
    4856              :     case PLUS_EXPR:
    4857              :     case POINTER_PLUS_EXPR:
    4858              :     case POINTER_DIFF_EXPR:
    4859              :     case MINUS_EXPR:
    4860              :       return 12;
    4861              : 
    4862              :     case VEC_WIDEN_MULT_HI_EXPR:
    4863              :     case VEC_WIDEN_MULT_LO_EXPR:
    4864              :     case WIDEN_MULT_EXPR:
    4865              :     case DOT_PROD_EXPR:
    4866              :     case WIDEN_MULT_PLUS_EXPR:
    4867              :     case WIDEN_MULT_MINUS_EXPR:
    4868              :     case MULT_EXPR:
    4869              :     case MULT_HIGHPART_EXPR:
    4870              :     case TRUNC_DIV_EXPR:
    4871              :     case CEIL_DIV_EXPR:
    4872              :     case FLOOR_DIV_EXPR:
    4873              :     case ROUND_DIV_EXPR:
    4874              :     case RDIV_EXPR:
    4875              :     case EXACT_DIV_EXPR:
    4876              :     case TRUNC_MOD_EXPR:
    4877              :     case CEIL_MOD_EXPR:
    4878              :     case FLOOR_MOD_EXPR:
    4879              :     case ROUND_MOD_EXPR:
    4880              :       return 13;
    4881              : 
    4882              :     case TRUTH_NOT_EXPR:
    4883              :     case BIT_NOT_EXPR:
    4884              :     case POSTINCREMENT_EXPR:
    4885              :     case POSTDECREMENT_EXPR:
    4886              :     case PREINCREMENT_EXPR:
    4887              :     case PREDECREMENT_EXPR:
    4888              :     case NEGATE_EXPR:
    4889              :     case INDIRECT_REF:
    4890              :     case ADDR_EXPR:
    4891              :     case FLOAT_EXPR:
    4892              :     CASE_CONVERT:
    4893              :     case FIX_TRUNC_EXPR:
    4894              :     case TARGET_EXPR:
    4895              :       return 14;
    4896              : 
    4897              :     case CALL_EXPR:
    4898              :     case ARRAY_REF:
    4899              :     case ARRAY_RANGE_REF:
    4900              :     case COMPONENT_REF:
    4901              :       return 15;
    4902              : 
    4903              :       /* Special expressions.  */
    4904              :     case MIN_EXPR:
    4905              :     case MAX_EXPR:
    4906              :     case ABS_EXPR:
    4907              :     case REALPART_EXPR:
    4908              :     case IMAGPART_EXPR:
    4909              :     case VEC_UNPACK_HI_EXPR:
    4910              :     case VEC_UNPACK_LO_EXPR:
    4911              :     case VEC_UNPACK_FLOAT_HI_EXPR:
    4912              :     case VEC_UNPACK_FLOAT_LO_EXPR:
    4913              :     case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
    4914              :     case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
    4915              :     case VEC_PACK_TRUNC_EXPR:
    4916              :     case VEC_PACK_SAT_EXPR:
    4917              :       return 16;
    4918              : 
    4919              :     default:
    4920              :       /* Return an arbitrarily high precedence to avoid surrounding single
    4921              :          VAR_DECLs in ()s.  */
    4922              :       return 9999;
    4923              :     }
    4924              : }
    4925              : 
    4926              : /* Return the priority of the operator OP.  */
    4927              : 
    4928              : int
    4929     17846725 : op_prio (const_tree op)
    4930              : {
    4931     17863677 :   enum tree_code code;
    4932              : 
    4933     17863677 :   if (op == NULL)
    4934              :     return 9999;
    4935              : 
    4936     17863455 :   code = TREE_CODE (op);
    4937     17863455 :   if (code == SAVE_EXPR || code == NON_LVALUE_EXPR)
    4938        16952 :     return op_prio (TREE_OPERAND (op, 0));
    4939              : 
    4940     17846503 :   return op_code_prio (code);
    4941              : }
    4942              : 
    4943              : /* Return the symbol associated with operator CODE.  */
    4944              : 
    4945              : const char *
    4946      2837690 : op_symbol_code (enum tree_code code, dump_flags_t flags)
    4947              : {
    4948      2837690 :   switch (code)
    4949              :     {
    4950              :     case MODIFY_EXPR:
    4951              :       return "=";
    4952              : 
    4953         2529 :     case TRUTH_OR_EXPR:
    4954         2529 :     case TRUTH_ORIF_EXPR:
    4955         2529 :       return "||";
    4956              : 
    4957         2832 :     case TRUTH_AND_EXPR:
    4958         2832 :     case TRUTH_ANDIF_EXPR:
    4959         2832 :       return "&&";
    4960              : 
    4961        36379 :     case BIT_IOR_EXPR:
    4962        36379 :       return "|";
    4963              : 
    4964        27291 :     case TRUTH_XOR_EXPR:
    4965        27291 :     case BIT_XOR_EXPR:
    4966        27291 :       return "^";
    4967              : 
    4968       388947 :     case ADDR_EXPR:
    4969       388947 :     case BIT_AND_EXPR:
    4970       388947 :       return "&";
    4971              : 
    4972           37 :     case ORDERED_EXPR:
    4973           37 :       return (flags & TDF_GIMPLE) ? "__ORDERED" : "ord";
    4974           63 :     case UNORDERED_EXPR:
    4975           63 :       return (flags & TDF_GIMPLE) ? "__UNORDERED" : "unord";
    4976              : 
    4977        68060 :     case EQ_EXPR:
    4978        68060 :       return "==";
    4979          151 :     case UNEQ_EXPR:
    4980          151 :       return (flags & TDF_GIMPLE) ? "__UNEQ" : "u==";
    4981              : 
    4982       215499 :     case NE_EXPR:
    4983       215499 :       return "!=";
    4984              : 
    4985        73521 :     case LT_EXPR:
    4986        73521 :       return "<";
    4987          190 :     case UNLT_EXPR:
    4988          190 :       return (flags & TDF_GIMPLE) ? "__UNLT" : "u<";
    4989              : 
    4990        31825 :     case LE_EXPR:
    4991        31825 :       return "<=";
    4992          224 :     case UNLE_EXPR:
    4993          224 :       return (flags & TDF_GIMPLE) ? "__UNLE" : "u<=";
    4994              : 
    4995        58615 :     case GT_EXPR:
    4996        58615 :       return ">";
    4997          235 :     case UNGT_EXPR:
    4998          235 :       return (flags & TDF_GIMPLE) ? "__UNGT" : "u>";
    4999              : 
    5000        10475 :     case GE_EXPR:
    5001        10475 :       return ">=";
    5002          179 :     case UNGE_EXPR:
    5003          179 :       return (flags & TDF_GIMPLE) ? "__UNGE" : "u>=";
    5004              : 
    5005           24 :     case LTGT_EXPR:
    5006           24 :       return (flags & TDF_GIMPLE) ? "__LTGT" : "<>";
    5007              : 
    5008        46914 :     case LSHIFT_EXPR:
    5009        46914 :       return "<<";
    5010              : 
    5011       106375 :     case RSHIFT_EXPR:
    5012       106375 :       return ">>";
    5013              : 
    5014          785 :     case LROTATE_EXPR:
    5015          785 :       return (flags & TDF_GIMPLE) ? "__ROTATE_LEFT" : "r<<";
    5016              : 
    5017         1381 :     case RROTATE_EXPR:
    5018         1381 :       return (flags & TDF_GIMPLE) ? "__ROTATE_RIGHT" : "r>>";
    5019              : 
    5020            0 :     case WIDEN_LSHIFT_EXPR:
    5021            0 :       return "w<<";
    5022              : 
    5023              :     case POINTER_PLUS_EXPR:
    5024              :       return "+";
    5025              : 
    5026              :     case PLUS_EXPR:
    5027              :       return "+";
    5028              : 
    5029            0 :     case WIDEN_SUM_EXPR:
    5030            0 :       return "w+";
    5031              : 
    5032        11305 :     case WIDEN_MULT_EXPR:
    5033        11305 :       return "w*";
    5034              : 
    5035         7636 :     case MULT_HIGHPART_EXPR:
    5036         7636 :       return (flags & TDF_GIMPLE) ? "__MULT_HIGHPART" : "h*";
    5037              : 
    5038       199687 :     case NEGATE_EXPR:
    5039       199687 :     case MINUS_EXPR:
    5040       199687 :     case POINTER_DIFF_EXPR:
    5041       199687 :       return "-";
    5042              : 
    5043          720 :     case BIT_NOT_EXPR:
    5044          720 :       return "~";
    5045              : 
    5046          540 :     case TRUTH_NOT_EXPR:
    5047          540 :       return "!";
    5048              : 
    5049       376445 :     case MULT_EXPR:
    5050       376445 :     case INDIRECT_REF:
    5051       376445 :       return "*";
    5052              : 
    5053        14038 :     case TRUNC_DIV_EXPR:
    5054        14038 :     case RDIV_EXPR:
    5055        14038 :       return "/";
    5056              : 
    5057          135 :     case CEIL_DIV_EXPR:
    5058          135 :       return "/[cl]";
    5059              : 
    5060          217 :     case FLOOR_DIV_EXPR:
    5061          217 :       return "/[fl]";
    5062              : 
    5063          126 :     case ROUND_DIV_EXPR:
    5064          126 :       return "/[rd]";
    5065              : 
    5066          544 :     case EXACT_DIV_EXPR:
    5067          544 :       return "/[ex]";
    5068              : 
    5069         6952 :     case TRUNC_MOD_EXPR:
    5070         6952 :       return "%";
    5071              : 
    5072          126 :     case CEIL_MOD_EXPR:
    5073          126 :       return "%[cl]";
    5074              : 
    5075           63 :     case FLOOR_MOD_EXPR:
    5076           63 :       return "%[fl]";
    5077              : 
    5078          126 :     case ROUND_MOD_EXPR:
    5079          126 :       return "%[rd]";
    5080              : 
    5081           53 :     case PREDECREMENT_EXPR:
    5082           53 :       return " --";
    5083              : 
    5084          538 :     case PREINCREMENT_EXPR:
    5085          538 :       return " ++";
    5086              : 
    5087           10 :     case POSTDECREMENT_EXPR:
    5088           10 :       return "-- ";
    5089              : 
    5090         1525 :     case POSTINCREMENT_EXPR:
    5091         1525 :       return "++ ";
    5092              : 
    5093           24 :     case MAX_EXPR:
    5094           24 :       return "max";
    5095              : 
    5096           22 :     case MIN_EXPR:
    5097           22 :       return "min";
    5098              : 
    5099         1422 :     default:
    5100         1422 :       return "<<< ??? >>>";
    5101              :     }
    5102              : }
    5103              : 
    5104              : /* Return the symbol associated with operator OP.  */
    5105              : 
    5106              : static const char *
    5107       604155 : op_symbol (const_tree op, dump_flags_t flags)
    5108              : {
    5109       604155 :   return op_symbol_code (TREE_CODE (op), flags);
    5110              : }
    5111              : 
    5112              : /* Prints the name of a call.  NODE is the CALL_EXPR_FN of a CALL_EXPR or
    5113              :    the gimple_call_fn of a GIMPLE_CALL.  */
    5114              : 
    5115              : void
    5116       190564 : print_call_name (pretty_printer *pp, tree node, dump_flags_t flags)
    5117              : {
    5118       190564 :   tree op0 = node;
    5119       190564 :   int spc = 0;
    5120              : 
    5121       190564 :   if (TREE_CODE (op0) == NON_LVALUE_EXPR)
    5122            4 :     op0 = TREE_OPERAND (op0, 0);
    5123              : 
    5124       190564 :  again:
    5125       376160 :   switch (TREE_CODE (op0))
    5126              :     {
    5127       184502 :     case VAR_DECL:
    5128       184502 :     case PARM_DECL:
    5129       184502 :     case FUNCTION_DECL:
    5130       184502 :       dump_function_name (pp, op0, flags);
    5131       184502 :       break;
    5132              : 
    5133       185596 :     case ADDR_EXPR:
    5134       185596 :     case INDIRECT_REF:
    5135       185596 :     CASE_CONVERT:
    5136       185596 :       op0 = TREE_OPERAND (op0, 0);
    5137       185596 :       goto again;
    5138              : 
    5139            0 :     case COND_EXPR:
    5140            0 :       pp_left_paren (pp);
    5141            0 :       dump_generic_node (pp, TREE_OPERAND (op0, 0), 0, flags, false);
    5142            0 :       pp_string (pp, ") ? ");
    5143            0 :       dump_generic_node (pp, TREE_OPERAND (op0, 1), 0, flags, false);
    5144            0 :       pp_string (pp, " : ");
    5145            0 :       dump_generic_node (pp, TREE_OPERAND (op0, 2), 0, flags, false);
    5146            0 :       break;
    5147              : 
    5148            0 :     case ARRAY_REF:
    5149            0 :       if (VAR_P (TREE_OPERAND (op0, 0)))
    5150            0 :         dump_function_name (pp, TREE_OPERAND (op0, 0), flags);
    5151              :       else
    5152            0 :         dump_generic_node (pp, op0, 0, flags, false);
    5153              :       break;
    5154              : 
    5155            0 :     case MEM_REF:
    5156            0 :       if (integer_zerop (TREE_OPERAND (op0, 1)))
    5157              :         {
    5158            0 :           op0 = TREE_OPERAND (op0, 0);
    5159            0 :           goto again;
    5160              :         }
    5161              :       /* Fallthru.  */
    5162         6060 :     case COMPONENT_REF:
    5163         6060 :     case SSA_NAME:
    5164         6060 :     case OBJ_TYPE_REF:
    5165         6060 :       dump_generic_node (pp, op0, 0, flags, false);
    5166         6060 :       break;
    5167              : 
    5168            2 :     default:
    5169            2 :       NIY;
    5170              :     }
    5171       190564 : }
    5172              : 
    5173              : /* Print the first N characters in the array STR, replacing non-printable
    5174              :    characters (including embedded nuls) with unambiguous escape sequences.  */
    5175              : 
    5176              : void
    5177        62309 : pretty_print_string (pretty_printer *pp, const char *str, size_t n)
    5178              : {
    5179        62309 :   if (str == NULL)
    5180              :     return;
    5181              : 
    5182      1483447 :   for ( ; n; --n, ++str)
    5183              :     {
    5184      1421138 :       switch (str[0])
    5185              :         {
    5186           26 :         case '\b':
    5187           26 :           pp_string (pp, "\\b");
    5188           26 :           break;
    5189              : 
    5190           30 :         case '\f':
    5191           30 :           pp_string (pp, "\\f");
    5192           30 :           break;
    5193              : 
    5194         2942 :         case '\n':
    5195         2942 :           pp_string (pp, "\\n");
    5196         2942 :           break;
    5197              : 
    5198           18 :         case '\r':
    5199           18 :           pp_string (pp, "\\r");
    5200           18 :           break;
    5201              : 
    5202           44 :         case '\t':
    5203           44 :           pp_string (pp, "\\t");
    5204           44 :           break;
    5205              : 
    5206           20 :         case '\v':
    5207           20 :           pp_string (pp, "\\v");
    5208           20 :           break;
    5209              : 
    5210           51 :         case '\\':
    5211           51 :           pp_string (pp, "\\\\");
    5212           51 :           break;
    5213              : 
    5214          146 :         case '\"':
    5215          146 :           pp_string (pp, "\\\"");
    5216          146 :           break;
    5217              : 
    5218        14903 :         case '\'':
    5219        14903 :           pp_string (pp, "\\'");
    5220        14903 :           break;
    5221              : 
    5222      1402958 :         default:
    5223      1402958 :           if (str[0] || n > 1)
    5224              :             {
    5225      1361989 :               if (!ISPRINT (str[0]))
    5226              :                 {
    5227         6914 :                   char buf[5];
    5228         6914 :                   sprintf (buf, "\\x%02x", (unsigned char)str[0]);
    5229         6914 :                   pp_string (pp, buf);
    5230              :                 }
    5231              :               else
    5232      1355075 :                 pp_character (pp, str[0]);
    5233              :               break;
    5234              :             }
    5235              :         }
    5236              :     }
    5237              : }
    5238              : 
    5239              : static void
    5240      7186527 : maybe_init_pretty_print (FILE *file)
    5241              : {
    5242      7186527 :   if (!tree_pp)
    5243              :     {
    5244        19269 :       tree_pp = new pretty_printer ();
    5245        19269 :       pp_needs_newline (tree_pp) = true;
    5246        19269 :       pp_translate_identifiers (tree_pp) = false;
    5247              :     }
    5248              : 
    5249      7186527 :   tree_pp->set_output_stream (file);
    5250      7186527 : }
    5251              : 
    5252              : static void
    5253       583305 : newline_and_indent (pretty_printer *pp, int spc)
    5254              : {
    5255       583305 :   pp_newline (pp);
    5256      7164346 :   INDENT (spc);
    5257       583305 : }
    5258              : 
    5259              : /* Print the identifier ID to PRETTY-PRINTER.  */
    5260              : 
    5261              : void
    5262     16743025 : pp_tree_identifier (pretty_printer *pp, tree id)
    5263              : {
    5264     16743025 :   if (pp_translate_identifiers (pp))
    5265              :     {
    5266      9115096 :       const char *text = identifier_to_locale (IDENTIFIER_POINTER (id));
    5267      9115096 :       pp_append_text (pp, text, text + strlen (text));
    5268              :     }
    5269              :   else
    5270      7627929 :     pp_append_text (pp, IDENTIFIER_POINTER (id),
    5271      7627929 :                     IDENTIFIER_POINTER (id) + IDENTIFIER_LENGTH (id));
    5272     16743025 : }
    5273              : 
    5274              : /* A helper function that is used to dump function information before the
    5275              :    function dump.  */
    5276              : 
    5277              : void
    5278        62082 : dump_function_header (FILE *dump_file, tree fdecl, dump_flags_t flags)
    5279              : {
    5280        62082 :   const char *dname, *aname;
    5281        62082 :   struct cgraph_node *node = cgraph_node::get (fdecl);
    5282        62082 :   struct function *fun = DECL_STRUCT_FUNCTION (fdecl);
    5283              : 
    5284        62082 :   dname = lang_hooks.decl_printable_name (fdecl, 1);
    5285              : 
    5286        62082 :   if (DECL_ASSEMBLER_NAME_SET_P (fdecl))
    5287        62078 :     aname = (IDENTIFIER_POINTER
    5288              :              (DECL_ASSEMBLER_NAME (fdecl)));
    5289              :   else
    5290              :     aname = "<unset-asm-name>";
    5291              : 
    5292        62082 :   fprintf (dump_file, "\n;; Function %s (%s, funcdef_no=%d",
    5293              :            dname, aname, fun->funcdef_no);
    5294        62082 :   if (!(flags & TDF_NOUID))
    5295        58101 :     fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
    5296        62082 :   if (node)
    5297              :     {
    5298        62082 :       fprintf (dump_file, ", cgraph_uid=%d", node->get_uid ());
    5299        62082 :       fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->order,
    5300        62082 :                node->frequency == NODE_FREQUENCY_HOT
    5301              :                ? " (hot)"
    5302              :                : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
    5303        61992 :                ? " (unlikely executed)"
    5304              :                : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
    5305        61691 :                ? " (executed once)"
    5306              :                : "");
    5307              :     }
    5308              :   else
    5309            0 :     fprintf (dump_file, ")\n\n");
    5310        62082 : }
    5311              : 
    5312              : #if __GNUC__ >= 10
    5313              : #  pragma GCC diagnostic pop
    5314              : #endif
        

Generated by: LCOV version 2.5.0-beta

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.