LCOV - code coverage report
Current view: top level - gcc/c - gimple-parser.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 88.6 % 1418 1256
Test Date: 2026-11-14 16:39:50 Functions: 100.0 % 28 28
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /* Parser for GIMPLE.
       2              :    Copyright (C) 2016-2026 Free Software Foundation, Inc.
       3              : 
       4              : This file is part of GCC.
       5              : 
       6              : GCC is free software; you can redistribute it and/or modify it under
       7              : the terms of the GNU General Public License as published by the Free
       8              : Software Foundation; either version 3, or (at your option) any later
       9              : version.
      10              : 
      11              : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12              : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13              : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14              : for more details.
      15              : 
      16              : You should have received a copy of the GNU General Public License
      17              : along with GCC; see the file COPYING3.  If not see
      18              : <http://www.gnu.org/licenses/>.  */
      19              : 
      20              : #include "config.h"
      21              : #include "system.h"
      22              : #include "coretypes.h"
      23              : #include "target.h"
      24              : #include "function.h"
      25              : #include "c-tree.h"
      26              : #include "timevar.h"
      27              : #include "stringpool.h"
      28              : #include "cgraph.h"
      29              : #include "attribs.h"
      30              : #include "stor-layout.h"
      31              : #include "varasm.h"
      32              : #include "trans-mem.h"
      33              : #include "c-family/c-pragma.h"
      34              : #include "c-lang.h"
      35              : #include "c-family/c-objc.h"
      36              : #include "plugin.h"
      37              : #include "builtins.h"
      38              : #include "gomp-constants.h"
      39              : #include "c-family/c-indentation.h"
      40              : #include "gimple-expr.h"
      41              : #include "context.h"
      42              : #include "gcc-rich-location.h"
      43              : #include "c-parser.h"
      44              : #include "tree-vrp.h"
      45              : #include "tree-pass.h"
      46              : #include "tree-pretty-print.h"
      47              : #include "tree.h"
      48              : #include "basic-block.h"
      49              : #include "gimple.h"
      50              : #include "gimple-pretty-print.h"
      51              : #include "tree-ssa.h"
      52              : #include "pass_manager.h"
      53              : #include "tree-ssanames.h"
      54              : #include "gimple-ssa.h"
      55              : #include "tree-dfa.h"
      56              : #include "internal-fn.h"
      57              : #include "cfg.h"
      58              : #include "cfghooks.h"
      59              : #include "bitmap.h"
      60              : #include "cfganal.h"
      61              : #include "tree-cfg.h"
      62              : #include "gimple-iterator.h"
      63              : #include "cfgloop.h"
      64              : #include "tree-phinodes.h"
      65              : #include "tree-into-ssa.h"
      66              : 
      67              : 
      68              : /* GIMPLE parser state.  */
      69              : 
      70         2148 : class gimple_parser
      71              : {
      72              : public:
      73         1074 :   gimple_parser (c_parser *p) : parser (p), edges(), current_bb(NULL) {}
      74              :   /* c_parser is not visible here, use composition and fake inheritance
      75              :      via a conversion operator.  */
      76       494209 :   operator c_parser *() { return parser; }
      77              :   c_parser *parser;
      78              : 
      79              :   /* CFG build state.  */
      80         2066 :   class gimple_parser_edge
      81              :   {
      82              :   public:
      83              :     int src;
      84              :     int dest;
      85              :     int flags;
      86              :     profile_probability probability;
      87              :   };
      88              :   auto_vec<gimple_parser_edge> edges;
      89              :   basic_block current_bb;
      90              : 
      91              :   void push_edge (int, int, int, profile_probability);
      92              : };
      93              : 
      94              : void
      95         2066 : gimple_parser::push_edge (int src, int dest, int flags,
      96              :                           profile_probability prob)
      97              : {
      98         2066 :   gimple_parser_edge e;
      99         2066 :   e.src = src;
     100         2066 :   e.dest = dest;
     101         2066 :   e.flags = flags;
     102         2066 :   e.probability = prob;
     103         2066 :   edges.safe_push (e);
     104         2066 : }
     105              : 
     106              : 
     107              : /* Gimple parsing functions.  */
     108              : static bool c_parser_gimple_compound_statement (gimple_parser &, gimple_seq *);
     109              : static void c_parser_gimple_label (gimple_parser &, gimple_seq *);
     110              : static void c_parser_gimple_statement (gimple_parser &, gimple_seq *);
     111              : static struct c_expr c_parser_gimple_binary_expression (gimple_parser &, tree);
     112              : static struct c_expr c_parser_gimple_unary_expression (gimple_parser &);
     113              : static struct c_expr c_parser_gimple_postfix_expression
     114              :                         (gimple_parser &, tree = error_mark_node);
     115              : static struct c_expr c_parser_gimple_postfix_expression_after_primary
     116              :                         (gimple_parser &, location_t, struct c_expr);
     117              : static void c_parser_gimple_declaration (gimple_parser &);
     118              : static void c_parser_gimple_goto_stmt (gimple_parser &, location_t,
     119              :                                        tree, gimple_seq *);
     120              : static void c_parser_gimple_try_stmt (gimple_parser &, gimple_seq *);
     121              : static void c_parser_gimple_if_stmt (gimple_parser &, gimple_seq *);
     122              : static void c_parser_gimple_switch_stmt (gimple_parser &, gimple_seq *);
     123              : static void c_parser_gimple_return_stmt (gimple_parser &, gimple_seq *);
     124              : static void c_finish_gimple_return (location_t, tree);
     125              : static tree c_parser_gimple_paren_condition (gimple_parser &);
     126              : static void c_parser_gimple_expr_list (gimple_parser &, vec<tree> *);
     127              : 
     128              : 
     129              : /* Much like parser_build_unary_op, but avoid applying default conversions.  */
     130              : 
     131              : static c_expr
     132          137 : gimple_parser_build_unary_op (location_t loc,
     133              :                               enum tree_code code, struct c_expr arg)
     134              : {
     135          137 :   struct c_expr result;
     136              : 
     137          137 :   result.original_code = code;
     138          137 :   result.original_type = NULL;
     139          137 :   result.m_decimal = 0;
     140              : 
     141          137 :   if (reject_gcc_builtin (arg.value))
     142              :     {
     143            0 :       result.value = error_mark_node;
     144              :     }
     145              :   else
     146              :     {
     147          137 :       result.value = build_unary_op (loc, code, arg.value, true);
     148              : 
     149          137 :       if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value))
     150            0 :         overflow_warning (loc, result.value, arg.value);
     151              :     }
     152              : 
     153              :   /* We are typically called when parsing a prefix token at LOC acting on
     154              :      ARG.  Reflect this by updating the source range of the result to
     155              :      start at LOC and end at the end of ARG.  */
     156          137 :   set_c_expr_source_range (&result,
     157              :                            loc, arg.get_finish ());
     158              : 
     159          137 :   return result;
     160              : }
     161              : 
     162              : /* See if VAL is an identifier matching __BB<num> and return <num>
     163              :    in *INDEX.  */
     164              : 
     165              : static bool
     166         1975 : c_parser_gimple_parse_bb_spec (tree val, int *index)
     167              : {
     168         1975 :   if (!startswith (IDENTIFIER_POINTER (val), "__BB"))
     169              :     return false;
     170              : 
     171         1975 :   const char *bb = IDENTIFIER_POINTER (val) + 4;
     172         1975 :   if (! ISDIGIT (*bb))
     173              :     return false;
     174              : 
     175         1975 :   char *pend;
     176         1975 :   errno = 0;
     177         1975 :   const unsigned long number = strtoul (bb, &pend, 10);
     178         1975 :   if (errno == ERANGE
     179         1975 :       || *pend != '\0'
     180         1975 :       || number > INT_MAX)
     181              :     return false;
     182              : 
     183         1975 :   *index = number;
     184         1975 :   return true;
     185              : }
     186              : 
     187              : /* See if VAL is an identifier matching __BB<num> and return <num>
     188              :    in *INDEX.  Return true if so and parse also FREQUENCY of
     189              :    the edge.  */
     190              : 
     191              : 
     192              : static bool
     193         1218 : c_parser_gimple_parse_bb_spec_edge_probability (tree val,
     194              :                                                 gimple_parser &parser,
     195              :                                                 int *index,
     196              :                                                 profile_probability
     197              :                                                 *probability)
     198              : {
     199         1218 :   bool return_p = c_parser_gimple_parse_bb_spec (val, index);
     200         1218 :   if (return_p)
     201              :     {
     202         1218 :       *probability = profile_probability::uninitialized ();
     203              :       /* Parse frequency if provided.  */
     204         1218 :       if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
     205              :         {
     206          441 :           tree f;
     207          441 :           c_parser_consume_token (parser);
     208          441 :           if (!c_parser_next_token_is (parser, CPP_NAME))
     209              :             {
     210            0 :               c_parser_error (parser, "expected frequency quality");
     211            0 :               return false;
     212              :             }
     213              : 
     214          441 :           profile_quality quality;
     215          441 :           const char *v
     216          441 :             = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
     217          441 :           if (!parse_profile_quality (v, &quality))
     218              :             {
     219            0 :               c_parser_error (parser, "unknown profile quality");
     220            0 :               return false;
     221              :             }
     222              : 
     223          441 :           c_parser_consume_token (parser);
     224          441 :           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
     225              :             return false;
     226              : 
     227          441 :           if (!c_parser_next_token_is (parser, CPP_NUMBER)
     228          441 :               || (TREE_CODE (f = c_parser_peek_token (parser)->value)
     229              :                   != INTEGER_CST))
     230              :             {
     231            0 :               c_parser_error (parser, "expected frequency value");
     232            0 :               return false;
     233              :             }
     234              : 
     235          441 :           unsigned int value = TREE_INT_CST_LOW (f);
     236          441 :           *probability = profile_probability (value, quality);
     237              : 
     238          441 :           c_parser_consume_token (parser);
     239          441 :           if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
     240              :             return false;
     241              : 
     242          441 :           if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
     243              :             return false;
     244              :         }
     245              : 
     246              :       return true;
     247              :     }
     248              : 
     249              :   return false;
     250              : 
     251              : }
     252              : 
     253              : /* Parse the body of a function declaration marked with "__GIMPLE".  */
     254              : 
     255              : void
     256         1074 : c_parser_parse_gimple_body (c_parser *cparser, char *gimple_pass,
     257              :                             enum c_declspec_il cdil,
     258              :                             profile_count entry_bb_count)
     259              : {
     260         1074 :   gimple_parser parser (cparser);
     261         1074 :   gimple_seq seq = NULL;
     262         1074 :   gimple_seq body = NULL;
     263         1074 :   tree stmt = push_stmt_list ();
     264         1074 :   push_scope ();
     265         1074 :   location_t loc1 = c_parser_peek_token (parser)->location;
     266              : 
     267         1074 :   cfun->pass_startwith = gimple_pass;
     268         1074 :   init_tree_ssa (cfun);
     269              : 
     270         1074 :   if (cdil == cdil_gimple)
     271              :     /* While we have SSA names in the IL we do not have a CFG built yet
     272              :        and PHIs are represented using a PHI internal function.  We do
     273              :        have lowered control flow and exception handling (well, we do not
     274              :        have parser support for EH yet).  But as we still have BINDs
     275              :        we have to go through lowering again.  */
     276          656 :     cfun->curr_properties = PROP_gimple_any;
     277              :   else
     278              :     {
     279              :       /* We have at least cdil_gimple_cfg.  */
     280          418 :       gimple_register_cfg_hooks ();
     281          418 :       init_empty_tree_cfg ();
     282          418 :       parser.current_bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
     283              :       /* Initialize the bare loop structure - we are going to only
     284              :          mark headers and leave the rest to fixup.  */
     285          418 :       set_loops_for_fn (cfun, ggc_cleared_alloc<struct loops> ());
     286          418 :       init_loops_structure (cfun, loops_for_fn (cfun), 1);
     287          418 :       loops_state_set (cfun, LOOPS_NEED_FIXUP|LOOPS_MAY_HAVE_MULTIPLE_LATCHES);
     288          418 :       cfun->curr_properties
     289          418 :         |= PROP_gimple_lcf | PROP_gimple_leh | PROP_cfg | PROP_loops;
     290          418 :       if (cdil == cdil_gimple_ssa)
     291              :         {
     292          418 :           init_ssa_operands (cfun);
     293          418 :           cfun->curr_properties |= PROP_ssa;
     294              :         }
     295              :     }
     296              : 
     297         1074 :   if (! c_parser_gimple_compound_statement (parser, &seq)
     298         1074 :       && cdil == cdil_gimple)
     299              :     {
     300          415 :       gimple *ret = gimple_build_return (NULL);
     301          415 :       gimple_seq_add_stmt_without_update (&seq, ret);
     302              :     }
     303              : 
     304         1074 :   tree block = pop_scope ();
     305         1074 :   stmt = pop_stmt_list (stmt);
     306         1074 :   stmt = c_build_bind_expr (loc1, block, stmt);
     307              : 
     308         1074 :   block = DECL_INITIAL (current_function_decl);
     309         1074 :   BLOCK_SUBBLOCKS (block) = NULL_TREE;
     310         1074 :   BLOCK_CHAIN (block) = NULL_TREE;
     311         1074 :   TREE_ASM_WRITTEN (block) = 1;
     312              : 
     313         1074 :   if (cdil == cdil_gimple)
     314              :     {
     315         1312 :       gbind *bind_stmt = gimple_build_bind (BIND_EXPR_VARS (stmt), NULL,
     316          656 :                                             BIND_EXPR_BLOCK (stmt));
     317          656 :       gimple_bind_set_body (bind_stmt, seq);
     318          656 :       gimple_seq_add_stmt_without_update (&body, bind_stmt);
     319          656 :       gimple_set_body (current_function_decl, body);
     320              :     }
     321              :   else
     322              :     {
     323              :       /* Control-flow and binds are lowered, record local decls.  */
     324          991 :       for (tree var = BIND_EXPR_VARS (stmt); var; var = DECL_CHAIN (var))
     325          573 :         if (VAR_P (var)
     326          573 :             && !DECL_EXTERNAL (var))
     327              :           {
     328          559 :             add_local_decl (cfun, var);
     329              :             /* When the middle-end re-gimplifies any expression we might
     330              :                run into the assertion that we've seen the decl in a BIND.  */
     331          559 :             if (!TREE_STATIC (var))
     332          559 :               DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
     333              :           }
     334              :       /* We have a CFG.  Build the edges.  */
     335         2484 :       for (unsigned i = 0; i < parser.edges.length (); ++i)
     336              :         {
     337         4132 :           edge e = make_edge (BASIC_BLOCK_FOR_FN (cfun, parser.edges[i].src),
     338         2066 :                               BASIC_BLOCK_FOR_FN (cfun, parser.edges[i].dest),
     339         2066 :                               parser.edges[i].flags);
     340         2066 :           e->probability = parser.edges[i].probability;
     341              :         }
     342              :       /* Add edges for case labels.  */
     343          418 :       basic_block bb;
     344         1698 :       FOR_EACH_BB_FN (bb, cfun)
     345         1280 :         if (EDGE_COUNT (bb->succs) == 0)
     346              :           {
     347         1308 :             if (gswitch *sw = safe_dyn_cast <gswitch *> (*gsi_last_bb (bb)))
     348           17 :               for (unsigned i = 0; i < gimple_switch_num_labels (sw); ++i)
     349              :                 {
     350           13 :                   basic_block label_bb = gimple_switch_label_bb (cfun, sw, i);
     351           13 :                   make_edge (bb, label_bb, 0);
     352              :                 }
     353              :           }
     354              :       /* Need those for loop fixup.  */
     355          418 :       calculate_dominance_info (CDI_DOMINATORS);
     356              :       /* With SSA lower PHIs parsed as internal function calls and
     357              :          update stmts.  */
     358          418 :       if (cdil == cdil_gimple_ssa)
     359              :         {
     360              :           /* Create PHI nodes, they are parsed into __PHI internal calls
     361              :              and update SSA operands.  */
     362         1698 :           FOR_EACH_BB_FN (bb, cfun)
     363              :             {
     364         1280 :               gimple_stmt_iterator gsi;
     365         2957 :               for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
     366              :                 {
     367         1402 :                   gimple *stmt = gsi_stmt (gsi);
     368         1402 :                   if (!gimple_call_internal_p (stmt, IFN_PHI))
     369              :                     break;
     370              : 
     371          397 :                   gphi *phi = create_phi_node (gimple_call_lhs (stmt), bb);
     372         1551 :                   for (unsigned i = 0; i < gimple_call_num_args (stmt); i += 2)
     373              :                     {
     374          757 :                       int srcidx = TREE_INT_CST_LOW (gimple_call_arg (stmt, i));
     375          757 :                       edge e = find_edge (BASIC_BLOCK_FOR_FN (cfun, srcidx), bb);
     376          757 :                       if (!e)
     377            0 :                         c_parser_error (parser, "edge not found");
     378              :                       else
     379          757 :                         add_phi_arg (phi, gimple_call_arg (stmt, i + 1), e,
     380              :                                      UNKNOWN_LOCATION);
     381              :                     }
     382          397 :                   gsi_remove (&gsi, true);
     383              :                 }
     384         4887 :               for (; !gsi_end_p (gsi); gsi_next (&gsi))
     385         3607 :                 update_stmt (gsi_stmt (gsi));
     386              :             }
     387              :           /* Fill SSA name gaps, putting them on the freelist and diagnose
     388              :              SSA names without definition.  */
     389         8843 :           for (unsigned i = 1; i < num_ssa_names; ++i)
     390         8425 :             if (!ssa_name (i))
     391              :               {
     392         5275 :                 tree name = make_ssa_name_fn (cfun, integer_type_node, NULL, i);
     393         5275 :                 release_ssa_name_fn (cfun, name);
     394              :               }
     395         3150 :             else if (!SSA_NAME_DEF_STMT (ssa_name (i)))
     396            1 :               error ("SSA name %qE with version %d has no definition",
     397              :                      ssa_name (i), i);
     398              :           /* No explicit virtual operands (yet).  */
     399          418 :           bitmap_obstack_initialize (NULL);
     400          418 :           update_ssa (TODO_update_ssa_only_virtuals);
     401          418 :           bitmap_obstack_release (NULL);
     402              :           /* ???  By flushing the freelist after virtual operand SSA rewrite
     403              :              we keep the gaps available for re-use like needed for the
     404              :              PR89595 testcase but then usually virtual operands would have
     405              :              taken most of them.  The fix is obviously to make virtual
     406              :              operands explicit in the SSA IL.  */
     407          418 :           flush_ssaname_freelist ();
     408              :         }
     409          418 :       fix_loop_structure (NULL);
     410              :     }
     411              : 
     412         1074 :   if (cfun->curr_properties & PROP_cfg)
     413              :     {
     414          418 :       ENTRY_BLOCK_PTR_FOR_FN (cfun)->count = entry_bb_count;
     415          418 :       gcov_type t = param_gimple_fe_computed_hot_bb_threshold;
     416          418 :       set_hot_bb_threshold (t);
     417          418 :       update_max_bb_count ();
     418          418 :       cgraph_node::get_create (cfun->decl);
     419          418 :       cgraph_edge::rebuild_edges ();
     420              :     }
     421              : 
     422              :   /* Perform IL validation and if any error is found abort compilation
     423              :      of this function by zapping its body.  */
     424         1074 :   if ((cfun->curr_properties & PROP_cfg)
     425         1074 :       && verify_gimple_in_cfg (cfun, false, false))
     426            0 :     init_empty_tree_cfg ();
     427         1074 :   else if (!(cfun->curr_properties & PROP_cfg)
     428         1074 :            && verify_gimple_in_seq (gimple_body (current_function_decl), false))
     429            1 :     gimple_set_body (current_function_decl, NULL);
     430              : 
     431         1074 :   dump_function (TDI_gimple, current_function_decl);
     432         1074 : }
     433              : 
     434              : /* Parse a compound statement in gimple function body.
     435              : 
     436              :    gimple-statement:
     437              :      gimple-statement
     438              :      gimple-declaration-statement
     439              :      gimple-if-statement
     440              :      gimple-switch-statement
     441              :      gimple-labeled-statement
     442              :      gimple-expression-statement
     443              :      gimple-goto-statement
     444              :      gimple-phi-statement
     445              :      gimple-return-statement
     446              : */
     447              : 
     448              : static bool
     449         1084 : c_parser_gimple_compound_statement (gimple_parser &parser, gimple_seq *seq)
     450              : {
     451         1084 :   bool return_p = false;
     452              : 
     453         1084 :   if (! c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
     454              :     return false;
     455              : 
     456              :   /* A compound statement starts with optional declarations.  */
     457         5508 :   while (c_parser_next_tokens_start_declaration (parser))
     458              :     {
     459         4424 :       c_parser_gimple_declaration (parser);
     460         4424 :       if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
     461              :         return false;
     462              :     }
     463              : 
     464         9837 :   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
     465              :     {
     466         8757 :       if (c_parser_error (parser))
     467              :         {
     468            4 :           c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
     469            4 :           return return_p;
     470              :         }
     471         8753 :       else if (c_parser_next_token_is (parser, CPP_EOF))
     472              :         {
     473            0 :           c_parser_error (parser, "expected declaration or statement");
     474            0 :           return return_p;
     475              :         }
     476              : 
     477         8753 :       switch (c_parser_peek_token (parser)->type)
     478              :         {
     479         1537 :         case CPP_KEYWORD:
     480         1537 :           switch (c_parser_peek_token (parser)->keyword)
     481              :             {
     482            0 :             case RID_AT_TRY:
     483            0 :               c_parser_gimple_try_stmt (parser, seq);
     484            0 :               break;
     485          403 :             case RID_IF:
     486          403 :               c_parser_gimple_if_stmt (parser, seq);
     487          403 :               break;
     488            5 :             case RID_SWITCH:
     489            5 :               c_parser_gimple_switch_stmt (parser, seq);
     490            5 :               break;
     491          458 :             case RID_GOTO:
     492          458 :               {
     493          458 :                 location_t loc = c_parser_peek_token (parser)->location;
     494          458 :                 c_parser_consume_token (parser);
     495          458 :                 if (c_parser_next_token_is (parser, CPP_NAME))
     496              :                   {
     497          458 :                     tree label = c_parser_peek_token (parser)->value;
     498          458 :                     c_parser_consume_token (parser);
     499          458 :                     c_parser_gimple_goto_stmt (parser, loc, label, seq);
     500          458 :                     if (! c_parser_require (parser, CPP_SEMICOLON,
     501              :                                             "expected %<;%>"))
     502              :                       return return_p;
     503              :                   }
     504              :                 }
     505              :               break;
     506          671 :             case RID_RETURN:
     507          671 :               return_p = true;
     508          671 :               c_parser_gimple_return_stmt (parser, seq);
     509          671 :               if (! c_parser_require (parser, CPP_SEMICOLON,
     510              :                                       "expected %<;%>"))
     511              :                 return return_p;
     512          671 :               if (cfun->curr_properties & PROP_cfg)
     513          430 :                 parser.push_edge (parser.current_bb->index, EXIT_BLOCK, 0,
     514              :                                   profile_probability::uninitialized ());
     515              :               break;
     516            0 :             default:
     517            0 :               goto expr_stmt;
     518              :             }
     519              :           break;
     520         7189 :         case CPP_NAME:
     521         7189 :           if (c_parser_peek_2nd_token (parser)->type == CPP_COLON)
     522              :             {
     523           73 :               c_parser_gimple_label (parser, seq);
     524           73 :               break;
     525              :             }
     526         7116 :           if (c_parser_next_token_is (parser, CPP_NAME)
     527         7116 :               && c_parser_peek_token (parser)->id_kind == C_ID_ID
     528        14232 :               && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser)->value),
     529              :                          "try") == 0)
     530              :             {
     531            4 :               c_parser_gimple_try_stmt (parser, seq);
     532            4 :               break;
     533              :             }
     534              :           /* Basic block specification.
     535              :              __BB (index, ...)  */
     536         7112 :           if ((cfun->curr_properties & PROP_cfg)
     537         7112 :               && !strcmp (IDENTIFIER_POINTER
     538              :                             (c_parser_peek_token (parser)->value), "__BB"))
     539              :             {
     540         1280 :               c_parser_consume_token (parser);
     541         1280 :               if (! c_parser_require (parser, CPP_OPEN_PAREN,
     542              :                                       "expected %<(%>"))
     543         1084 :                 return return_p;
     544         1280 :               if (c_parser_next_token_is_not (parser, CPP_NUMBER))
     545              :                 {
     546            0 :                   c_parser_error (parser, "expected block index");
     547            0 :                   return return_p;
     548              :                 }
     549         1280 :               tree tnum = c_parser_peek_token (parser)->value;
     550         1280 :               if (TREE_CODE (tnum) != INTEGER_CST)
     551              :                 {
     552            0 :                   c_parser_error (parser, "expected block index");
     553            0 :                   return return_p;
     554              :                 }
     555         1280 :               int index = TREE_INT_CST_LOW (tnum);
     556         1280 :               if (index < NUM_FIXED_BLOCKS
     557         1280 :                   || (index < last_basic_block_for_fn (cfun)
     558          237 :                       && BASIC_BLOCK_FOR_FN (cfun, index) != NULL))
     559              :                 {
     560            0 :                   c_parser_error (parser, "invalid block index");
     561            0 :                   return return_p;
     562              :                 }
     563         1280 :               int is_loop_header_of = -1;
     564         1280 :               profile_count bb_count = profile_count::uninitialized ();
     565         1280 :               c_parser_consume_token (parser);
     566         3086 :               while (c_parser_next_token_is (parser, CPP_COMMA))
     567              :                 {
     568          526 :                   c_parser_consume_token (parser);
     569          526 :                   if (! c_parser_next_token_is (parser, CPP_NAME))
     570              :                     {
     571            0 :                       c_parser_error (parser, "expected block specifier");
     572            0 :                       return return_p;
     573              :                     }
     574              :                   /* loop_header (NUM)  */
     575          526 :                   if (!strcmp (IDENTIFIER_POINTER
     576              :                                  (c_parser_peek_token (parser)->value),
     577              :                                "loop_header"))
     578              :                     {
     579          101 :                       c_parser_consume_token (parser);
     580          101 :                       if (! c_parser_require (parser, CPP_OPEN_PAREN,
     581              :                                               "expected %<(%>"))
     582              :                         return return_p;
     583          101 :                       tree loop_num;
     584          101 :                       if (! c_parser_next_token_is (parser, CPP_NUMBER)
     585          101 :                           || TREE_CODE (loop_num
     586              :                                           = c_parser_peek_token (parser)->value)
     587              :                                != INTEGER_CST)
     588              :                         {
     589            0 :                           c_parser_error (parser, "expected loop number");
     590            0 :                           return return_p;
     591              :                         }
     592          101 :                       c_parser_consume_token (parser);
     593          101 :                       is_loop_header_of = TREE_INT_CST_LOW (loop_num);
     594          101 :                       if (! c_parser_require (parser, CPP_CLOSE_PAREN,
     595              :                                               "expected %<)%>"))
     596              :                         return return_p;
     597              :                     }
     598              :                   /* Parse profile: quality(value) */
     599              :                   else
     600              :                     {
     601          425 :                       tree q;
     602          425 :                       profile_quality quality;
     603          425 :                       tree v = c_parser_peek_token (parser)->value;
     604          425 :                       if (!parse_profile_quality (IDENTIFIER_POINTER (v),
     605              :                                                   &quality))
     606              :                         {
     607            0 :                           c_parser_error (parser, "unknown block specifier");
     608            0 :                           return false;
     609              :                         }
     610              : 
     611          425 :                       c_parser_consume_token (parser);
     612          425 :                       if (!c_parser_require (parser, CPP_OPEN_PAREN,
     613              :                                              "expected %<(%>"))
     614              :                         return false;
     615              : 
     616          425 :                       if (!c_parser_next_token_is (parser, CPP_NUMBER)
     617          425 :                           || (TREE_CODE (q = c_parser_peek_token (parser)->value)
     618              :                               != INTEGER_CST))
     619              :                         {
     620            0 :                           c_parser_error (parser, "expected count value");
     621            0 :                           return false;
     622              :                         }
     623              : 
     624          425 :                       bb_count
     625          425 :                         = profile_count::from_gcov_type (TREE_INT_CST_LOW (q),
     626              :                                                          quality);
     627          425 :                       c_parser_consume_token (parser);
     628          425 :                       if (! c_parser_require (parser, CPP_CLOSE_PAREN,
     629              :                                               "expected %<)%>"))
     630              :                         return return_p;
     631              :                     }
     632              :                 }
     633         1280 :               if (! c_parser_require (parser, CPP_CLOSE_PAREN,
     634              :                                       "expected %<)%>")
     635         1280 :                   || ! c_parser_require (parser, CPP_COLON,
     636              :                                          "expected %<:%>"))
     637              :                 return return_p;
     638              : 
     639              :               /* Put stmts parsed in the current block.  */
     640         1280 :               if (!gimple_seq_empty_p (*seq))
     641              :                 {
     642          596 :                   if (!parser.current_bb)
     643            0 :                     c_parser_error (parser, "stmts without block");
     644              :                   else
     645              :                     {
     646          596 :                       gimple_stmt_iterator gsi
     647          596 :                         = gsi_start_bb (parser.current_bb);
     648          596 :                       gsi_insert_seq_after_without_update (&gsi, *seq,
     649              :                                                            GSI_CONTINUE_LINKING);
     650              :                     }
     651          596 :                   *seq = NULL;
     652              :                 }
     653              : 
     654              :               /* Build an empty block with specified index, linking them
     655              :                  in source order.  */
     656         1280 :               basic_block bb = alloc_block ();
     657         1280 :               bb->index = index;
     658         1280 :               link_block (bb, (parser.current_bb ? parser.current_bb
     659            0 :                                : ENTRY_BLOCK_PTR_FOR_FN (cfun)));
     660         1280 :               if (basic_block_info_for_fn (cfun)->length () <= (size_t)index)
     661            1 :                 vec_safe_grow_cleared (basic_block_info_for_fn (cfun),
     662            1 :                                        index + 1, true);
     663         1280 :               SET_BASIC_BLOCK_FOR_FN (cfun, index, bb);
     664         1280 :               if (last_basic_block_for_fn (cfun) <= index)
     665         1043 :                 last_basic_block_for_fn (cfun) = index + 1;
     666         1280 :               n_basic_blocks_for_fn (cfun)++;
     667         1280 :               if (parser.current_bb->index == ENTRY_BLOCK)
     668          418 :                 parser.push_edge (ENTRY_BLOCK, bb->index, EDGE_FALLTHRU,
     669              :                                   profile_probability::always ());
     670              : 
     671              :               /* We leave the proper setting to fixup.  */
     672         1280 :               class loop *loop_father = loops_for_fn (cfun)->tree_root;
     673              :               /* If the new block is a loop header, allocate a loop
     674              :                  struct.  Fixup will take care of proper placement within
     675              :                  the loop tree.  */
     676         1280 :               if (is_loop_header_of != -1)
     677              :                 {
     678          101 :                   if (number_of_loops (cfun) > (unsigned)is_loop_header_of
     679          101 :                       && get_loop (cfun, is_loop_header_of) != NULL)
     680              :                     {
     681            0 :                       c_parser_error (parser, "duplicate loop header");
     682              :                     }
     683              :                   else
     684              :                     {
     685          101 :                       class loop *loop = alloc_loop ();
     686          101 :                       loop->num = is_loop_header_of;
     687          101 :                       loop->header = bb;
     688          202 :                       if (number_of_loops (cfun) <= (unsigned)is_loop_header_of)
     689           98 :                         vec_safe_grow_cleared (loops_for_fn (cfun)->larray,
     690           98 :                                                is_loop_header_of + 1, true);
     691          101 :                       (*loops_for_fn (cfun)->larray)[is_loop_header_of] = loop;
     692          101 :                       flow_loop_tree_node_add (loops_for_fn (cfun)->tree_root,
     693              :                                                loop);
     694              :                     }
     695          101 :                   loop_father = get_loop (cfun, is_loop_header_of);
     696              :                 }
     697         1280 :               bb->loop_father = loop_father;
     698         1280 :               bb->count = bb_count;
     699              : 
     700              :               /* Stmts now go to the new block.  */
     701         1280 :               parser.current_bb = bb;
     702         1280 :               break;
     703              :             }
     704         5832 :           goto expr_stmt;
     705              : 
     706            5 :         case CPP_SEMICOLON:
     707            5 :           {
     708              :             /* Empty stmt.  */
     709            5 :             location_t loc = c_parser_peek_token (parser)->location;
     710            5 :             c_parser_consume_token (parser);
     711            5 :             gimple *nop = gimple_build_nop ();
     712            5 :             gimple_set_location (nop, loc);
     713            5 :             gimple_seq_add_stmt_without_update (seq, nop);
     714            5 :             break;
     715              :           }
     716              : 
     717            1 :         case CPP_CLOSE_PAREN:
     718            1 :         case CPP_CLOSE_SQUARE:
     719              :           /* Avoid infinite loop in error recovery:
     720              :              c_parser_skip_until_found stops at a closing nesting
     721              :              delimiter without consuming it, but here we need to consume
     722              :              it to proceed further.  */
     723            1 :           c_parser_error (parser, "expected statement");
     724            1 :           c_parser_consume_token (parser);
     725            1 :         break;
     726              : 
     727         5853 :         default:
     728         5853 : expr_stmt:
     729         5853 :           c_parser_gimple_statement (parser, seq);
     730         5853 :           if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
     731            3 :             c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
     732              :         }
     733              :     }
     734         1080 :   c_parser_consume_token (parser);
     735              : 
     736              :   /* Put stmts parsed in the current block.  */
     737         1080 :   if ((cfun->curr_properties & PROP_cfg)
     738         1080 :       && !gimple_seq_empty_p (*seq))
     739              :     {
     740          417 :       if (!parser.current_bb)
     741            0 :         c_parser_error (parser, "stmts without block");
     742              :       else
     743              :         {
     744          417 :           gimple_stmt_iterator gsi = gsi_start_bb (parser.current_bb);
     745          417 :           gsi_insert_seq_after_without_update (&gsi, *seq,
     746              :                                                GSI_CONTINUE_LINKING);
     747              :         }
     748          417 :       *seq = NULL;
     749              :     }
     750              : 
     751              :   return return_p;
     752              : }
     753              : 
     754              : /* Parse a gimple statement.
     755              : 
     756              :    gimple-statement:
     757              :      gimple-call-expression
     758              :      gimple-assign-statement
     759              :      gimple-phi-statement
     760              : 
     761              :    gimple-assign-statement:
     762              :      gimple-unary-expression = gimple-assign-rhs
     763              : 
     764              :    gimple-assign-rhs:
     765              :      gimple-cast-expression
     766              :      gimple-unary-expression
     767              :      gimple-binary-expression
     768              :      gimple-call-expression
     769              : 
     770              :    gimple-phi-statement:
     771              :      identifier = __PHI ( label : gimple_primary-expression, ... )
     772              : 
     773              :    gimple-call-expr:
     774              :      gimple-primary-expression ( argument-list )
     775              : 
     776              :    gimple-cast-expression:
     777              :      ( type-name ) gimple-primary-expression
     778              : 
     779              : */
     780              : 
     781              : static void
     782         5853 : c_parser_gimple_statement (gimple_parser &parser, gimple_seq *seq)
     783              : {
     784         5853 :   struct c_expr lhs, rhs;
     785         5853 :   gimple *assign = NULL;
     786         5853 :   location_t loc;
     787         5853 :   tree arg = NULL_TREE;
     788         5853 :   auto_vec<tree> vargs;
     789              : 
     790         5853 :   lhs = c_parser_gimple_unary_expression (parser);
     791         5853 :   loc = EXPR_LOCATION (lhs.value);
     792         5853 :   rhs.set_error ();
     793              : 
     794              :   /* The parser already reported the error in an invalid statement.  */
     795         5853 :   if (c_parser_next_token_is (parser, CPP_SEMICOLON)
     796         5853 :       && lhs.value == error_mark_node)
     797              :     return;
     798              : 
     799              :   /* GIMPLE call statement without LHS.  */
     800         5851 :   if (c_parser_next_token_is (parser, CPP_SEMICOLON)
     801         5851 :       && TREE_CODE (lhs.value) == CALL_EXPR)
     802              :     {
     803          117 :       gimple *call;
     804          117 :       call = gimple_build_call_from_tree (lhs.value, NULL);
     805          117 :       gimple_seq_add_stmt_without_update (seq, call);
     806          117 :       gimple_set_location (call, loc);
     807          117 :       return;
     808              :     }
     809              : 
     810              :   /* All following cases are statements with LHS.  */
     811         5734 :   if (! c_parser_require (parser, CPP_EQ, "expected %<=%>"))
     812              :     return;
     813              : 
     814              :   /* Eat and ignore {v} right after the =, the has_volatile_ops is
     815              :      redundant and re-computed by the operand scanner.  */
     816         5733 :   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)
     817            1 :       && !(c_parser_peek_token (parser)->flags & PREV_WHITE)
     818            1 :       && c_parser_peek_2nd_token (parser)->type == CPP_NAME
     819            1 :       && !(c_parser_peek_2nd_token (parser)->flags & PREV_WHITE)
     820            1 :       && strcmp ("v", IDENTIFIER_POINTER
     821              :                         (c_parser_peek_2nd_token (parser)->value)) == 0
     822            1 :       && c_parser_peek_nth_token (parser, 3)->type == CPP_CLOSE_BRACE
     823         5734 :       && !(c_parser_peek_nth_token (parser, 3)->flags & PREV_WHITE))
     824              :     {
     825            1 :       c_parser_consume_token (parser);
     826            1 :       c_parser_consume_token (parser);
     827            1 :       c_parser_consume_token (parser);
     828              :     }
     829              : 
     830              :   /* Cast expression.  */
     831         5733 :   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
     832         5733 :       && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
     833              :     {
     834          307 :       c_parser_consume_token (parser);
     835          307 :       struct c_type_name *type_name = c_parser_type_name (parser);
     836          307 :       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
     837          307 :       if (type_name == NULL)
     838              :         return;
     839              :       /* ???  The actual type used in the cast expression is ignored as
     840              :          in GIMPLE it is encoded by the type of the LHS.  */
     841          307 :       rhs = c_parser_gimple_postfix_expression (parser);
     842          307 :       if (lhs.value != error_mark_node
     843          307 :           && rhs.value != error_mark_node)
     844              :         {
     845          307 :           enum tree_code code = NOP_EXPR;
     846          614 :           if (FLOAT_TYPE_P (TREE_TYPE (lhs.value))
     847          308 :               && ! FLOAT_TYPE_P (TREE_TYPE (rhs.value)))
     848              :             code = FLOAT_EXPR;
     849          612 :           else if (! FLOAT_TYPE_P (TREE_TYPE (lhs.value))
     850          612 :                    && FLOAT_TYPE_P (TREE_TYPE (rhs.value)))
     851              :             code = FIX_TRUNC_EXPR;
     852          307 :           assign = gimple_build_assign (lhs.value, code, rhs.value);
     853          307 :           gimple_seq_add_stmt_without_update (seq, assign);
     854          307 :           gimple_set_location (assign, loc);
     855          307 :           return;
     856              :         }
     857              :     }
     858              : 
     859              :   /* Unary expression.  */
     860         5426 :   switch (c_parser_peek_token (parser)->type)
     861              :     {
     862         4603 :     case CPP_NAME:
     863         4603 :       {
     864         4603 :         tree id = c_parser_peek_token (parser)->value;
     865         4603 :         if (strcmp (IDENTIFIER_POINTER (id), "__ABS") == 0
     866         4600 :             || strcmp (IDENTIFIER_POINTER (id), "__ABSU") == 0
     867         4593 :             || strcmp (IDENTIFIER_POINTER (id), "__MIN") == 0
     868         4565 :             || strcmp (IDENTIFIER_POINTER (id), "__MAX") == 0
     869         4564 :             || strcmp (IDENTIFIER_POINTER (id), "__BIT_INSERT") == 0
     870         9159 :             || strcmp (IDENTIFIER_POINTER (id), "__VEC_PERM") == 0)
     871          744 :           goto build_unary_expr;
     872              :         break;
     873              :       }
     874          403 :     case CPP_KEYWORD:
     875          403 :       if (c_parser_peek_token (parser)->keyword != RID_REALPART
     876          403 :           && c_parser_peek_token (parser)->keyword != RID_IMAGPART)
     877              :         break;
     878              :       /* Fallthru.  */
     879          798 :     case CPP_AND:
     880          798 :     case CPP_PLUS:
     881          798 :     case CPP_MINUS:
     882          798 :     case CPP_COMPL:
     883          798 :     case CPP_NOT:
     884          798 :     case CPP_MULT: /* pointer deref */
     885          798 :     build_unary_expr:
     886          798 :       rhs = c_parser_gimple_unary_expression (parser);
     887          798 :       if (rhs.value != error_mark_node)
     888              :         {
     889          797 :           assign = gimple_build_assign (lhs.value, rhs.value);
     890          797 :           gimple_set_location (assign, loc);
     891          797 :           gimple_seq_add_stmt_without_update (seq, assign);
     892              :         }
     893              :       return;
     894              : 
     895         4628 :     default:;
     896              :     }
     897              : 
     898              :   /* GIMPLE PHI statement.  */
     899         4628 :   if (c_parser_next_token_is_keyword (parser, RID_PHI))
     900              :     {
     901          397 :       c_parser_consume_token (parser);
     902              : 
     903          397 :       if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
     904              :         return;
     905              : 
     906          397 :       if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
     907            0 :         c_parser_consume_token (parser);
     908              : 
     909         2271 :       while (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
     910              :         {
     911         1874 :           if (c_parser_next_token_is (parser, CPP_NAME)
     912         1874 :               && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
     913              :             {
     914          757 :               arg = c_parser_peek_token (parser)->value;
     915          757 :               c_parser_consume_token (parser);
     916          757 :               if (c_parser_next_token_is (parser, CPP_COLON))
     917          757 :                 c_parser_consume_token (parser);
     918          757 :               int src_index = -1;
     919          757 :               if (!c_parser_gimple_parse_bb_spec (arg, &src_index))
     920            0 :                 c_parser_error (parser, "invalid source block specification");
     921          757 :               vargs.safe_push (size_int (src_index));
     922              :             }
     923         1117 :           else if (c_parser_next_token_is (parser, CPP_COMMA))
     924          360 :             c_parser_consume_token (parser);
     925              :           else
     926              :             {
     927          757 :               arg = c_parser_gimple_unary_expression (parser).value;
     928          757 :               vargs.safe_push (arg);
     929              :             }
     930              :         }
     931              : 
     932          397 :       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
     933              :                                  "expected %<)%>");
     934              : 
     935              :       /* Build internal function for PHI.  */
     936          397 :       gcall *call_stmt = gimple_build_call_internal_vec (IFN_PHI, vargs);
     937          397 :       gimple_call_set_lhs (call_stmt, lhs.value);
     938          397 :       gimple_set_location (call_stmt, UNKNOWN_LOCATION);
     939          397 :       gimple_seq_add_stmt_without_update (seq, call_stmt);
     940          397 :       return;
     941              :     }
     942              : 
     943              :   /* GIMPLE call with lhs.  */
     944         4231 :   if (c_parser_next_token_is (parser, CPP_DOT)
     945         4231 :       || (c_parser_next_token_is (parser, CPP_NAME)
     946         3859 :           && c_parser_peek_2nd_token (parser)->type == CPP_OPEN_PAREN
     947          475 :           && lookup_name (c_parser_peek_token (parser)->value)))
     948              :     {
     949          170 :       rhs = c_parser_gimple_unary_expression (parser);
     950          170 :       if (rhs.value != error_mark_node)
     951              :         {
     952          162 :           gimple *call = gimple_build_call_from_tree (rhs.value, NULL);
     953          162 :           gimple_call_set_lhs (call, lhs.value);
     954          162 :           gimple_seq_add_stmt_without_update (seq, call);
     955          324 :           gimple_set_location (call, loc);
     956              :         }
     957              :       return;
     958              :     }
     959              : 
     960         4061 :   rhs = c_parser_gimple_binary_expression (parser, TREE_TYPE (lhs.value));
     961         4061 :   if (lhs.value != error_mark_node
     962         4055 :       && rhs.value != error_mark_node)
     963              :     {
     964              :       /* If we parsed an identifier and the next token  is a '?' then parse
     965              :          a conditional expression.  */
     966         4052 :       if (SSA_VAR_P (rhs.value) && c_parser_next_token_is (parser, CPP_QUERY))
     967              :         {
     968          250 :           struct c_expr trueval, falseval;
     969          250 :           c_parser_consume_token (parser);
     970          250 :           trueval = c_parser_gimple_postfix_expression (parser);
     971          250 :           falseval.set_error ();
     972          250 :           if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
     973          250 :             falseval = c_parser_gimple_postfix_expression (parser);
     974          250 :           if (trueval.value == error_mark_node
     975          250 :               || falseval.value == error_mark_node)
     976            0 :             return;
     977          250 :           rhs.value = build3_loc (loc,
     978          250 :                                   VECTOR_TYPE_P (TREE_TYPE (rhs.value))
     979              :                                   ? VEC_COND_EXPR : COND_EXPR,
     980          250 :                                   TREE_TYPE (trueval.value),
     981              :                                   rhs.value, trueval.value, falseval.value);
     982              :         }
     983         4052 :       if (get_gimple_rhs_class (TREE_CODE (rhs.value)) == GIMPLE_INVALID_RHS)
     984              :         {
     985            0 :           c_parser_error (parser, "unexpected RHS for assignment");
     986            0 :           return;
     987              :         }
     988         4052 :       assign = gimple_build_assign (lhs.value, rhs.value);
     989         4052 :       gimple_seq_add_stmt_without_update (seq, assign);
     990         4052 :       gimple_set_location (assign, loc);
     991              :     }
     992              :   return;
     993         5853 : }
     994              : 
     995              : /* A mapping between an identifier to a tree code for binary operations. */
     996              : static const std::pair<const char *, tree_code> gimple_binary_identifier_code[] =
     997              :   {
     998              :     {"__MULT_HIGHPART", MULT_HIGHPART_EXPR},
     999              :     {"__UNLT", UNLT_EXPR},
    1000              :     {"__UNLE", UNLE_EXPR},
    1001              :     {"__UNGT", UNGT_EXPR},
    1002              :     {"__UNGE", UNGE_EXPR},
    1003              :     {"__UNEQ", UNEQ_EXPR},
    1004              :     {"__UNORDERED", UNORDERED_EXPR},
    1005              :     {"__ORDERED", ORDERED_EXPR},
    1006              :     {"__LTGT", LTGT_EXPR},
    1007              :     {"__FLOOR_DIV", FLOOR_DIV_EXPR},
    1008              :     {"__ROUND_DIV", ROUND_DIV_EXPR},
    1009              :     {"__EXACT_DIV", EXACT_DIV_EXPR},
    1010              :     {"__CEIL_DIV", CEIL_DIV_EXPR},
    1011              :     {"__FLOOR_MOD", FLOOR_MOD_EXPR},
    1012              :     {"__ROUND_MOD", ROUND_MOD_EXPR},
    1013              :     {"__CEIL_MOD", CEIL_MOD_EXPR},
    1014              :     {"__ROTATE_LEFT", LROTATE_EXPR},
    1015              :     {"__ROTATE_RIGHT", RROTATE_EXPR},
    1016              :   };
    1017              : 
    1018              : /* Parse gimple binary expr.
    1019              : 
    1020              :    gimple-binary-expression:
    1021              :      gimple-unary-expression * gimple-unary-expression
    1022              :      gimple-unary-expression __MULT_HIGHPART gimple-unary-expression
    1023              :      gimple-unary-expression / gimple-unary-expression
    1024              :      gimple-unary-expression % gimple-unary-expression
    1025              :      gimple-unary-expression + gimple-unary-expression
    1026              :      gimple-unary-expression - gimple-unary-expression
    1027              :      gimple-unary-expression << gimple-unary-expression
    1028              :      gimple-unary-expression >> gimple-unary-expression
    1029              :      gimple-unary-expression < gimple-unary-expression
    1030              :      gimple-unary-expression > gimple-unary-expression
    1031              :      gimple-unary-expression <= gimple-unary-expression
    1032              :      gimple-unary-expression >= gimple-unary-expression
    1033              :      gimple-unary-expression == gimple-unary-expression
    1034              :      gimple-unary-expression != gimple-unary-expression
    1035              :      gimple-unary-expression & gimple-unary-expression
    1036              :      gimple-unary-expression ^ gimple-unary-expression
    1037              :      gimple-unary-expression | gimple-unary-expression
    1038              : 
    1039              : */
    1040              : 
    1041              : static c_expr
    1042         4464 : c_parser_gimple_binary_expression (gimple_parser &parser, tree ret_type)
    1043              : {
    1044              :   /* Location of the binary operator.  */
    1045         4464 :   struct c_expr ret, lhs, rhs;
    1046         4464 :   enum tree_code code = ERROR_MARK;
    1047         4464 :   ret.set_error ();
    1048         4464 :   lhs = c_parser_gimple_postfix_expression (parser, ret_type);
    1049         4464 :   if (c_parser_error (parser))
    1050            5 :     return ret;
    1051         4459 :   switch (c_parser_peek_token (parser)->type)
    1052              :     {
    1053              :     case CPP_MULT:
    1054              :       code = MULT_EXPR;
    1055              :       break;
    1056           13 :     case CPP_DIV:
    1057           13 :       code = TRUNC_DIV_EXPR;
    1058           13 :       break;
    1059           28 :     case CPP_MOD:
    1060           28 :       code = TRUNC_MOD_EXPR;
    1061           28 :       break;
    1062          449 :     case CPP_PLUS:
    1063          449 :       if (POINTER_TYPE_P (TREE_TYPE (lhs.value)))
    1064              :         code = POINTER_PLUS_EXPR;
    1065              :       else
    1066              :         code = PLUS_EXPR;
    1067              :       break;
    1068          116 :     case CPP_MINUS:
    1069          116 :       if (POINTER_TYPE_P (TREE_TYPE (lhs.value)))
    1070              :         code = POINTER_DIFF_EXPR;
    1071              :       else
    1072              :         code = MINUS_EXPR;
    1073              :       break;
    1074           19 :     case CPP_LSHIFT:
    1075           19 :       code = LSHIFT_EXPR;
    1076           19 :       break;
    1077           31 :     case CPP_RSHIFT:
    1078           31 :       code = RSHIFT_EXPR;
    1079           31 :       break;
    1080           49 :     case CPP_LESS:
    1081           49 :       code = LT_EXPR;
    1082           49 :       break;
    1083          246 :     case CPP_GREATER:
    1084          246 :       code = GT_EXPR;
    1085          246 :       break;
    1086           34 :     case CPP_LESS_EQ:
    1087           34 :       code = LE_EXPR;
    1088           34 :       break;
    1089           27 :     case CPP_GREATER_EQ:
    1090           27 :       code = GE_EXPR;
    1091           27 :       break;
    1092          130 :     case CPP_EQ_EQ:
    1093          130 :       code = EQ_EXPR;
    1094          130 :       break;
    1095          256 :     case CPP_NOT_EQ:
    1096          256 :       code = NE_EXPR;
    1097          256 :       break;
    1098          117 :     case CPP_AND:
    1099          117 :       code = BIT_AND_EXPR;
    1100          117 :       break;
    1101           14 :     case CPP_XOR:
    1102           14 :       code = BIT_XOR_EXPR;
    1103           14 :       break;
    1104           39 :     case CPP_OR:
    1105           39 :       code = BIT_IOR_EXPR;
    1106           39 :       break;
    1107            0 :     case CPP_AND_AND:
    1108            0 :       c_parser_error (parser, "%<&&%> not valid in GIMPLE");
    1109            0 :       return ret;
    1110            0 :     case CPP_OR_OR:
    1111            0 :       c_parser_error (parser, "%<||%> not valid in GIMPLE");
    1112            0 :       return ret;
    1113          117 :     case CPP_NAME:
    1114          117 :       {
    1115          117 :         tree id = c_parser_peek_token (parser)->value;
    1116         1386 :         for (auto &p : gimple_binary_identifier_code)
    1117              :           {
    1118         1386 :             if (strcmp (IDENTIFIER_POINTER (id), p.first) == 0)
    1119              :               {
    1120          117 :                 code = p.second;
    1121          117 :                 break;
    1122              :               }
    1123              :           }
    1124          117 :         if (code != ERROR_MARK)
    1125              :           break;
    1126              :       }
    1127              :       /* Fallthru.  */
    1128         2568 :     default:
    1129              :       /* Not a binary expression.  */
    1130         2568 :       return lhs;
    1131              :     }
    1132         1891 :   location_t ret_loc = c_parser_peek_token (parser)->location;
    1133         1891 :   c_parser_consume_token (parser);
    1134         1891 :   rhs = c_parser_gimple_postfix_expression (parser);
    1135         1891 :   if (lhs.value != error_mark_node && rhs.value != error_mark_node)
    1136         1890 :     ret.value = build2_loc (ret_loc, code, ret_type, lhs.value, rhs.value);
    1137         1891 :   return ret;
    1138              : }
    1139              : 
    1140              : /* Parse a gimple parentized binary expression.  */
    1141              : 
    1142              : static c_expr
    1143           29 : c_parser_gimple_parentized_binary_expression (gimple_parser &parser,
    1144              :                                               location_t op_loc,
    1145              :                                               tree_code code)
    1146              : {
    1147           29 :   struct c_expr ret;
    1148           29 :   ret.set_error ();
    1149              : 
    1150           29 :   c_parser_consume_token (parser);
    1151           29 :   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    1152              :     return ret;
    1153           29 :   c_expr op1 = c_parser_gimple_postfix_expression (parser);
    1154           29 :   if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
    1155              :     return ret;
    1156           29 :   c_expr op2 = c_parser_gimple_postfix_expression (parser);
    1157           29 :   if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
    1158              :     return ret;
    1159              : 
    1160           29 :   if (op1.value != error_mark_node && op2.value != error_mark_node)
    1161           29 :     ret.value = build2_loc (op_loc,
    1162           29 :                             code, TREE_TYPE (op1.value), op1.value, op2.value);
    1163              :   return ret;
    1164              : }
    1165              : 
    1166              : /* Parse a gimple parentized binary expression.  */
    1167              : 
    1168              : static c_expr
    1169          697 : c_parser_gimple_parentized_ternary_expression (gimple_parser &parser,
    1170              :                                                location_t op_loc,
    1171              :                                                tree_code code)
    1172              : {
    1173          697 :   struct c_expr ret;
    1174          697 :   ret.set_error ();
    1175              : 
    1176          697 :   c_parser_consume_token (parser);
    1177          697 :   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    1178              :     return ret;
    1179          697 :   c_expr op1 = c_parser_gimple_postfix_expression (parser);
    1180          697 :   if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
    1181              :     return ret;
    1182          697 :   c_expr op2 = c_parser_gimple_postfix_expression (parser);
    1183          697 :   if (!c_parser_require (parser, CPP_COMMA, "expected %<)%>"))
    1184              :     return ret;
    1185          697 :   c_expr op3 = c_parser_gimple_postfix_expression (parser);
    1186          697 :   if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
    1187              :     return ret;
    1188              : 
    1189          697 :   if (op1.value != error_mark_node
    1190          697 :       && op2.value != error_mark_node
    1191          697 :       && op3.value != error_mark_node)
    1192          697 :     ret.value = build3_loc (op_loc,
    1193          697 :                             code, TREE_TYPE (op1.value),
    1194              :                             op1.value, op2.value, op3.value);
    1195              :   return ret;
    1196              : }
    1197              : 
    1198              : /* Parse gimple unary expression.
    1199              : 
    1200              :    gimple-unary-expression:
    1201              :      gimple-postfix-expression
    1202              :      unary-operator gimple-postfix-expression
    1203              : 
    1204              :    unary-operator: one of
    1205              :      & * + - ~ abs_expr
    1206              : */
    1207              : 
    1208              : static c_expr
    1209         9144 : c_parser_gimple_unary_expression (gimple_parser &parser)
    1210              : {
    1211         9144 :   struct c_expr ret, op;
    1212         9144 :   location_t op_loc = c_parser_peek_token (parser)->location;
    1213         9144 :   location_t finish;
    1214         9144 :   ret.set_error ();
    1215         9144 :   switch (c_parser_peek_token (parser)->type)
    1216              :     {
    1217           67 :     case CPP_AND:
    1218           67 :       c_parser_consume_token (parser);
    1219           67 :       op = c_parser_gimple_postfix_expression (parser);
    1220           67 :       mark_exp_read (op.value);
    1221           67 :       return gimple_parser_build_unary_op (op_loc, ADDR_EXPR, op);
    1222           30 :     case CPP_MULT:
    1223           30 :       {
    1224           30 :         c_parser_consume_token (parser);
    1225           30 :         op = c_parser_gimple_postfix_expression (parser);
    1226           30 :         if (op.value == error_mark_node)
    1227            1 :           return ret;
    1228           29 :         if (! POINTER_TYPE_P (TREE_TYPE (op.value)))
    1229              :           {
    1230            1 :             error_at (op_loc, "expected pointer as argument of unary %<*%>");
    1231            1 :             return ret;
    1232              :           }
    1233           28 :         finish = op.get_finish ();
    1234           28 :         location_t combined_loc = make_location (op_loc, op_loc, finish);
    1235           28 :         ret.value = build_simple_mem_ref_loc (combined_loc, op.value);
    1236           56 :         TREE_SIDE_EFFECTS (ret.value)
    1237           28 :           = TREE_THIS_VOLATILE (ret.value)
    1238           28 :           = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op.value)));
    1239           28 :         ret.src_range.m_start = op_loc;
    1240           28 :         ret.src_range.m_finish = finish;
    1241           28 :         return ret;
    1242              :       }
    1243            0 :     case CPP_PLUS:
    1244            0 :       c_parser_consume_token (parser);
    1245            0 :       op = c_parser_gimple_postfix_expression (parser);
    1246            0 :       return gimple_parser_build_unary_op (op_loc, CONVERT_EXPR, op);
    1247           51 :     case CPP_MINUS:
    1248           51 :       c_parser_consume_token (parser);
    1249           51 :       op = c_parser_gimple_postfix_expression (parser);
    1250           51 :       return gimple_parser_build_unary_op (op_loc, NEGATE_EXPR, op);
    1251            3 :     case CPP_COMPL:
    1252            3 :       c_parser_consume_token (parser);
    1253            3 :       op = c_parser_gimple_postfix_expression (parser);
    1254            3 :       return gimple_parser_build_unary_op (op_loc, BIT_NOT_EXPR, op);
    1255            0 :     case CPP_NOT:
    1256            0 :       c_parser_error (parser, "%<!%> not valid in GIMPLE");
    1257            0 :       return ret;
    1258            6 :     case CPP_KEYWORD:
    1259            6 :       switch (c_parser_peek_token (parser)->keyword)
    1260              :         {
    1261            4 :         case RID_REALPART:
    1262            4 :           c_parser_consume_token (parser);
    1263            4 :           op = c_parser_gimple_postfix_expression (parser);
    1264            4 :           return gimple_parser_build_unary_op (op_loc, REALPART_EXPR, op);
    1265            2 :         case RID_IMAGPART:
    1266            2 :           c_parser_consume_token (parser);
    1267            2 :           op = c_parser_gimple_postfix_expression (parser);
    1268            2 :           return gimple_parser_build_unary_op (op_loc, IMAGPART_EXPR, op);
    1269            0 :         default:
    1270            0 :           return c_parser_gimple_postfix_expression (parser);
    1271              :         }
    1272         8127 :     case CPP_NAME:
    1273         8127 :         {
    1274         8127 :           tree id = c_parser_peek_token (parser)->value;
    1275         8127 :           if (strcmp (IDENTIFIER_POINTER (id), "__ABS") == 0)
    1276              :             {
    1277            3 :               c_parser_consume_token (parser);
    1278            3 :               op = c_parser_gimple_postfix_expression (parser);
    1279            3 :               return gimple_parser_build_unary_op (op_loc, ABS_EXPR, op);
    1280              :             }
    1281         8124 :           else if (strcmp (IDENTIFIER_POINTER (id), "__ABSU") == 0)
    1282              :             {
    1283            7 :               c_parser_consume_token (parser);
    1284            7 :               op = c_parser_gimple_postfix_expression (parser);
    1285            7 :               return gimple_parser_build_unary_op (op_loc, ABSU_EXPR, op);
    1286              :             }
    1287         8117 :           else if (strcmp (IDENTIFIER_POINTER (id), "__MIN") == 0)
    1288           28 :             return c_parser_gimple_parentized_binary_expression (parser,
    1289              :                                                                  op_loc,
    1290           28 :                                                                  MIN_EXPR);
    1291         8089 :           else if (strcmp (IDENTIFIER_POINTER (id), "__MAX") == 0)
    1292            1 :             return c_parser_gimple_parentized_binary_expression (parser,
    1293              :                                                                  op_loc,
    1294            1 :                                                                  MAX_EXPR);
    1295         8088 :           else if (strcmp (IDENTIFIER_POINTER (id), "__VEC_PERM") == 0)
    1296          697 :             return c_parser_gimple_parentized_ternary_expression
    1297          697 :                         (parser, op_loc, VEC_PERM_EXPR);
    1298         7391 :           else if (strcmp (IDENTIFIER_POINTER (id), "__BIT_INSERT") == 0)
    1299              :             {
    1300              :               /* __BIT_INSERT '(' postfix-expression, postfix-expression,
    1301              :                                   integer ')'  */
    1302            8 :               location_t loc = c_parser_peek_token (parser)->location;
    1303            8 :               c_parser_consume_token (parser);
    1304            8 :               if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    1305              :                 {
    1306            8 :                   c_expr op0 = c_parser_gimple_postfix_expression (parser);
    1307            8 :                   c_parser_skip_until_found (parser, CPP_COMMA,
    1308              :                                              "expected %<,%>");
    1309            8 :                   c_expr op1 = c_parser_gimple_postfix_expression (parser);
    1310            8 :                   c_parser_skip_until_found (parser, CPP_COMMA,
    1311              :                                              "expected %<,%>");
    1312            8 :                   c_expr op2 = c_parser_gimple_postfix_expression (parser);
    1313            8 :                   if (TREE_CODE (op2.value) != INTEGER_CST
    1314            8 :                       || !int_fits_type_p (op2.value, bitsizetype))
    1315            0 :                     c_parser_error (parser, "expected constant offset");
    1316            8 :                   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    1317              :                                              "expected %<)%>");
    1318            8 :                   if (op0.value != error_mark_node
    1319            8 :                       && op1.value != error_mark_node
    1320            8 :                       && TREE_CODE (op2.value) == INTEGER_CST)
    1321           16 :                     ret.value = build3_loc (loc, BIT_INSERT_EXPR,
    1322            8 :                                             TREE_TYPE (op0.value),
    1323              :                                             op0.value, op1.value,
    1324              :                                             fold_convert (bitsizetype,
    1325              :                                                           op2.value));
    1326              :                 }
    1327            8 :               return ret;
    1328              :             }
    1329              :           else
    1330         7383 :             return c_parser_gimple_postfix_expression (parser);
    1331              :         }
    1332          860 :     default:
    1333          860 :       return c_parser_gimple_postfix_expression (parser);
    1334              :     }
    1335              : }
    1336              : 
    1337              : /* Decompose ID into base name (ID until ver_offset) and VERSION.  Return
    1338              :    true if ID matches a SSA name.  */
    1339              : 
    1340              : static bool
    1341        11212 : c_parser_parse_ssa_name_id (tree id, unsigned *version, unsigned *ver_offset)
    1342              : {
    1343        11212 :   const char *token = IDENTIFIER_POINTER (id);
    1344        11212 :   const char *var_version = strrchr (token, '_');
    1345        11212 :   if (! var_version)
    1346              :     return false;
    1347              : 
    1348        10251 :   *ver_offset = var_version - token;
    1349        23019 :   for (const char *p = var_version + 1; *p; ++p)
    1350        12788 :     if (! ISDIGIT (*p))
    1351              :       return false;
    1352        10231 :   *version = atoi (var_version + 1);
    1353        10231 :   return *version > 0;
    1354              : }
    1355              : 
    1356              : /* Get at the actual SSA name ID with VERSION starting at VER_OFFSET.
    1357              :    TYPE is the type if the SSA name is being declared.  */
    1358              : 
    1359              : static tree
    1360         8656 : c_parser_parse_ssa_name (gimple_parser &parser,
    1361              :                          tree id, tree type, unsigned version,
    1362              :                          unsigned ver_offset)
    1363              : {
    1364         8656 :   tree name = NULL_TREE;
    1365         8656 :   const char *token = IDENTIFIER_POINTER (id);
    1366              : 
    1367         8656 :   if (ver_offset == 0)
    1368              :     {
    1369              :       /* Anonymous unnamed SSA name.  */
    1370         5785 :       if (version < num_ssa_names)
    1371         4062 :         name = ssa_name (version);
    1372         4062 :       if (! name)
    1373              :         {
    1374         1825 :           if (! type)
    1375              :             {
    1376            0 :               c_parser_error (parser, "SSA name undeclared");
    1377            0 :               return error_mark_node;
    1378              :             }
    1379         1825 :           name = make_ssa_name_fn (cfun, type, NULL, version);
    1380              :         }
    1381              :     }
    1382              :   else
    1383              :     {
    1384         2871 :       if (version < num_ssa_names)
    1385         2281 :         name = ssa_name (version);
    1386         2281 :       if (! name)
    1387              :         {
    1388              :           /* Separate var name from version.  */
    1389         1420 :           char *var_name = XNEWVEC (char, ver_offset + 1);
    1390         1420 :           memcpy (var_name, token, ver_offset);
    1391         1420 :           var_name[ver_offset] = '\0';
    1392              :           /* lookup for parent decl.  */
    1393         1420 :           id = get_identifier (var_name);
    1394         1420 :           tree parent = lookup_name (id);
    1395         1420 :           XDELETEVEC (var_name);
    1396         1420 :           if (! parent || parent == error_mark_node)
    1397              :             {
    1398            1 :               c_parser_error (parser, "base variable or SSA name undeclared");
    1399            1 :               return error_mark_node;
    1400              :             }
    1401         1419 :           if (!(VAR_P (parent)
    1402              :                 || TREE_CODE (parent) == PARM_DECL
    1403              :                 || TREE_CODE (parent) == RESULT_DECL))
    1404              :             {
    1405            1 :               error ("invalid base %qE for SSA name", parent);
    1406            1 :               return error_mark_node;
    1407              :             }
    1408         1418 :           name = make_ssa_name_fn (cfun, parent,
    1409              :                                    gimple_build_nop (), version);
    1410              :         }
    1411              :     }
    1412              : 
    1413              :   return name;
    1414              : }
    1415              : 
    1416              : /* Parse a gimple call to an internal function.
    1417              : 
    1418              :    gimple-call-internal:
    1419              :      . identifier ( gimple-argument-expression-list[opt] )  */
    1420              : 
    1421              : static struct c_expr
    1422          152 : c_parser_gimple_call_internal (gimple_parser &parser)
    1423              : {
    1424          152 :   struct c_expr expr;
    1425          152 :   expr.set_error ();
    1426              : 
    1427          152 :   gcc_assert (c_parser_next_token_is (parser, CPP_DOT));
    1428          152 :   c_parser_consume_token (parser);
    1429          152 :   location_t loc = c_parser_peek_token (parser)->location;
    1430          152 :   if (!c_parser_next_token_is (parser, CPP_NAME)
    1431          152 :       || c_parser_peek_token (parser)->id_kind != C_ID_ID)
    1432              :     {
    1433            0 :       c_parser_error (parser, "expecting internal function name");
    1434            0 :       return expr;
    1435              :     }
    1436          152 :   tree id = c_parser_peek_token (parser)->value;
    1437          152 :   internal_fn ifn = lookup_internal_fn (IDENTIFIER_POINTER (id));
    1438          152 :   c_parser_consume_token (parser);
    1439          152 :   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    1440              :     {
    1441          152 :       auto_vec<tree> exprlist;
    1442          152 :       if (!c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    1443          151 :         c_parser_gimple_expr_list (parser, &exprlist);
    1444          152 :       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
    1445          152 :       if (ifn == IFN_LAST)
    1446            0 :         error_at (loc, "unknown internal function %qE", id);
    1447          152 :       else if (!exprlist.contains (error_mark_node)
    1448          302 :                && check_internal_fn_args (loc, ifn, exprlist.length (),
    1449          150 :                                           exprlist.address ()))
    1450              :         {
    1451          284 :           expr.value = build_call_expr_internal_loc_array
    1452          142 :             (loc, ifn, void_type_node, exprlist.length (),
    1453          142 :              exprlist.address ());
    1454          142 :           expr.original_code = ERROR_MARK;
    1455          142 :           expr.original_type = NULL;
    1456          142 :           expr.m_decimal = 0;
    1457              :         }
    1458          152 :     }
    1459              :   return expr;
    1460              : }
    1461              : 
    1462              : /* Parse '<' type [',' alignment] '>' and return a type on success
    1463              :    and NULL_TREE on error.  */
    1464              : 
    1465              : static tree
    1466          448 : c_parser_gimple_typespec (gimple_parser &parser)
    1467              : {
    1468          448 :   struct c_type_name *type_name = NULL;
    1469          448 :   tree alignment = NULL_TREE;
    1470          448 :   if (c_parser_require (parser, CPP_LESS, "expected %<<%>"))
    1471              :     {
    1472          447 :       type_name = c_parser_type_name (parser);
    1473              :       /* Optional alignment.  */
    1474          447 :       if (c_parser_next_token_is (parser, CPP_COMMA))
    1475              :         {
    1476           14 :           c_parser_consume_token (parser);
    1477           14 :           alignment
    1478           14 :               = c_parser_gimple_postfix_expression (parser).value;
    1479              :         }
    1480          447 :       c_parser_skip_until_found (parser,
    1481              :                                  CPP_GREATER, "expected %<>%>");
    1482              :     }
    1483          447 :   if (!type_name)
    1484              :     return NULL_TREE;
    1485          447 :   tree tem;
    1486          447 :   tree type = groktypename (type_name, &tem, NULL);
    1487          447 :   if (alignment)
    1488           14 :     type = build_aligned_type (type, tree_to_uhwi (alignment));
    1489              :   return type;
    1490              : }
    1491              : 
    1492              : /* Parse gimple postfix expression.
    1493              : 
    1494              :    gimple-postfix-expression:
    1495              :      gimple-primary-expression
    1496              :      gimple-primary-expression [ gimple-primary-expression ]
    1497              :      gimple-primary-expression ( gimple-argument-expression-list[opt] )
    1498              :      gimple-postfix-expression . identifier
    1499              :      gimple-postfix-expression -> identifier
    1500              : 
    1501              :    gimple-argument-expression-list:
    1502              :      gimple-unary-expression
    1503              :      gimple-argument-expression-list , gimple-unary-expression
    1504              : 
    1505              :    gimple-primary-expression:
    1506              :      identifier
    1507              :      constant
    1508              :      string-literal
    1509              :      constructor
    1510              :      gimple-call-internal
    1511              : 
    1512              : */
    1513              : 
    1514              : static struct c_expr
    1515        23868 : c_parser_gimple_postfix_expression (gimple_parser &parser, tree ret_type)
    1516              : {
    1517        23868 :   location_t loc = c_parser_peek_token (parser)->location;
    1518        23868 :   source_range tok_range = c_parser_peek_token (parser)->get_range ();
    1519        23868 :   struct c_expr expr;
    1520        23868 :   expr.set_error ();
    1521        23868 :   switch (c_parser_peek_token (parser)->type)
    1522              :     {
    1523         8182 :     case CPP_NUMBER:
    1524         8182 :       expr.value = c_parser_peek_token (parser)->value;
    1525         8182 :       set_c_expr_source_range (&expr, tok_range);
    1526         8182 :       loc = c_parser_peek_token (parser)->location;
    1527         8182 :       c_parser_consume_token (parser);
    1528         8182 :       break;
    1529            0 :     case CPP_CHAR:
    1530            0 :     case CPP_CHAR16:
    1531            0 :     case CPP_CHAR32:
    1532            0 :     case CPP_UTF8CHAR:
    1533            0 :     case CPP_WCHAR:
    1534            0 :       expr.value = c_parser_peek_token (parser)->value;
    1535            0 :       set_c_expr_source_range (&expr, tok_range);
    1536            0 :       c_parser_consume_token (parser);
    1537            0 :       break;
    1538            6 :     case CPP_STRING:
    1539            6 :     case CPP_STRING16:
    1540            6 :     case CPP_STRING32:
    1541            6 :     case CPP_WSTRING:
    1542            6 :     case CPP_UTF8STRING:
    1543            6 :       expr = c_parser_string_literal (parser, false, true);
    1544            6 :       break;
    1545          152 :     case CPP_DOT:
    1546          152 :       expr = c_parser_gimple_call_internal (parser);
    1547          152 :       break;
    1548        15525 :     case CPP_NAME:
    1549        15525 :       if (c_parser_peek_token (parser)->id_kind == C_ID_ID)
    1550              :         {
    1551        15525 :           tree id = c_parser_peek_token (parser)->value;
    1552        15525 :           if (strcmp (IDENTIFIER_POINTER (id), "__MEM") == 0)
    1553              :             {
    1554              :               /* __MEM '<' type-name [ ',' number ] '>'
    1555              :                        '(' [ '(' type-name ')' ] unary-expression
    1556              :                            [ '+' number ]
    1557              :                            [ ',' number ]
    1558              :                            [ ',' number ':' number ] ')'  */
    1559          359 :               location_t loc = c_parser_peek_token (parser)->location;
    1560          359 :               c_parser_consume_token (parser);
    1561          359 :               tree type = c_parser_gimple_typespec (parser);
    1562          359 :               struct c_expr ptr, alias_off, step, index, index2;
    1563          359 :               ptr.value = error_mark_node;
    1564          359 :               alias_off.value = NULL_TREE;
    1565          359 :               step.value = NULL_TREE;
    1566          359 :               index.value = NULL_TREE;
    1567          359 :               index2.value = NULL_TREE;
    1568          359 :               unsigned short clique = 0;
    1569          359 :               unsigned short base = 0;
    1570          359 :               bool reverse_order = false;
    1571          359 :               struct c_expr ro;
    1572          359 :               if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    1573              :                 {
    1574          359 :                   tree alias_type = NULL_TREE;
    1575              :                   /* Optional alias-type cast.  */
    1576          359 :                   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
    1577              :                     {
    1578           59 :                       c_parser_consume_token (parser);
    1579           59 :                       struct c_type_name *alias_type_name
    1580           59 :                         = c_parser_type_name (parser);
    1581           59 :                       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    1582              :                                                  "expected %<)%>");
    1583           59 :                       if (alias_type_name)
    1584              :                         {
    1585           59 :                           tree tem;
    1586           59 :                           alias_type = groktypename (alias_type_name,
    1587              :                                                      &tem, NULL);
    1588              :                         }
    1589              :                     }
    1590          359 :                   ptr = c_parser_gimple_unary_expression (parser);
    1591          359 :                   if (ptr.value == error_mark_node
    1592          359 :                       || ! POINTER_TYPE_P (TREE_TYPE (ptr.value)))
    1593              :                     {
    1594            1 :                       if (ptr.value != error_mark_node)
    1595            0 :                         error_at (ptr.get_start (),
    1596              :                                   "invalid type of %<__MEM%> operand");
    1597            1 :                       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    1598              :                                                  "expected %<)%>");
    1599            1 :                       return expr;
    1600              :                     }
    1601          358 :                   if (! alias_type)
    1602          299 :                     alias_type = TREE_TYPE (ptr.value);
    1603              :                   /* Optional constant offset.  */
    1604          358 :                   if (c_parser_next_token_is (parser, CPP_PLUS))
    1605              :                     {
    1606           82 :                       c_parser_consume_token (parser);
    1607           82 :                       alias_off = c_parser_gimple_postfix_expression (parser);
    1608              :                     }
    1609          358 :                   if (c_parser_next_token_is (parser, CPP_MULT))
    1610              :                     {
    1611            1 :                       std::swap (index, alias_off);
    1612            1 :                       c_parser_consume_token (parser);
    1613            1 :                       step = c_parser_gimple_postfix_expression (parser);
    1614              :                     }
    1615          357 :                   else if (c_parser_next_token_is (parser, CPP_PLUS))
    1616              :                     {
    1617            3 :                       c_parser_consume_token (parser);
    1618            3 :                       index = c_parser_gimple_postfix_expression (parser);
    1619            3 :                       if (c_parser_next_token_is (parser, CPP_MULT))
    1620              :                         {
    1621            2 :                           c_parser_consume_token (parser);
    1622            2 :                           step = c_parser_gimple_postfix_expression (parser);
    1623              :                         }
    1624              :                       else
    1625            1 :                         std::swap (index, index2);
    1626              :                     }
    1627          354 :                   else if (alias_off.value
    1628           78 :                            && TREE_CODE (alias_off.value) != INTEGER_CST)
    1629            1 :                     std::swap (alias_off, index2);
    1630          358 :                   if (c_parser_next_token_is (parser, CPP_PLUS))
    1631              :                     {
    1632            1 :                       c_parser_consume_token (parser);
    1633            1 :                       index2 = c_parser_gimple_postfix_expression (parser);
    1634              :                     }
    1635          358 :                   if (alias_off.value)
    1636              :                     {
    1637           80 :                       if (TREE_CODE (alias_off.value) != INTEGER_CST)
    1638            0 :                         error_at (alias_off.get_start (),
    1639              :                                   "expected constant offset for %<__MEM%> "
    1640              :                                   "operand");
    1641           80 :                       alias_off.value = fold_convert (alias_type,
    1642              :                                                       alias_off.value);
    1643              :                     }
    1644              :                   else
    1645          278 :                     alias_off.value = build_int_cst (alias_type, 0);
    1646          358 :                   if (step.value)
    1647              :                     {
    1648            3 :                       if (TREE_CODE (step.value) != INTEGER_CST)
    1649            0 :                         error_at (step.get_start (),
    1650              :                                   "expected constant step for %<__MEM%> "
    1651              :                                   "operand");
    1652              :                     }
    1653          358 :                   if (c_parser_next_token_is (parser, CPP_COMMA))
    1654              :                     {
    1655            4 :                       struct c_expr cl, ba;
    1656            4 :                       bool has_clb = true;
    1657            4 :                       c_parser_consume_token (parser);
    1658            4 :                       cl = c_parser_gimple_postfix_expression (parser);
    1659            4 :                       if (!c_parser_next_token_is (parser, CPP_COLON))
    1660              :                         {
    1661            1 :                           ro = cl;
    1662            1 :                           unsigned HOST_WIDE_INT tmp = 0;
    1663            1 :                           if (!tree_fits_uhwi_p (ro.value)
    1664            1 :                               || (tmp = tree_to_uhwi (ro.value)) > 1)
    1665            0 :                             error_at (ro.get_start (),
    1666              :                                       "invalid reverse order value");
    1667            1 :                           reverse_order = tmp;
    1668            1 :                           has_clb = false;
    1669            1 :                           if (c_parser_next_token_is (parser, CPP_COMMA))
    1670              :                             {
    1671            0 :                               c_parser_consume_token (parser);
    1672            0 :                               cl = c_parser_gimple_postfix_expression (parser);
    1673            0 :                               has_clb = true;
    1674              :                             }
    1675              :                         }
    1676            0 :                       if (has_clb
    1677            3 :                           && c_parser_require (parser,
    1678              :                                                CPP_COLON, "expected %<:%>"))
    1679              :                         {
    1680            3 :                           ba = c_parser_gimple_postfix_expression (parser);
    1681            3 :                           if (!tree_fits_uhwi_p (cl.value)
    1682            3 :                               || !tree_fits_uhwi_p (ba.value)
    1683            3 :                               || compare_tree_int (cl.value,
    1684            3 :                                                    (clique = tree_to_uhwi
    1685            3 :                                                                 (cl.value)))
    1686            6 :                               || compare_tree_int (ba.value,
    1687            3 :                                                    (base = tree_to_uhwi
    1688            3 :                                                                  (ba.value))))
    1689            0 :                             error_at (cl.get_start (),
    1690              :                                       "invalid clique/base pair");
    1691              :                         }
    1692              :                     }
    1693          358 :                   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    1694              :                                              "expected %<)%>");
    1695              :                 }
    1696          358 :               if (! type || c_parser_error (parser))
    1697              :                 {
    1698            0 :                   c_parser_set_error (parser, false);
    1699            0 :                   return expr;
    1700              :                 }
    1701          358 :               if (index.value || step.value || index2.value)
    1702            5 :                 expr.value = build5_loc (loc, TARGET_MEM_REF,
    1703              :                                          type, ptr.value, alias_off.value,
    1704              :                                          index.value, step.value, index2.value);
    1705              :               else
    1706          353 :                 expr.value = build2_loc (loc, MEM_REF,
    1707              :                                          type, ptr.value, alias_off.value);
    1708          358 :               if (clique != 0)
    1709              :                 {
    1710            3 :                   cfun->last_clique = MAX (cfun->last_clique, clique);
    1711            3 :                   MR_DEPENDENCE_CLIQUE (expr.value) = clique;
    1712            3 :                   MR_DEPENDENCE_BASE (expr.value) = base;
    1713              :                 }
    1714          358 :               if (reverse_order)
    1715              :                 {
    1716            1 :                   if (TREE_CODE (expr.value) == MEM_REF)
    1717            1 :                     REF_REVERSE_STORAGE_ORDER (expr.value) = reverse_order;
    1718              :                   else
    1719            0 :                     error_at (ro.get_start (),
    1720              :                               "target mem ref cannot have reverse order");
    1721              :                 }
    1722          358 :               break;
    1723              :             }
    1724        15166 :           else if (strcmp (IDENTIFIER_POINTER (id), "__VIEW_CONVERT") == 0)
    1725              :             {
    1726              :               /* __VIEW_CONVERT '<' type-name [ ',' number ] '>'
    1727              :                                 '(' postfix-expression ')'  */
    1728           18 :               location_t loc = c_parser_peek_token (parser)->location;
    1729           18 :               c_parser_consume_token (parser);
    1730           18 :               tree type = c_parser_gimple_typespec (parser);
    1731           18 :               if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    1732              :                 {
    1733           18 :                   c_expr op = c_parser_gimple_postfix_expression (parser);
    1734           18 :                   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    1735              :                                              "expected %<)%>");
    1736           18 :                   if (type && op.value != error_mark_node)
    1737           18 :                     expr.value = build1_loc (loc, VIEW_CONVERT_EXPR,
    1738              :                                              type, op.value);
    1739              :                 }
    1740              :               break;
    1741              :             }
    1742        15148 :           else if (strcmp (IDENTIFIER_POINTER (id), "__BIT_FIELD_REF") == 0)
    1743              :             {
    1744              :               /* __BIT_FIELD_REF '<' type-name [ ',' number ] '>'
    1745              :                                 '(' postfix-expression, integer, integer ')'  */
    1746           71 :               location_t loc = c_parser_peek_token (parser)->location;
    1747           71 :               c_parser_consume_token (parser);
    1748           71 :               tree type = c_parser_gimple_typespec (parser);
    1749           71 :               if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    1750              :                 {
    1751           71 :                   c_expr op0 = c_parser_gimple_postfix_expression (parser);
    1752           71 :                   c_parser_skip_until_found (parser, CPP_COMMA,
    1753              :                                              "expected %<,%>");
    1754           71 :                   c_expr op1 = c_parser_gimple_postfix_expression (parser);
    1755           71 :                   if (TREE_CODE (op1.value) != INTEGER_CST
    1756           71 :                       || !int_fits_type_p (op1.value, bitsizetype))
    1757            0 :                     c_parser_error (parser, "expected constant size");
    1758           71 :                   c_parser_skip_until_found (parser, CPP_COMMA,
    1759              :                                              "expected %<,%>");
    1760           71 :                   c_expr op2 = c_parser_gimple_postfix_expression (parser);
    1761           71 :                   if (TREE_CODE (op2.value) != INTEGER_CST
    1762           71 :                       || !int_fits_type_p (op2.value, bitsizetype))
    1763            0 :                     c_parser_error (parser, "expected constant offset");
    1764           71 :                   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    1765              :                                              "expected %<)%>");
    1766           71 :                   if (type
    1767           71 :                       && op0.value != error_mark_node
    1768           71 :                       && TREE_CODE (op1.value) == INTEGER_CST
    1769           71 :                       && TREE_CODE (op2.value) == INTEGER_CST)
    1770           71 :                     expr.value = build3_loc (loc, BIT_FIELD_REF, type,
    1771              :                                              op0.value,
    1772              :                                              fold_convert (bitsizetype,
    1773              :                                                            op1.value),
    1774              :                                              fold_convert (bitsizetype,
    1775              :                                                            op2.value));
    1776              :                 }
    1777              :               break;
    1778              :             }
    1779        15077 :           else if (strcmp (IDENTIFIER_POINTER (id), "__CLOBBER") == 0)
    1780              :             {
    1781              :               /* __CLOBBER [ '(' bob | eob | bos | eos ')' ]  */
    1782           19 :               clobber_kind kind = CLOBBER_UNDEF;
    1783           19 :               c_parser_consume_token (parser);
    1784           19 :               if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
    1785              :                 {
    1786           18 :                   c_parser_consume_token (parser);
    1787           18 :                   auto tok = c_parser_peek_token (parser);
    1788           18 :                   if (c_parser_require (parser, CPP_NAME,
    1789              :                                         "expected clobber kind"))
    1790              :                     {
    1791           18 :                       const char *kind_str = IDENTIFIER_POINTER (tok->value);
    1792           18 :                       if (strcmp (kind_str, "bos") == 0)
    1793              :                         kind = CLOBBER_STORAGE_BEGIN;
    1794           17 :                       else if (strcmp (kind_str, "bob") == 0)
    1795              :                         kind = CLOBBER_OBJECT_BEGIN;
    1796           16 :                       else if (strcmp (kind_str, "eob") == 0)
    1797              :                         kind = CLOBBER_OBJECT_END;
    1798           15 :                       else if (strcmp (kind_str, "eos") == 0)
    1799              :                         kind = CLOBBER_STORAGE_END;
    1800              :                       else
    1801            0 :                         c_parser_error (parser, "expected one of %<bos%>, "
    1802              :                                         "%<eos%>, %<bob>, %<eob%>");
    1803              :                     }
    1804           18 :                   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    1805              :                                              "expected %<)%>");
    1806              :                 }
    1807              :               /* We infer the (redundant) type from the LHS.  */
    1808           19 :               expr.value = build_clobber (ret_type, kind);
    1809           19 :               break;
    1810              :             }
    1811        15058 :           else if (strcmp (IDENTIFIER_POINTER (id), "_Literal") == 0)
    1812              :             {
    1813              :               /* _Literal '(' type-name ')' ( [ '-' ] constant | constructor ) */
    1814         1261 :               c_parser_consume_token (parser);
    1815         1261 :               tree type = NULL_TREE;
    1816         1261 :               if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    1817              :                 {
    1818         1261 :                   struct c_type_name *type_name = c_parser_type_name (parser);
    1819         1261 :                   tree tem;
    1820         1261 :                   if (type_name)
    1821         1261 :                     type = groktypename (type_name, &tem, NULL);
    1822         1261 :                   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    1823              :                                              "expected %<)%>");
    1824              :                 }
    1825         1261 :               if (! type)
    1826              :                 {
    1827            0 :                   c_parser_error (parser, "invalid _Literal");
    1828            0 :                   return expr;
    1829              :                 }
    1830         1261 :               if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
    1831              :                 {
    1832          807 :                   c_parser_consume_token (parser);
    1833          807 :                   if (!AGGREGATE_TYPE_P (type)
    1834          807 :                       && !VECTOR_TYPE_P (type))
    1835              :                     {
    1836            0 :                       c_parser_error (parser, "invalid type for _Literal with "
    1837              :                                       "constructor");
    1838            0 :                       c_parser_skip_until_found (parser, CPP_CLOSE_BRACE,
    1839              :                                                  "expected %<}%>");
    1840            0 :                       return expr;
    1841              :                     }
    1842          807 :                   vec<constructor_elt, va_gc> *v = NULL;
    1843          807 :                   bool constant_p = true;
    1844          807 :                   if (VECTOR_TYPE_P (type)
    1845          807 :                       && !c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
    1846              :                     {
    1847          784 :                       vec_alloc (v, constant_lower_bound (
    1848          784 :                                       TYPE_VECTOR_SUBPARTS (type)));
    1849         9840 :                       do
    1850              :                         {
    1851         5312 :                           tree val
    1852         5312 :                             = c_parser_gimple_postfix_expression (parser).value;
    1853         5312 :                           if (! val
    1854         5312 :                               || val == error_mark_node
    1855         5312 :                               || (! CONSTANT_CLASS_P (val)
    1856              :                                   && ! SSA_VAR_P (val)))
    1857              :                             {
    1858            0 :                               c_parser_error (parser, "invalid _Literal");
    1859            0 :                               return expr;
    1860              :                             }
    1861         5312 :                           CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, val);
    1862         5312 :                           if (! CONSTANT_CLASS_P (val))
    1863           83 :                             constant_p = false;
    1864         5312 :                           if (c_parser_next_token_is (parser, CPP_COMMA))
    1865         4528 :                             c_parser_consume_token (parser);
    1866              :                           else
    1867              :                             break;
    1868         4528 :                         }
    1869              :                       while (1);
    1870              :                     }
    1871          807 :                   if (c_parser_require (parser, CPP_CLOSE_BRACE,
    1872              :                                         "expected %<}%>"))
    1873              :                     {
    1874          807 :                       if (v && constant_p)
    1875          757 :                         expr.value = build_vector_from_ctor (type, v);
    1876              :                       else
    1877           50 :                         expr.value = build_constructor (type, v);
    1878              :                     }
    1879              :                   else
    1880              :                     {
    1881            0 :                       c_parser_skip_until_found (parser, CPP_CLOSE_BRACE,
    1882              :                                                  "expected %<}%>");
    1883            0 :                       return expr;
    1884              :                     }
    1885              :                 }
    1886              :               else
    1887              :                 {
    1888          454 :                   bool neg_p, addr_p;
    1889          454 :                   if ((neg_p = c_parser_next_token_is (parser, CPP_MINUS)))
    1890           39 :                     c_parser_consume_token (parser);
    1891          454 :                   if ((addr_p = c_parser_next_token_is (parser, CPP_AND)))
    1892           95 :                     c_parser_consume_token (parser);
    1893          454 :                   tree val = c_parser_gimple_postfix_expression (parser).value;
    1894          454 :                   if (! val
    1895          454 :                       || val == error_mark_node
    1896          454 :                       || (!CONSTANT_CLASS_P (val) && !addr_p))
    1897              :                     {
    1898            0 :                       c_parser_error (parser, "invalid _Literal");
    1899            0 :                       return expr;
    1900              :                     }
    1901          361 :                   if (addr_p)
    1902              :                     {
    1903           95 :                       val = build1 (ADDR_EXPR, type, val);
    1904           95 :                       if (!is_gimple_invariant_address (val))
    1905              :                         {
    1906            0 :                           c_parser_error (parser, "invalid _Literal");
    1907            0 :                           return expr;
    1908              :                         }
    1909              :                     }
    1910          454 :                   if (neg_p)
    1911              :                     {
    1912           39 :                       val = const_unop (NEGATE_EXPR, TREE_TYPE (val), val);
    1913           39 :                       if (! val)
    1914              :                         {
    1915            0 :                           c_parser_error (parser, "invalid _Literal");
    1916            0 :                           return expr;
    1917              :                         }
    1918              :                     }
    1919          454 :                   expr.value = fold_convert (type, val);
    1920              :                 }
    1921         1261 :               return expr;
    1922              :             }
    1923              : 
    1924              :           /* SSA name.  */
    1925        13797 :           unsigned version, ver_offset;
    1926        13797 :           if (! lookup_name (id)
    1927        13797 :               && c_parser_parse_ssa_name_id (id, &version, &ver_offset))
    1928              :             {
    1929         6831 :               c_parser_consume_token (parser);
    1930         6831 :               expr.value = c_parser_parse_ssa_name (parser, id, NULL_TREE,
    1931              :                                                     version, ver_offset);
    1932         6831 :               if (expr.value == error_mark_node)
    1933            2 :                 return expr;
    1934         6829 :               set_c_expr_source_range (&expr, tok_range);
    1935              :               /* For default definition SSA names.  */
    1936         6829 :               if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
    1937          817 :                   && c_parser_peek_2nd_token (parser)->type == CPP_NAME
    1938          816 :                   && strcmp ("D",
    1939          816 :                              IDENTIFIER_POINTER
    1940              :                                (c_parser_peek_2nd_token (parser)->value)) == 0
    1941         7645 :                   && c_parser_peek_nth_token (parser, 3)->type == CPP_CLOSE_PAREN)
    1942              :                 {
    1943          816 :                   c_parser_consume_token (parser);
    1944          816 :                   c_parser_consume_token (parser);
    1945          816 :                   c_parser_consume_token (parser);
    1946          816 :                   if (! SSA_NAME_IS_DEFAULT_DEF (expr.value))
    1947              :                     {
    1948          524 :                       if (!SSA_NAME_VAR (expr.value))
    1949              :                         {
    1950            1 :                           error_at (loc, "anonymous SSA name cannot have"
    1951              :                                     " default definition");
    1952            1 :                           expr.value = error_mark_node;
    1953            1 :                           return expr;
    1954              :                         }
    1955          523 :                       set_ssa_default_def (cfun, SSA_NAME_VAR (expr.value),
    1956              :                                            expr.value);
    1957          523 :                       SSA_NAME_DEF_STMT (expr.value) = gimple_build_nop ();
    1958              :                     }
    1959              :                 }
    1960              :             }
    1961              :           else
    1962              :             {
    1963         6966 :               c_parser_consume_token (parser);
    1964         6966 :               expr.value
    1965        13932 :                 = build_external_ref (loc, id,
    1966         6966 :                                       (c_parser_peek_token (parser)->type
    1967              :                                        == CPP_OPEN_PAREN), &expr.original_type);
    1968         6966 :               set_c_expr_source_range (&expr, tok_range);
    1969              :             }
    1970              :           break;
    1971              :         }
    1972              :       /* Fallthru.  */
    1973            3 :     default:
    1974            3 :       c_parser_error (parser, "expected expression");
    1975            3 :       expr.set_error ();
    1976            3 :       break;
    1977              :     }
    1978        22603 :   if (expr.value == error_mark_node)
    1979           21 :     return expr;
    1980        22582 :   return c_parser_gimple_postfix_expression_after_primary
    1981        22582 :     (parser, EXPR_LOC_OR_LOC (expr.value, loc), expr);
    1982              : }
    1983              : 
    1984              : /* Parse a gimple postfix expression after the initial primary or compound
    1985              :    literal.  */
    1986              : 
    1987              : static struct c_expr
    1988        22582 : c_parser_gimple_postfix_expression_after_primary (gimple_parser &parser,
    1989              :                                                   location_t expr_loc,
    1990              :                                                   struct c_expr expr)
    1991              : {
    1992        23108 :   location_t start;
    1993        23108 :   location_t finish;
    1994        23108 :   tree ident;
    1995        23108 :   location_t comp_loc;
    1996              : 
    1997        23108 :   while (true)
    1998              :     {
    1999        23108 :       location_t op_loc = c_parser_peek_token (parser)->location;
    2000        23108 :       switch (c_parser_peek_token (parser)->type)
    2001              :         {
    2002          338 :         case CPP_OPEN_SQUARE:
    2003          338 :           {
    2004          338 :             c_parser_consume_token (parser);
    2005          338 :             tree idx = c_parser_gimple_unary_expression (parser).value;
    2006              : 
    2007          338 :             if (! c_parser_require (parser, CPP_CLOSE_SQUARE, "expected %<]%>"))
    2008              :               {
    2009            0 :                 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
    2010            0 :                 break;
    2011              :               }
    2012              : 
    2013          338 :             start = expr.get_start ();
    2014          338 :             finish = c_parser_tokens_buf (parser, 0)->location;
    2015          338 :             expr.value = build_array_ref (op_loc, expr.value, idx);
    2016          338 :             set_c_expr_source_range (&expr, start, finish);
    2017          338 :             expr.m_decimal = 0;
    2018              : 
    2019          338 :             expr.original_code = ERROR_MARK;
    2020          338 :             expr.original_type = NULL;
    2021          338 :             break;
    2022              :           }
    2023          140 :         case CPP_OPEN_PAREN:
    2024          140 :           {
    2025              :             /* Function call.  */
    2026          140 :             c_parser_consume_token (parser);
    2027          140 :             auto_vec<tree> exprlist;
    2028          140 :             if (! c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
    2029           28 :               c_parser_gimple_expr_list (parser, &exprlist);
    2030          140 :             c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
    2031              :                                        "expected %<)%>");
    2032          140 :             if (!FUNC_OR_METHOD_TYPE_P (TREE_TYPE (expr.value)))
    2033              :               {
    2034            1 :                 c_parser_error (parser, "invalid call to non-function");
    2035            1 :                 expr.set_error ();
    2036            1 :                 break;
    2037              :               }
    2038          139 :             expr.value = build_call_array_loc
    2039          139 :                 (expr_loc, TREE_TYPE (TREE_TYPE (expr.value)),
    2040          167 :                  expr.value, exprlist.length (), exprlist.address ());
    2041          139 :             expr.m_decimal = 0;
    2042          139 :             expr.original_code = ERROR_MARK;
    2043          139 :             expr.original_type = NULL;
    2044          139 :             break;
    2045          140 :           }
    2046           39 :         case CPP_DOT:
    2047           39 :           {
    2048              :             /* Structure element reference.  */
    2049           39 :             c_parser_consume_token (parser);
    2050           39 :             if (c_parser_next_token_is (parser, CPP_NAME))
    2051              :               {
    2052           39 :                 c_token *comp_tok = c_parser_peek_token (parser);
    2053           39 :                 ident = comp_tok->value;
    2054           39 :                 comp_loc = comp_tok->location;
    2055              :               }
    2056              :             else
    2057              :               {
    2058            0 :                 c_parser_error (parser, "expected identifier");
    2059            0 :                 expr.set_error ();
    2060            0 :                 expr.original_code = ERROR_MARK;
    2061            0 :                 expr.original_type = NULL;
    2062            0 :                 return expr;
    2063              :               }
    2064           39 :             start = expr.get_start ();
    2065           39 :             finish = c_parser_peek_token (parser)->get_finish ();
    2066           39 :             c_parser_consume_token (parser);
    2067           39 :             expr.value = build_component_ref (op_loc, expr.value, ident,
    2068              :                                               comp_loc, UNKNOWN_LOCATION);
    2069           39 :             set_c_expr_source_range (&expr, start, finish);
    2070           39 :             expr.m_decimal = 0;
    2071           39 :             expr.original_code = ERROR_MARK;
    2072           39 :             if (TREE_CODE (expr.value) != COMPONENT_REF)
    2073            0 :               expr.original_type = NULL;
    2074              :             else
    2075              :               {
    2076              :                 /* Remember the original type of a bitfield.  */
    2077           39 :                 tree field = TREE_OPERAND (expr.value, 1);
    2078           39 :                 if (TREE_CODE (field) != FIELD_DECL)
    2079            0 :                   expr.original_type = NULL;
    2080              :                 else
    2081           39 :                   expr.original_type = DECL_BIT_FIELD_TYPE (field);
    2082              :               }
    2083              :             break;
    2084              :           }
    2085           10 :         case CPP_DEREF:
    2086           10 :           {
    2087              :             /* Structure element reference.  */
    2088           10 :             if (!POINTER_TYPE_P (TREE_TYPE (expr.value)))
    2089              :               {
    2090            1 :                 c_parser_error (parser, "dereference of non-pointer");
    2091            1 :                 expr.set_error ();
    2092            1 :                 expr.original_code = ERROR_MARK;
    2093            1 :                 expr.original_type = NULL;
    2094            1 :                 return expr;
    2095              :               }
    2096            9 :             c_parser_consume_token (parser);
    2097            9 :             if (c_parser_next_token_is (parser, CPP_NAME))
    2098              :               {
    2099            9 :                 c_token *comp_tok = c_parser_peek_token (parser);
    2100            9 :                 ident = comp_tok->value;
    2101            9 :                 comp_loc = comp_tok->location;
    2102              :               }
    2103              :             else
    2104              :               {
    2105            0 :                 c_parser_error (parser, "expected identifier");
    2106            0 :                 expr.set_error ();
    2107            0 :                 expr.original_code = ERROR_MARK;
    2108            0 :                 expr.original_type = NULL;
    2109            0 :                 return expr;
    2110              :               }
    2111            9 :             start = expr.get_start ();
    2112            9 :             finish = c_parser_peek_token (parser)->get_finish ();
    2113            9 :             c_parser_consume_token (parser);
    2114            9 :             expr.value = build_component_ref (op_loc,
    2115              :                                               build_simple_mem_ref_loc
    2116              :                                                 (op_loc, expr.value),
    2117              :                                               ident, comp_loc,
    2118              :                                               expr.get_location ());
    2119            9 :             set_c_expr_source_range (&expr, start, finish);
    2120            9 :             expr.m_decimal = 0;
    2121            9 :             expr.original_code = ERROR_MARK;
    2122            9 :             if (TREE_CODE (expr.value) != COMPONENT_REF)
    2123            0 :               expr.original_type = NULL;
    2124              :             else
    2125              :               {
    2126              :                 /* Remember the original type of a bitfield.  */
    2127            9 :                 tree field = TREE_OPERAND (expr.value, 1);
    2128            9 :                 if (TREE_CODE (field) != FIELD_DECL)
    2129            0 :                   expr.original_type = NULL;
    2130              :                 else
    2131            9 :                   expr.original_type = DECL_BIT_FIELD_TYPE (field);
    2132              :               }
    2133              :             break;
    2134              :           }
    2135        22581 :         default:
    2136        22581 :           return expr;
    2137              :         }
    2138              :     }
    2139              : }
    2140              : 
    2141              : /* Parse expression list.
    2142              : 
    2143              :    gimple-expr-list:
    2144              :      gimple-unary-expression
    2145              :      gimple-expr-list , gimple-unary-expression
    2146              : 
    2147              :  */
    2148              : 
    2149              : static void
    2150          179 : c_parser_gimple_expr_list (gimple_parser &parser, vec<tree> *ret)
    2151              : {
    2152          179 :   struct c_expr expr;
    2153              : 
    2154          179 :   expr = c_parser_gimple_unary_expression (parser);
    2155          179 :   ret->safe_push (expr.value);
    2156          536 :   while (c_parser_next_token_is (parser, CPP_COMMA))
    2157              :     {
    2158          178 :       c_parser_consume_token (parser);
    2159          178 :       expr = c_parser_gimple_unary_expression (parser);
    2160          178 :       ret->safe_push (expr.value);
    2161              :     }
    2162          179 : }
    2163              : 
    2164              : /* Parse gimple label.
    2165              : 
    2166              :    gimple-label:
    2167              :      identifier :
    2168              :      case constant-expression :
    2169              :      default :
    2170              : 
    2171              : */
    2172              : 
    2173              : static void
    2174           73 : c_parser_gimple_label (gimple_parser &parser, gimple_seq *seq)
    2175              : {
    2176           73 :   tree name = c_parser_peek_token (parser)->value;
    2177           73 :   location_t loc1 = c_parser_peek_token (parser)->location;
    2178           73 :   gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
    2179           73 :   c_parser_consume_token (parser);
    2180           73 :   gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
    2181           73 :   c_parser_consume_token (parser);
    2182           73 :   tree label = define_label (loc1, name);
    2183           73 :   if (label)
    2184           72 :     gimple_seq_add_stmt_without_update (seq, gimple_build_label (label));
    2185           73 :   return;
    2186              : }
    2187              : 
    2188              : /* Parse gimple/RTL pass list.
    2189              : 
    2190              :    gimple-or-rtl-pass-list:
    2191              :      startwith("pass-name")[,{cfg,ssa}]
    2192              :  */
    2193              : 
    2194              : void
    2195         1100 : c_parser_gimple_or_rtl_pass_list (c_parser *parser, c_declspecs *specs)
    2196              : {
    2197         1100 :   char *pass = NULL;
    2198              : 
    2199              :   /* Accept __GIMPLE/__RTL.  */
    2200         1100 :   if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
    2201              :     return;
    2202          903 :   c_parser_consume_token (parser);
    2203              : 
    2204          903 :   specs->entry_bb_count = profile_count::uninitialized ();
    2205         1659 :   while (c_parser_next_token_is (parser, CPP_NAME))
    2206              :     {
    2207          756 :       profile_quality quality;
    2208          756 :       const char *op = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
    2209          756 :       c_parser_consume_token (parser);
    2210          756 :       if (! strcmp (op, "startwith"))
    2211              :         {
    2212          240 :           if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    2213            0 :             return;
    2214          240 :           if (c_parser_next_token_is_not (parser, CPP_STRING))
    2215              :             {
    2216            0 :               error_at (c_parser_peek_token (parser)->location,
    2217              :                         "expected pass name");
    2218            0 :               return;
    2219              :             }
    2220          240 :           pass = xstrdup (TREE_STRING_POINTER
    2221              :                           (c_parser_string_literal (parser, false,
    2222              :                                                     false).value));
    2223          240 :           if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<(%>"))
    2224              :             return;
    2225              :         }
    2226          516 :       else if (parse_profile_quality (op, &quality))
    2227              :         {
    2228           98 :           tree q;
    2229           98 :           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    2230              :             return;
    2231              : 
    2232           98 :           if (!c_parser_next_token_is (parser, CPP_NUMBER)
    2233           98 :               || (TREE_CODE (q = c_parser_peek_token (parser)->value)
    2234              :                   != INTEGER_CST))
    2235              :             {
    2236            0 :               c_parser_error (parser, "expected count value");
    2237            0 :               return;
    2238              :             }
    2239              : 
    2240           98 :           specs->entry_bb_count
    2241           98 :             = profile_count::from_gcov_type (TREE_INT_CST_LOW (q), quality);
    2242           98 :           c_parser_consume_token (parser);
    2243           98 :           if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
    2244              :             return;
    2245              :         }
    2246          418 :       else if (specs->declspec_il != cdil_gimple)
    2247              :         /* Allow only one IL specifier and none on RTL.  */
    2248              :         ;
    2249          418 :       else if (! strcmp (op, "cfg"))
    2250            0 :         specs->declspec_il = cdil_gimple_cfg;
    2251          418 :       else if (! strcmp (op, "ssa"))
    2252          418 :         specs->declspec_il = cdil_gimple_ssa;
    2253              :       else
    2254              :         {
    2255            0 :           error_at (c_parser_peek_token (parser)->location,
    2256              :                     "invalid operation");
    2257            0 :           return;
    2258              :         }
    2259          756 :      if (c_parser_next_token_is (parser, CPP_COMMA))
    2260          311 :        c_parser_consume_token (parser);
    2261              :     }
    2262              : 
    2263          903 :   if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
    2264              :     return;
    2265              : 
    2266          903 :   specs->gimple_or_rtl_pass = pass;
    2267              : }
    2268              : 
    2269              : /* Parse gimple local declaration.
    2270              : 
    2271              :    declaration-specifiers:
    2272              :      storage-class-specifier declaration-specifiers[opt]
    2273              :      type-specifier declaration-specifiers[opt]
    2274              :      type-qualifier declaration-specifiers[opt]
    2275              :      function-specifier declaration-specifiers[opt]
    2276              :      alignment-specifier declaration-specifiers[opt]
    2277              : 
    2278              :    storage-class-specifier:
    2279              :      typedef
    2280              :      extern
    2281              :      static
    2282              :      auto
    2283              :      register
    2284              : 
    2285              :    type-specifier:
    2286              :      void
    2287              :      char
    2288              :      short
    2289              :      int
    2290              :      long
    2291              :      float
    2292              :      double
    2293              :      signed
    2294              :      unsigned
    2295              :      _Bool
    2296              :      _Complex
    2297              : 
    2298              :    type-qualifier:
    2299              :      const
    2300              :      restrict
    2301              :      volatile
    2302              :      address-space-qualifier
    2303              :      _Atomic
    2304              : 
    2305              :  */
    2306              : 
    2307              : static void
    2308         4424 : c_parser_gimple_declaration (gimple_parser &parser)
    2309              : {
    2310         4424 :   struct c_declarator *declarator;
    2311         4424 :   struct c_declspecs *specs = build_null_declspecs ();
    2312         4424 :   c_parser_declspecs (parser, specs, true, true, true,
    2313              :                       true, true, true, true, cla_nonabstract_decl);
    2314         4424 :   finish_declspecs (specs);
    2315              : 
    2316              :   /* Provide better error recovery.  Note that a type name here is usually
    2317              :      better diagnosed as a redeclaration.  */
    2318         4424 :   if (c_parser_next_token_starts_declspecs (parser)
    2319         4424 :       && ! c_parser_next_token_is (parser, CPP_NAME))
    2320              :     {
    2321            0 :       c_parser_error (parser, "expected %<;%>");
    2322            0 :       c_parser_set_error (parser, false);
    2323            0 :       return;
    2324              :     }
    2325              : 
    2326         4424 :   bool dummy = false;
    2327         8848 :   declarator = c_parser_declarator (parser,
    2328         4424 :                                     specs->typespec_kind != ctsk_none,
    2329              :                                     C_DTR_NORMAL, &dummy);
    2330              : 
    2331         4424 :   if (!c_parser_next_token_is (parser, CPP_SEMICOLON))
    2332              :     {
    2333            0 :       c_parser_error (parser, "expected %<;%>");
    2334            0 :       return;
    2335              :     }
    2336         4424 :   if (declarator)
    2337              :     {
    2338              :       /* Handle SSA name decls specially, they do not go into the identifier
    2339              :          table but we simply build the SSA name for later lookup.  */
    2340              :       unsigned version, ver_offset;
    2341              :       /* Handle SSA pointer declarations in a very simplistic ways, we
    2342              :          probably would like to call grokdeclarator in a special mode to
    2343              :          just build the type of the decl - start_decl already pushes
    2344              :          the identifier to the bindings for lookup, something we do not
    2345              :          want.  */
    2346              :       struct c_declarator *id_declarator = declarator;
    2347         4640 :       while (id_declarator->kind == cdk_pointer)
    2348          217 :         id_declarator = id_declarator->declarator;
    2349         4423 :       if (id_declarator->kind == cdk_id
    2350         4386 :           && (declarator->kind == cdk_pointer
    2351         4176 :               || is_gimple_reg_type (specs->type))
    2352         4377 :           && c_parser_parse_ssa_name_id (id_declarator->u.id.id,
    2353              :                                          &version, &ver_offset)
    2354              :           /* The following restricts it to unnamed anonymous SSA names
    2355              :              which fails parsing of named ones in dumps (we could
    2356              :              decide to not dump their name for -gimple).  */
    2357         6301 :           && ver_offset == 0)
    2358              :         {
    2359         1825 :           struct c_declarator *p = declarator;
    2360         1825 :           tree type = specs->type;
    2361         1975 :           while (p->kind == cdk_pointer)
    2362              :             {
    2363          150 :               type = build_pointer_type (type);
    2364          150 :               p = p->declarator;
    2365              :             }
    2366         1825 :           c_parser_parse_ssa_name (parser, id_declarator->u.id.id, type,
    2367              :                                    version, ver_offset);
    2368              :         }
    2369              :       else
    2370              :         {
    2371         2598 :           tree postfix_attrs = NULL_TREE;
    2372         2598 :           tree all_prefix_attrs = specs->attrs;
    2373         2598 :           specs->attrs = NULL;
    2374         2598 :           tree decl = start_decl (declarator, specs, false,
    2375              :                                   chainon (postfix_attrs, all_prefix_attrs));
    2376         2598 :           if (decl)
    2377         2598 :             finish_decl (decl, UNKNOWN_LOCATION, NULL_TREE, NULL_TREE,
    2378              :                          NULL_TREE);
    2379              :         }
    2380              :     }
    2381              : }
    2382              : 
    2383              : /* Parse gimple goto statement.  */
    2384              : 
    2385              : static void
    2386          458 : c_parser_gimple_goto_stmt (gimple_parser &parser,
    2387              :                            location_t loc, tree label, gimple_seq *seq)
    2388              : {
    2389          458 :   if (cfun->curr_properties & PROP_cfg)
    2390              :     {
    2391          454 :       int dest_index;
    2392          454 :       profile_probability prob;
    2393          454 :       if (c_parser_gimple_parse_bb_spec_edge_probability (label, parser,
    2394              :                                                           &dest_index, &prob))
    2395              :         {
    2396          454 :           parser.push_edge (parser.current_bb->index, dest_index,
    2397              :                             EDGE_FALLTHRU, prob);
    2398          454 :           return;
    2399              :         }
    2400              :     }
    2401            4 :   tree decl = lookup_label_for_goto (loc, label);
    2402            4 :   gimple_seq_add_stmt_without_update (seq, gimple_build_goto (decl));
    2403              : }
    2404              : 
    2405              : /* Parse a parenthesized condition.
    2406              :    gimple-condition:
    2407              :      ( gimple-binary-expression )    */
    2408              : 
    2409              : static tree
    2410          403 : c_parser_gimple_paren_condition (gimple_parser &parser)
    2411              : {
    2412          403 :   if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    2413            0 :     return error_mark_node;
    2414          403 :   tree cond
    2415          403 :     = c_parser_gimple_binary_expression (parser, boolean_type_node).value;
    2416          403 :   if (cond != error_mark_node
    2417          402 :       && ! COMPARISON_CLASS_P (cond)
    2418            6 :       && ! CONSTANT_CLASS_P (cond)
    2419              :       && ! SSA_VAR_P (cond))
    2420              :     {
    2421            1 :       c_parser_error (parser, "comparison required");
    2422            1 :       cond = error_mark_node;
    2423              :     }
    2424          403 :   if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
    2425            0 :     return error_mark_node;
    2426              :   return cond;
    2427              : }
    2428              : 
    2429              : /* Parse gimple try statement.
    2430              : 
    2431              :    try-statement:
    2432              :      try { ... } finally { ... }
    2433              :      try { ... } finally { ... } else { ... }
    2434              : 
    2435              :    This could support try/catch as well, but it's not implemented yet.
    2436              :  */
    2437              : 
    2438              : static void
    2439            4 : c_parser_gimple_try_stmt (gimple_parser &parser, gimple_seq *seq)
    2440              : {
    2441            4 :   gimple_seq tryseq = NULL;
    2442            4 :   c_parser_consume_token (parser);
    2443            4 :   c_parser_gimple_compound_statement (parser, &tryseq);
    2444              : 
    2445            4 :   if ((c_parser_next_token_is (parser, CPP_KEYWORD)
    2446            0 :        && c_parser_peek_token (parser)->keyword == RID_AT_FINALLY)
    2447            4 :       || (c_parser_next_token_is (parser, CPP_NAME)
    2448            4 :           && c_parser_peek_token (parser)->id_kind == C_ID_ID
    2449            4 :           && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser)->value),
    2450              :                      "finally") == 0))
    2451              :     {
    2452            4 :       gimple_seq finseq = NULL;
    2453            4 :       c_parser_consume_token (parser);
    2454            4 :       c_parser_gimple_compound_statement (parser, &finseq);
    2455              : 
    2456            4 :       if (c_parser_next_token_is (parser, CPP_KEYWORD)
    2457            4 :           && c_parser_peek_token (parser)->keyword == RID_ELSE)
    2458              :         {
    2459            2 :           gimple_seq elsseq = NULL;
    2460            2 :           c_parser_consume_token (parser);
    2461            2 :           c_parser_gimple_compound_statement (parser, &elsseq);
    2462              : 
    2463            2 :           geh_else *stmt = gimple_build_eh_else (finseq, elsseq);
    2464            2 :           finseq = NULL;
    2465            2 :           gimple_seq_add_stmt_without_update (&finseq, stmt);
    2466              :         }
    2467              : 
    2468            4 :       gtry *stmt = gimple_build_try (tryseq, finseq, GIMPLE_TRY_FINALLY);
    2469            4 :       gimple_seq_add_stmt_without_update (seq, stmt);
    2470              :     }
    2471            0 :   else if (c_parser_next_token_is (parser, CPP_KEYWORD)
    2472            0 :       && c_parser_peek_token (parser)->keyword == RID_AT_CATCH)
    2473            0 :     c_parser_error (parser, "%<catch%> is not supported");
    2474              :   else
    2475            0 :     c_parser_error (parser, "expected %<finally%> or %<catch%>");
    2476            4 : }
    2477              : 
    2478              : /* Parse gimple if-else statement.
    2479              : 
    2480              :    if-statement:
    2481              :      if ( gimple-binary-expression ) gimple-goto-statement
    2482              :      if ( gimple-binary-expression ) gimple-goto-statement \
    2483              :                                         else gimple-goto-statement
    2484              :  */
    2485              : 
    2486              : static void
    2487          403 : c_parser_gimple_if_stmt (gimple_parser &parser, gimple_seq *seq)
    2488              : {
    2489          403 :   tree t_label = NULL_TREE, f_label = NULL_TREE, label;
    2490          403 :   location_t loc;
    2491          403 :   c_parser_consume_token (parser);
    2492          403 :   tree cond = c_parser_gimple_paren_condition (parser);
    2493              : 
    2494          403 :   if (c_parser_next_token_is_keyword (parser, RID_GOTO))
    2495              :     {
    2496          403 :       loc = c_parser_peek_token (parser)->location;
    2497          403 :       c_parser_consume_token (parser);
    2498          403 :       if (! c_parser_next_token_is (parser, CPP_NAME))
    2499              :         {
    2500            1 :           c_parser_error (parser, "expected label");
    2501            2 :           return;
    2502              :         }
    2503          402 :       label = c_parser_peek_token (parser)->value;
    2504          402 :       c_parser_consume_token (parser);
    2505          402 :       int dest_index;
    2506          402 :       profile_probability prob;
    2507          402 :       if ((cfun->curr_properties & PROP_cfg)
    2508          402 :           && c_parser_gimple_parse_bb_spec_edge_probability (label, parser,
    2509              :                                                              &dest_index, &prob))
    2510          382 :         parser.push_edge (parser.current_bb->index, dest_index,
    2511              :                           EDGE_TRUE_VALUE, prob);
    2512              :       else
    2513           20 :         t_label = lookup_label_for_goto (loc, label);
    2514          402 :       if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
    2515              :         return;
    2516              :     }
    2517              :   else
    2518              :     {
    2519            0 :       c_parser_error (parser, "expected goto expression");
    2520            0 :       return;
    2521              :     }
    2522              : 
    2523          402 :   if (c_parser_next_token_is_keyword (parser, RID_ELSE))
    2524          402 :     c_parser_consume_token (parser);
    2525              :   else
    2526              :     {
    2527            0 :       c_parser_error (parser, "expected else statement");
    2528            0 :       return;
    2529              :     }
    2530              : 
    2531          402 :   if (c_parser_next_token_is_keyword (parser, RID_GOTO))
    2532              :     {
    2533          402 :       loc = c_parser_peek_token (parser)->location;
    2534          402 :       c_parser_consume_token (parser);
    2535          402 :       if (! c_parser_next_token_is (parser, CPP_NAME))
    2536              :         {
    2537            2 :           c_parser_error (parser, "expected label");
    2538            4 :           return;
    2539              :         }
    2540          400 :       label = c_parser_peek_token (parser)->value;
    2541          400 :       c_parser_consume_token (parser);
    2542          400 :       int dest_index;
    2543          400 :       profile_probability prob;
    2544          400 :       if ((cfun->curr_properties & PROP_cfg)
    2545          400 :           && c_parser_gimple_parse_bb_spec_edge_probability (label, parser,
    2546              :                                                              &dest_index, &prob))
    2547          382 :         parser.push_edge (parser.current_bb->index, dest_index,
    2548              :                           EDGE_FALSE_VALUE, prob);
    2549              :       else
    2550           18 :         f_label = lookup_label_for_goto (loc, label);
    2551          400 :       if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
    2552              :         return;
    2553              :     }
    2554              :   else
    2555              :     {
    2556            0 :       c_parser_error (parser, "expected goto expression");
    2557            0 :       return;
    2558              :     }
    2559              : 
    2560          400 :   if (cond != error_mark_node)
    2561          398 :     gimple_seq_add_stmt_without_update (seq, gimple_build_cond_from_tree (cond, t_label,
    2562              :                                                            f_label));
    2563              : }
    2564              : 
    2565              : /* Parse gimple switch-statement.
    2566              : 
    2567              :    gimple-switch-statement:
    2568              :      switch (gimple-postfix-expression) gimple-case-statement
    2569              : 
    2570              :    gimple-case-statement:
    2571              :      gimple-case-statement
    2572              :      gimple-label-statement : gimple-goto-statement
    2573              : */
    2574              : 
    2575              : static void
    2576            5 : c_parser_gimple_switch_stmt (gimple_parser &parser, gimple_seq *seq)
    2577              : {
    2578            5 :   c_expr cond_expr;
    2579            5 :   tree case_label, label;
    2580            5 :   auto_vec<tree> labels;
    2581            5 :   tree default_label = NULL_TREE;
    2582            5 :   c_parser_consume_token (parser);
    2583              : 
    2584            5 :   if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
    2585              :     return;
    2586            5 :   cond_expr = c_parser_gimple_postfix_expression (parser);
    2587            5 :   if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
    2588              :     return;
    2589              : 
    2590            5 :   if (! c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
    2591              :     return;
    2592              : 
    2593           21 :   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
    2594              :     {
    2595           16 :       if (c_parser_next_token_is (parser, CPP_EOF))
    2596              :         {
    2597            0 :           c_parser_error (parser, "expected statement");
    2598            0 :           return;
    2599              :         }
    2600              : 
    2601           16 :       switch (c_parser_peek_token (parser)->keyword)
    2602              :         {
    2603           11 :         case RID_CASE:
    2604           11 :           {
    2605           11 :             c_expr exp1;
    2606           11 :             location_t loc = c_parser_peek_token (parser)->location;
    2607           11 :             c_parser_consume_token (parser);
    2608              : 
    2609           11 :             if (c_parser_next_token_is (parser, CPP_NAME)
    2610           11 :                 || c_parser_peek_token (parser)->type == CPP_NUMBER)
    2611           11 :               exp1 = c_parser_gimple_postfix_expression (parser);
    2612              :             else
    2613              :               {
    2614            0 :                 c_parser_error (parser, "expected expression");
    2615            0 :                 return;
    2616              :               }
    2617              : 
    2618           11 :             if (c_parser_next_token_is (parser, CPP_COLON))
    2619              :               {
    2620           11 :                 c_parser_consume_token (parser);
    2621           11 :                 if (c_parser_next_token_is (parser, CPP_NAME))
    2622              :                   {
    2623           11 :                     label = c_parser_peek_token (parser)->value;
    2624           11 :                     c_parser_consume_token (parser);
    2625           11 :                     tree decl = lookup_label_for_goto (loc, label);
    2626           11 :                     case_label = build_case_label (exp1.value, NULL_TREE,
    2627              :                                                    decl);
    2628           11 :                     labels.safe_push (case_label);
    2629           11 :                     if (! c_parser_require (parser, CPP_SEMICOLON,
    2630              :                                             "expected %<;%>"))
    2631              :                       return;
    2632              :                   }
    2633            0 :                 else if (! c_parser_require (parser, CPP_NAME,
    2634              :                                              "expected label"))
    2635              :                   return;
    2636              :               }
    2637            0 :             else if (! c_parser_require (parser, CPP_SEMICOLON,
    2638              :                                          "expected %<:%>"))
    2639              :               return;
    2640           11 :             break;
    2641              :           }
    2642            5 :         case RID_DEFAULT:
    2643            5 :           {
    2644            5 :             location_t loc = c_parser_peek_token (parser)->location;
    2645            5 :             c_parser_consume_token (parser);
    2646            5 :             if (c_parser_next_token_is (parser, CPP_COLON))
    2647              :               {
    2648            5 :                 c_parser_consume_token (parser);
    2649            5 :                 if (c_parser_next_token_is (parser, CPP_NAME))
    2650              :                   {
    2651            5 :                     label = c_parser_peek_token (parser)->value;
    2652            5 :                     c_parser_consume_token (parser);
    2653            5 :                     tree decl = lookup_label_for_goto (loc, label);
    2654            5 :                     default_label = build_case_label (NULL_TREE, NULL_TREE,
    2655              :                                                       decl);
    2656            5 :                     if (! c_parser_require (parser, CPP_SEMICOLON,
    2657              :                                             "expected %<;%>"))
    2658              :                       return;
    2659              :                   }
    2660            0 :                 else if (! c_parser_require (parser, CPP_NAME,
    2661              :                                              "expected label"))
    2662              :                   return;
    2663              :               }
    2664            0 :             else if (! c_parser_require (parser, CPP_SEMICOLON,
    2665              :                                          "expected %<:%>"))
    2666              :               return;
    2667              :             break;
    2668              :           }
    2669            0 :         default:
    2670            0 :           c_parser_error (parser, "expected case label");
    2671            0 :           return;
    2672              :         }
    2673              : 
    2674              :     }
    2675            5 :   if (! c_parser_require (parser, CPP_CLOSE_BRACE, "expected %<}%>"))
    2676              :     return;
    2677              : 
    2678            5 :   if (cond_expr.value != error_mark_node)
    2679              :     {
    2680            4 :       gswitch *s = gimple_build_switch (cond_expr.value, default_label, labels);
    2681            4 :       gimple_seq_add_stmt_without_update (seq, s);
    2682              :     }
    2683            5 : }
    2684              : 
    2685              : /* Parse gimple return statement.  */
    2686              : 
    2687              : static void
    2688          671 : c_parser_gimple_return_stmt (gimple_parser &parser, gimple_seq *seq)
    2689              : {
    2690          671 :   location_t loc = c_parser_peek_token (parser)->location;
    2691          671 :   gimple *ret = NULL;
    2692          671 :   c_parser_consume_token (parser);
    2693          671 :   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
    2694              :     {
    2695          159 :       c_finish_gimple_return (loc, NULL_TREE);
    2696          159 :       ret = gimple_build_return (NULL);
    2697          159 :       gimple_seq_add_stmt_without_update (seq, ret);
    2698              :     }
    2699              :   else
    2700              :     {
    2701          512 :       location_t xloc = c_parser_peek_token (parser)->location;
    2702          512 :       c_expr expr = c_parser_gimple_unary_expression (parser);
    2703          512 :       if (expr.value != error_mark_node)
    2704              :         {
    2705          510 :           c_finish_gimple_return (xloc, expr.value);
    2706          510 :           ret = gimple_build_return (expr.value);
    2707          510 :           gimple_seq_add_stmt_without_update (seq, ret);
    2708              :         }
    2709              :     }
    2710          671 : }
    2711              : 
    2712              : /* Support function for c_parser_gimple_return_stmt.  */
    2713              : 
    2714              : static void
    2715          669 : c_finish_gimple_return (location_t loc, tree retval)
    2716              : {
    2717          669 :   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
    2718              : 
    2719              :   /* Use the expansion point to handle cases such as returning NULL
    2720              :      in a function returning void.  */
    2721          669 :   location_t xloc = expansion_point_location_if_in_system_header (loc);
    2722              : 
    2723          669 :   if (TREE_THIS_VOLATILE (current_function_decl))
    2724            0 :     warning_at (xloc, 0,
    2725              :                 "function declared %<noreturn%> has a %<return%> statement");
    2726              : 
    2727          669 :   if (! retval)
    2728          159 :     current_function_returns_null = 1;
    2729          510 :   else if (valtype == 0 || VOID_TYPE_P (valtype))
    2730              :     {
    2731            0 :       current_function_returns_null = 1;
    2732            0 :       if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
    2733              :         {
    2734            0 :           error_at
    2735            0 :             (xloc, "%<return%> with a value, in function returning void");
    2736            0 :           inform (DECL_SOURCE_LOCATION (current_function_decl),
    2737              :                   "declared here");
    2738              :         }
    2739              :     }
    2740          510 :   else if (TREE_CODE (valtype) != TREE_CODE (TREE_TYPE (retval)))
    2741              :     {
    2742            0 :       error_at
    2743            0 :         (xloc, "invalid conversion in return statement");
    2744            0 :       inform (DECL_SOURCE_LOCATION (current_function_decl),
    2745              :               "declared here");
    2746              :     }
    2747          669 :   return;
    2748              : }
        

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.