LCOV - code coverage report
Current view: top level - gcc/c - gimple-parser.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1088 1263 86.1 %
Date: 2020-03-28 11:57:23 Functions: 27 27 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

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

Generated by: LCOV version 1.0

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