gcc/c/gimple-parser.c

   1 /* Parser for GIMPLE.
   2    Copyright (C) 2016-2018 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
  58
  59 /* Gimple parsing functions.  */
  60 static bool c_parser_gimple_compound_statement (c_parser *, gimple_seq *);
  61 static void c_parser_gimple_label (c_parser *, gimple_seq *);
  62 static void c_parser_gimple_statement (c_parser *, gimple_seq *);
  63 static struct c_expr c_parser_gimple_binary_expression (c_parser *);
  64 static struct c_expr c_parser_gimple_unary_expression (c_parser *);
  65 static struct c_expr c_parser_gimple_postfix_expression (c_parser *);
  66 static struct c_expr c_parser_gimple_postfix_expression_after_primary (c_parser *,
  67                                                                        location_t,
  68                                                                        struct c_expr);
  69 static void c_parser_gimple_declaration (c_parser *);
  70 static void c_parser_gimple_goto_stmt (location_t, tree, gimple_seq *);
  71 static void c_parser_gimple_if_stmt (c_parser *, gimple_seq *);
  72 static void c_parser_gimple_switch_stmt (c_parser *, gimple_seq *);
  73 static void c_parser_gimple_return_stmt (c_parser *, gimple_seq *);
  74 static void c_finish_gimple_return (location_t, tree);
  75 static tree c_parser_gimple_paren_condition (c_parser *);
  76 static void c_parser_gimple_expr_list (c_parser *, vec<tree> *);
  77
  78
  79 /* Parse the body of a function declaration marked with "__GIMPLE".  */
  80
  81 void
  82 c_parser_parse_gimple_body (c_parser *parser)
  83 {
  84   gimple_seq seq = NULL;
  85   gimple_seq body = NULL;
  86   tree stmt = push_stmt_list ();
  87   push_scope ();
  88   location_t loc1 = c_parser_peek_token (parser)->location;
  89
  90   init_tree_ssa (cfun);
  91
  92   if (! c_parser_gimple_compound_statement (parser, &seq))
  93     {
  94       gimple *ret = gimple_build_return (NULL);
  95       gimple_seq_add_stmt (&seq, ret);
  96     }
  97
  98   tree block = pop_scope ();
  99   stmt = pop_stmt_list (stmt);
 100   stmt = c_build_bind_expr (loc1, block, stmt);
 101
 102   block = DECL_INITIAL (current_function_decl);
 103   BLOCK_SUBBLOCKS (block) = NULL_TREE;
 104   BLOCK_CHAIN (block) = NULL_TREE;
 105   TREE_ASM_WRITTEN (block) = 1;
 106
 107   gbind *bind_stmt = gimple_build_bind (BIND_EXPR_VARS (stmt), NULL,
 108                                         BIND_EXPR_BLOCK (stmt));
 109   gimple_bind_set_body (bind_stmt, seq);
 110   gimple_seq_add_stmt (&body, bind_stmt);
 111   gimple_set_body (current_function_decl, body);
 112
 113   /* While we have SSA names in the IL we do not have a CFG built yet
 114      and PHIs are represented using a PHI internal function.  We do
 115      have lowered control flow and exception handling (well, we do not
 116      have parser support for EH yet).  But as we still have BINDs
 117      we have to go through lowering again.  */
 118   cfun->curr_properties = PROP_gimple_any;
 119
 120   dump_function (TDI_gimple, current_function_decl);
 121 }
 122
 123 /* Parse a compound statement in gimple function body.
 124
 125    gimple-statement:
 126      gimple-statement
 127      gimple-declaration-statement
 128      gimple-if-statement
 129      gimple-switch-statement
 130      gimple-labeled-statement
 131      gimple-expression-statement
 132      gimple-goto-statement
 133      gimple-phi-statement
 134      gimple-return-statement
 135 */
 136
 137 static bool
 138 c_parser_gimple_compound_statement (c_parser *parser, gimple_seq *seq)
 139 {
 140   bool return_p = false;
 141
 142   if (! c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
 143     return false;
 144
 145   /* A compund statement starts with optional declarations.  */
 146   while (c_parser_next_tokens_start_declaration (parser))
 147     {
 148       c_parser_gimple_declaration (parser);
 149       if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
 150         return false;
 151     }
 152
 153   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
 154     {
 155       if (c_parser_error (parser))
 156         {
 157           c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
 158           return return_p;
 159         }
 160       else if (c_parser_next_token_is (parser, CPP_EOF))
 161         {
 162           c_parser_error (parser, "expected declaration or statement");
 163           return return_p;
 164         }
 165
 166       switch (c_parser_peek_token (parser)->type)
 167         {
 168         case CPP_KEYWORD:
 169           switch (c_parser_peek_token (parser)->keyword)
 170             {
 171             case RID_IF:
 172               c_parser_gimple_if_stmt (parser, seq);
 173               break;
 174             case RID_SWITCH:
 175               c_parser_gimple_switch_stmt (parser, seq);
 176               break;
 177             case RID_GOTO:
 178               {
 179                 location_t loc = c_parser_peek_token (parser)->location;
 180                 c_parser_consume_token (parser);
 181                 if (c_parser_next_token_is (parser, CPP_NAME))
 182                   {
 183                     c_parser_gimple_goto_stmt (loc,
 184                                                c_parser_peek_token
 185                                                (parser)->value,
 186                                                seq);
 187                     c_parser_consume_token (parser);
 188                     if (! c_parser_require (parser, CPP_SEMICOLON,
 189                                             "expected %<;%>"))
 190                       return return_p;
 191                   }
 192                 }
 193               break;
 194             case RID_RETURN:
 195               return_p = true;
 196               c_parser_gimple_return_stmt (parser, seq);
 197               if (! c_parser_require (parser, CPP_SEMICOLON,
 198                                       "expected %<;%>"))
 199                 return return_p;
 200               break;
 201             default:
 202               goto expr_stmt;
 203             }
 204           break;
 205         case CPP_NAME:
 206           if (c_parser_peek_2nd_token (parser)->type == CPP_COLON)
 207             {
 208               c_parser_gimple_label (parser, seq);
 209               break;
 210             }
 211           goto expr_stmt;
 212
 213         case CPP_SEMICOLON:
 214           {
 215             /* Empty stmt.  */
 216             location_t loc = c_parser_peek_token (parser)->location;
 217             c_parser_consume_token (parser);
 218             gimple *nop = gimple_build_nop ();
 219             gimple_set_location (nop, loc);
 220             gimple_seq_add_stmt (seq, nop);
 221             break;
 222           }
 223
 224         default:
 225 expr_stmt:
 226           c_parser_gimple_statement (parser, seq);
 227           if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
 228             c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
 229         }
 230     }
 231   c_parser_consume_token (parser);
 232   return return_p;
 233 }
 234
 235 /* Parse a gimple statement.
 236
 237    gimple-statement:
 238      gimple-call-expression
 239      gimple-assign-statement
 240      gimple-phi-statement
 241
 242    gimple-assign-statement:
 243      gimple-unary-expression = gimple-assign-rhs
 244
 245    gimple-assign-rhs:
 246      gimple-cast-expression
 247      gimple-unary-expression
 248      gimple-binary-expression
 249      gimple-call-expression
 250
 251    gimple-phi-statement:
 252      identifier = __PHI ( label : gimple_primary-expression, ... )
 253
 254    gimple-call-expr:
 255      gimple-primary-expression ( argument-list )
 256
 257    gimple-cast-expression:
 258      ( type-name ) gimple-primary-expression
 259
 260 */
 261
 262 static void
 263 c_parser_gimple_statement (c_parser *parser, gimple_seq *seq)
 264 {
 265   struct c_expr lhs, rhs;
 266   gimple *assign = NULL;
 267   location_t loc;
 268   tree arg = NULL_TREE;
 269   auto_vec<tree> vargs;
 270
 271   lhs = c_parser_gimple_unary_expression (parser);
 272   loc = EXPR_LOCATION (lhs.value);
 273   rhs.set_error ();
 274
 275   /* GIMPLE call statement without LHS.  */
 276   if (c_parser_next_token_is (parser, CPP_SEMICOLON)
 277       && TREE_CODE (lhs.value) == CALL_EXPR)
 278     {
 279       gimple *call;
 280       call = gimple_build_call_from_tree (lhs.value, NULL);
 281       gimple_seq_add_stmt (seq, call);
 282       gimple_set_location (call, loc);
 283       return;
 284     }
 285
 286   /* All following cases are statements with LHS.  */
 287   if (! c_parser_require (parser, CPP_EQ, "expected %<=%>"))
 288     return;
 289
 290   /* Cast expression.  */
 291   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
 292       && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
 293     {
 294       c_parser_consume_token (parser);
 295       struct c_type_name *type_name = c_parser_type_name (parser);
 296       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
 297       if (type_name == NULL)
 298         return;
 299       /* ???  The actual type used in the cast expression is ignored as
 300          in GIMPLE it is encoded by the type of the LHS.  */
 301       rhs = c_parser_gimple_postfix_expression (parser);
 302       if (lhs.value != error_mark_node
 303           && rhs.value != error_mark_node)
 304         {
 305           enum tree_code code = NOP_EXPR;
 306           if (VECTOR_TYPE_P (TREE_TYPE (lhs.value)))
 307             {
 308               code = VIEW_CONVERT_EXPR;
 309               rhs.value = build1 (VIEW_CONVERT_EXPR,
 310                                   TREE_TYPE (lhs.value), rhs.value);
 311             }
 312           else if (FLOAT_TYPE_P (TREE_TYPE (lhs.value))
 313                    && ! FLOAT_TYPE_P (TREE_TYPE (rhs.value)))
 314             code = FLOAT_EXPR;
 315           else if (! FLOAT_TYPE_P (TREE_TYPE (lhs.value))
 316                    && FLOAT_TYPE_P (TREE_TYPE (rhs.value)))
 317             code = FIX_TRUNC_EXPR;
 318           assign = gimple_build_assign (lhs.value, code, rhs.value);
 319           gimple_seq_add_stmt (seq, assign);
 320           gimple_set_location (assign, loc);
 321           return;
 322         }
 323     }
 324
 325   /* Unary expression.  */
 326   switch (c_parser_peek_token (parser)->type)
 327     {
 328     case CPP_NAME:
 329       {
 330         tree id = c_parser_peek_token (parser)->value;
 331         if (strcmp (IDENTIFIER_POINTER (id), "__ABS") == 0
 332             || strcmp (IDENTIFIER_POINTER (id), "__ABSU") == 0)
 333           goto build_unary_expr;
 334         break;
 335       }
 336     case CPP_KEYWORD:
 337       if (c_parser_peek_token (parser)->keyword != RID_REALPART
 338           && c_parser_peek_token (parser)->keyword != RID_IMAGPART)
 339         break;
 340       /* Fallthru.  */
 341     case CPP_AND:
 342     case CPP_PLUS:
 343     case CPP_MINUS:
 344     case CPP_COMPL:
 345     case CPP_NOT:
 346     case CPP_MULT: /* pointer deref */
 347     build_unary_expr:
 348       rhs = c_parser_gimple_unary_expression (parser);
 349       if (rhs.value != error_mark_node)
 350         {
 351           assign = gimple_build_assign (lhs.value, rhs.value);
 352           gimple_set_location (assign, loc);
 353           gimple_seq_add_stmt (seq, assign);
 354         }
 355       return;
 356
 357     default:;
 358     }
 359
 360   /* GIMPLE PHI statement.  */
 361   if (c_parser_next_token_is_keyword (parser, RID_PHI))
 362     {
 363       c_parser_consume_token (parser);
 364
 365       if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
 366         return;
 367
 368       if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
 369         c_parser_consume_token (parser);
 370
 371       while (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
 372         {
 373           if (c_parser_next_token_is (parser, CPP_NAME)
 374               && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
 375             {
 376               arg = lookup_label_for_goto (loc,
 377                                            c_parser_peek_token (parser)->value);
 378               c_parser_consume_token (parser);
 379
 380               if (c_parser_next_token_is (parser, CPP_COLON))
 381                 c_parser_consume_token (parser);
 382               vargs.safe_push (arg);
 383             }
 384           else if (c_parser_next_token_is (parser, CPP_COMMA))
 385             c_parser_consume_token (parser);
 386           else
 387             {
 388               arg = c_parser_gimple_unary_expression (parser).value;
 389               vargs.safe_push (arg);
 390             }
 391         }
 392
 393       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 394                                  "expected %<)%>");
 395
 396       /* Build internal function for PHI.  */
 397       gcall *call_stmt = gimple_build_call_internal_vec (IFN_PHI, vargs);
 398       gimple_call_set_lhs (call_stmt, lhs.value);
 399       gimple_set_location (call_stmt, UNKNOWN_LOCATION);
 400       gimple_seq_add_stmt (seq, call_stmt);
 401       return;
 402     }
 403
 404   /* GIMPLE call with lhs.  */
 405   if (c_parser_next_token_is (parser, CPP_DOT)
 406       || (c_parser_next_token_is (parser, CPP_NAME)
 407           && c_parser_peek_2nd_token (parser)->type == CPP_OPEN_PAREN
 408           && lookup_name (c_parser_peek_token (parser)->value)))
 409     {
 410       rhs = c_parser_gimple_unary_expression (parser);
 411       if (rhs.value != error_mark_node)
 412         {
 413           gimple *call = gimple_build_call_from_tree (rhs.value, NULL);
 414           gimple_call_set_lhs (call, lhs.value);
 415           gimple_seq_add_stmt (seq, call);
 416           gimple_set_location (call, loc);
 417         }
 418       return;
 419     }
 420
 421   rhs = c_parser_gimple_binary_expression (parser);
 422   if (lhs.value != error_mark_node
 423       && rhs.value != error_mark_node)
 424     {
 425       /* If we parsed a comparison and the next token is a '?' then
 426          parse a conditional expression.  */
 427       if (COMPARISON_CLASS_P (rhs.value)
 428           && c_parser_next_token_is (parser, CPP_QUERY))
 429         {
 430           struct c_expr trueval, falseval;
 431           c_parser_consume_token (parser);
 432           trueval = c_parser_gimple_postfix_expression (parser);
 433           falseval.set_error ();
 434           if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
 435             falseval = c_parser_gimple_postfix_expression (parser);
 436           if (trueval.value == error_mark_node
 437               || falseval.value == error_mark_node)
 438             return;
 439           rhs.value = build3_loc (loc, COND_EXPR, TREE_TYPE (trueval.value),
 440                                   rhs.value, trueval.value, falseval.value);
 441         }
 442       assign = gimple_build_assign (lhs.value, rhs.value);
 443       gimple_seq_add_stmt (seq, assign);
 444       gimple_set_location (assign, loc);
 445     }
 446   return;
 447 }
 448
 449 /* Parse gimple binary expr.
 450
 451    gimple-binary-expression:
 452      gimple-unary-expression * gimple-unary-expression
 453      gimple-unary-expression __MULT_HIGHPART gimple-unary-expression
 454      gimple-unary-expression / gimple-unary-expression
 455      gimple-unary-expression % gimple-unary-expression
 456      gimple-unary-expression + gimple-unary-expression
 457      gimple-unary-expression - gimple-unary-expression
 458      gimple-unary-expression << gimple-unary-expression
 459      gimple-unary-expression >> gimple-unary-expression
 460      gimple-unary-expression < gimple-unary-expression
 461      gimple-unary-expression > gimple-unary-expression
 462      gimple-unary-expression <= gimple-unary-expression
 463      gimple-unary-expression >= gimple-unary-expression
 464      gimple-unary-expression == gimple-unary-expression
 465      gimple-unary-expression != gimple-unary-expression
 466      gimple-unary-expression & gimple-unary-expression
 467      gimple-unary-expression ^ gimple-unary-expression
 468      gimple-unary-expression | gimple-unary-expression
 469
 470 */
 471
 472 static c_expr
 473 c_parser_gimple_binary_expression (c_parser *parser)
 474 {
 475   /* Location of the binary operator.  */
 476   struct c_expr ret, lhs, rhs;
 477   enum tree_code code = ERROR_MARK;
 478   ret.set_error ();
 479   lhs = c_parser_gimple_postfix_expression (parser);
 480   if (c_parser_error (parser))
 481     return ret;
 482   tree ret_type = TREE_TYPE (lhs.value);
 483   switch (c_parser_peek_token (parser)->type)
 484     {
 485     case CPP_MULT:
 486       code = MULT_EXPR;
 487       break;
 488     case CPP_DIV:
 489       code = TRUNC_DIV_EXPR;
 490       break;
 491     case CPP_MOD:
 492       code = TRUNC_MOD_EXPR;
 493       break;
 494     case CPP_PLUS:
 495       if (POINTER_TYPE_P (TREE_TYPE (lhs.value)))
 496         code = POINTER_PLUS_EXPR;
 497       else
 498         code = PLUS_EXPR;
 499       break;
 500     case CPP_MINUS:
 501       code = MINUS_EXPR;
 502       break;
 503     case CPP_LSHIFT:
 504       code = LSHIFT_EXPR;
 505       break;
 506     case CPP_RSHIFT:
 507       code = RSHIFT_EXPR;
 508       break;
 509     case CPP_LESS:
 510       code = LT_EXPR;
 511       ret_type = boolean_type_node;
 512       break;
 513     case CPP_GREATER:
 514       code = GT_EXPR;
 515       ret_type = boolean_type_node;
 516       break;
 517     case CPP_LESS_EQ:
 518       code = LE_EXPR;
 519       ret_type = boolean_type_node;
 520       break;
 521     case CPP_GREATER_EQ:
 522       code = GE_EXPR;
 523       ret_type = boolean_type_node;
 524       break;
 525     case CPP_EQ_EQ:
 526       code = EQ_EXPR;
 527       ret_type = boolean_type_node;
 528       break;
 529     case CPP_NOT_EQ:
 530       code = NE_EXPR;
 531       ret_type = boolean_type_node;
 532       break;
 533     case CPP_AND:
 534       code = BIT_AND_EXPR;
 535       break;
 536     case CPP_XOR:
 537       code = BIT_XOR_EXPR;
 538       break;
 539     case CPP_OR:
 540       code = BIT_IOR_EXPR;
 541       break;
 542     case CPP_AND_AND:
 543       c_parser_error (parser, "%<&&%> not valid in GIMPLE");
 544       return ret;
 545     case CPP_OR_OR:
 546       c_parser_error (parser, "%<||%> not valid in GIMPLE");
 547       return ret;
 548     case CPP_NAME:
 549         {
 550           tree id = c_parser_peek_token (parser)->value;
 551           if (strcmp (IDENTIFIER_POINTER (id), "__MULT_HIGHPART") == 0)
 552             {
 553               code = MULT_HIGHPART_EXPR;
 554               break;
 555             }
 556         }
 557       /* Fallthru.  */
 558     default:
 559       /* Not a binary expression.  */
 560       return lhs;
 561     }
 562   location_t ret_loc = c_parser_peek_token (parser)->location;
 563   c_parser_consume_token (parser);
 564   rhs = c_parser_gimple_postfix_expression (parser);
 565   if (lhs.value != error_mark_node && rhs.value != error_mark_node)
 566     ret.value = build2_loc (ret_loc, code, ret_type, lhs.value, rhs.value);
 567   return ret;
 568 }
 569
 570 /* Parse gimple unary expression.
 571
 572    gimple-unary-expression:
 573      gimple-postfix-expression
 574      unary-operator gimple-postfix-expression
 575
 576    unary-operator: one of
 577      & * + - ~ abs_expr
 578 */
 579
 580 static c_expr
 581 c_parser_gimple_unary_expression (c_parser *parser)
 582 {
 583   struct c_expr ret, op;
 584   location_t op_loc = c_parser_peek_token (parser)->location;
 585   location_t finish;
 586   ret.set_error ();
 587   switch (c_parser_peek_token (parser)->type)
 588     {
 589     case CPP_AND:
 590       c_parser_consume_token (parser);
 591       op = c_parser_gimple_postfix_expression (parser);
 592       mark_exp_read (op.value);
 593       return parser_build_unary_op (op_loc, ADDR_EXPR, op);
 594     case CPP_MULT:
 595       {
 596         c_parser_consume_token (parser);
 597         op = c_parser_gimple_postfix_expression (parser);
 598         if (op.value == error_mark_node)
 599           return ret;
 600         if (! POINTER_TYPE_P (TREE_TYPE (op.value)))
 601           {
 602             error_at (op_loc, "expected pointer as argument of unary %<*%>");
 603             return ret;
 604           }
 605         finish = op.get_finish ();
 606         location_t combined_loc = make_location (op_loc, op_loc, finish);
 607         ret.value = build_simple_mem_ref_loc (combined_loc, op.value);
 608         TREE_SIDE_EFFECTS (ret.value)
 609           = TREE_THIS_VOLATILE (ret.value)
 610           = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op.value)));
 611         ret.src_range.m_start = op_loc;
 612         ret.src_range.m_finish = finish;
 613         return ret;
 614       }
 615     case CPP_PLUS:
 616       c_parser_consume_token (parser);
 617       op = c_parser_gimple_postfix_expression (parser);
 618       return parser_build_unary_op (op_loc, CONVERT_EXPR, op);
 619     case CPP_MINUS:
 620       c_parser_consume_token (parser);
 621       op = c_parser_gimple_postfix_expression (parser);
 622       return parser_build_unary_op (op_loc, NEGATE_EXPR, op);
 623     case CPP_COMPL:
 624       c_parser_consume_token (parser);
 625       op = c_parser_gimple_postfix_expression (parser);
 626       return parser_build_unary_op (op_loc, BIT_NOT_EXPR, op);
 627     case CPP_NOT:
 628       c_parser_error (parser, "%<!%> not valid in GIMPLE");
 629       return ret;
 630     case CPP_KEYWORD:
 631       switch (c_parser_peek_token (parser)->keyword)
 632         {
 633         case RID_REALPART:
 634           c_parser_consume_token (parser);
 635           op = c_parser_gimple_postfix_expression (parser);
 636           return parser_build_unary_op (op_loc, REALPART_EXPR, op);
 637         case RID_IMAGPART:
 638           c_parser_consume_token (parser);
 639           op = c_parser_gimple_postfix_expression (parser);
 640           return parser_build_unary_op (op_loc, IMAGPART_EXPR, op);
 641         default:
 642           return c_parser_gimple_postfix_expression (parser);
 643         }
 644     case CPP_NAME:
 645         {
 646           tree id = c_parser_peek_token (parser)->value;
 647           if (strcmp (IDENTIFIER_POINTER (id), "__ABS") == 0)
 648             {
 649               c_parser_consume_token (parser);
 650               op = c_parser_gimple_postfix_expression (parser);
 651               return parser_build_unary_op (op_loc, ABS_EXPR, op);
 652             }
 653           else if (strcmp (IDENTIFIER_POINTER (id), "__ABSU") == 0)
 654             {
 655               c_parser_consume_token (parser);
 656               op = c_parser_gimple_postfix_expression (parser);
 657               return parser_build_unary_op (op_loc, ABSU_EXPR, op);
 658             }
 659           else
 660             return c_parser_gimple_postfix_expression (parser);
 661         }
 662     default:
 663       return c_parser_gimple_postfix_expression (parser);
 664     }
 665 }
 666
 667 /* Decompose ID into base name (ID until ver_offset) and VERSION.  Return
 668    true if ID matches a SSA name.  */
 669
 670 static bool
 671 c_parser_parse_ssa_name_id (tree id, unsigned *version, unsigned *ver_offset)
 672 {
 673   const char *token = IDENTIFIER_POINTER (id);
 674   const char *var_version = strrchr (token, '_');
 675   if (! var_version)
 676     return false;
 677
 678   *ver_offset = var_version - token;
 679   for (const char *p = var_version + 1; *p; ++p)
 680     if (! ISDIGIT (*p))
 681       return false;
 682   *version = atoi (var_version + 1);
 683   return *version > 0;
 684 }
 685
 686 /* Get at the actual SSA name ID with VERSION starting at VER_OFFSET.
 687    TYPE is the type if the SSA name is being declared.  */
 688
 689 static tree
 690 c_parser_parse_ssa_name (c_parser *parser,
 691                          tree id, tree type, unsigned version,
 692                          unsigned ver_offset)
 693 {
 694   tree name = NULL_TREE;
 695   const char *token = IDENTIFIER_POINTER (id);
 696
 697   if (ver_offset == 0)
 698     {
 699       /* Anonymous unnamed SSA name.  */
 700       if (version < num_ssa_names)
 701         name = ssa_name (version);
 702       if (! name)
 703         {
 704           if (! type)
 705             {
 706               c_parser_error (parser, "SSA name undeclared");
 707               return error_mark_node;
 708             }
 709           name = make_ssa_name_fn (cfun, type, NULL, version);
 710         }
 711     }
 712   else
 713     {
 714       if (version < num_ssa_names)
 715         name = ssa_name (version);
 716       if (! name)
 717         {
 718           /* Separate var name from version.  */
 719           char *var_name = XNEWVEC (char, ver_offset + 1);
 720           memcpy (var_name, token, ver_offset);
 721           var_name[ver_offset] = '\0';
 722           /* lookup for parent decl.  */
 723           id = get_identifier (var_name);
 724           tree parent = lookup_name (id);
 725           XDELETEVEC (var_name);
 726           if (! parent || parent == error_mark_node)
 727             {
 728               c_parser_error (parser, "base variable or SSA name undeclared");
 729               return error_mark_node;
 730             }
 731           if (!(VAR_P (parent)
 732                 || TREE_CODE (parent) == PARM_DECL
 733                 || TREE_CODE (parent) == RESULT_DECL))
 734             {
 735               error ("invalid base %qE for SSA name", parent);
 736               return error_mark_node;
 737             }
 738           if (VECTOR_TYPE_P (TREE_TYPE (parent))
 739               || TREE_CODE (TREE_TYPE (parent)) == COMPLEX_TYPE)
 740             DECL_GIMPLE_REG_P (parent) = 1;
 741           name = make_ssa_name_fn (cfun, parent,
 742                                    gimple_build_nop (), version);
 743         }
 744     }
 745
 746   return name;
 747 }
 748
 749 /* Parse a gimple call to an internal function.
 750
 751    gimple-call-internal:
 752      . identifier ( gimple-argument-expression-list[opt] )  */
 753
 754 static struct c_expr
 755 c_parser_gimple_call_internal (c_parser *parser)
 756 {
 757   struct c_expr expr;
 758   expr.set_error ();
 759
 760   gcc_assert (c_parser_next_token_is (parser, CPP_DOT));
 761   c_parser_consume_token (parser);
 762   location_t loc = c_parser_peek_token (parser)->location;
 763   if (!c_parser_next_token_is (parser, CPP_NAME)
 764       || c_parser_peek_token (parser)->id_kind != C_ID_ID)
 765     {
 766       c_parser_error (parser, "expecting internal function name");
 767       return expr;
 768     }
 769   tree id = c_parser_peek_token (parser)->value;
 770   internal_fn ifn = lookup_internal_fn (IDENTIFIER_POINTER (id));
 771   c_parser_consume_token (parser);
 772   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
 773     {
 774       auto_vec<tree> exprlist;
 775       if (!c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
 776         c_parser_gimple_expr_list (parser, &exprlist);
 777       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
 778       if (ifn == IFN_LAST)
 779         error_at (loc, "unknown internal function %qE", id);
 780       else
 781         {
 782           expr.value = build_call_expr_internal_loc_array
 783             (loc, ifn, void_type_node, exprlist.length (),
 784              exprlist.address ());
 785           expr.original_code = ERROR_MARK;
 786           expr.original_type = NULL;
 787         }
 788     }
 789   return expr;
 790 }
 791
 792 /* Parse gimple postfix expression.
 793
 794    gimple-postfix-expression:
 795      gimple-primary-expression
 796      gimple-primary-expression [ gimple-primary-expression ]
 797      gimple-primary-expression ( gimple-argument-expression-list[opt] )
 798      gimple-postfix-expression . identifier
 799      gimple-postfix-expression -> identifier
 800
 801    gimple-argument-expression-list:
 802      gimple-unary-expression
 803      gimple-argument-expression-list , gimple-unary-expression
 804
 805    gimple-primary-expression:
 806      identifier
 807      constant
 808      string-literal
 809      constructor
 810      gimple-call-internal
 811
 812 */
 813
 814 static struct c_expr
 815 c_parser_gimple_postfix_expression (c_parser *parser)
 816 {
 817   location_t loc = c_parser_peek_token (parser)->location;
 818   source_range tok_range = c_parser_peek_token (parser)->get_range ();
 819   struct c_expr expr;
 820   expr.set_error ();
 821   switch (c_parser_peek_token (parser)->type)
 822     {
 823     case CPP_NUMBER:
 824       expr.value = c_parser_peek_token (parser)->value;
 825       set_c_expr_source_range (&expr, tok_range);
 826       loc = c_parser_peek_token (parser)->location;
 827       c_parser_consume_token (parser);
 828       break;
 829     case CPP_CHAR:
 830     case CPP_CHAR16:
 831     case CPP_CHAR32:
 832     case CPP_WCHAR:
 833       expr.value = c_parser_peek_token (parser)->value;
 834       set_c_expr_source_range (&expr, tok_range);
 835       c_parser_consume_token (parser);
 836       break;
 837     case CPP_STRING:
 838     case CPP_STRING16:
 839     case CPP_STRING32:
 840     case CPP_WSTRING:
 841     case CPP_UTF8STRING:
 842       expr.value = c_parser_peek_token (parser)->value;
 843       set_c_expr_source_range (&expr, tok_range);
 844       expr.original_code = STRING_CST;
 845       c_parser_consume_token (parser);
 846       break;
 847     case CPP_DOT:
 848       expr = c_parser_gimple_call_internal (parser);
 849       break;
 850     case CPP_NAME:
 851       if (c_parser_peek_token (parser)->id_kind == C_ID_ID)
 852         {
 853           tree id = c_parser_peek_token (parser)->value;
 854           if (strcmp (IDENTIFIER_POINTER (id), "__MEM") == 0)
 855             {
 856               /* __MEM '<' type-name [ ',' number ] '>'
 857                        '(' [ '(' type-name ')' ] unary-expression
 858                            [ '+' number ] ')'  */
 859               location_t loc = c_parser_peek_token (parser)->location;
 860               c_parser_consume_token (parser);
 861               struct c_type_name *type_name = NULL;
 862               tree alignment = NULL_TREE;
 863               if (c_parser_require (parser, CPP_LESS, "expected %<<%>"))
 864                 {
 865                   type_name = c_parser_type_name (parser);
 866                   /* Optional alignment.  */
 867                   if (c_parser_next_token_is (parser, CPP_COMMA))
 868                     {
 869                       c_parser_consume_token (parser);
 870                       alignment
 871                         = c_parser_gimple_postfix_expression (parser).value;
 872                     }
 873                   c_parser_skip_until_found (parser,
 874                                              CPP_GREATER, "expected %<>%>");
 875                 }
 876               struct c_expr ptr;
 877               ptr.value = error_mark_node;
 878               tree alias_off = NULL_TREE;
 879               if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
 880                 {
 881                   tree alias_type = NULL_TREE;
 882                   /* Optional alias-type cast.  */
 883                   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
 884                     {
 885                       c_parser_consume_token (parser);
 886                       struct c_type_name *alias_type_name
 887                         = c_parser_type_name (parser);
 888                       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 889                                                  "expected %<)%>");
 890                       if (alias_type_name)
 891                         {
 892                           tree tem;
 893                           alias_type = groktypename (alias_type_name,
 894                                                      &tem, NULL);
 895                         }
 896                     }
 897                   ptr = c_parser_gimple_unary_expression (parser);
 898                   if (ptr.value == error_mark_node
 899                       || ! POINTER_TYPE_P (TREE_TYPE (ptr.value)))
 900                     {
 901                       if (ptr.value != error_mark_node)
 902                         error_at (ptr.get_start (),
 903                                   "invalid type of %<__MEM%> operand");
 904                       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 905                                                  "expected %<)%>");
 906                       return expr;
 907                     }
 908                   if (! alias_type)
 909                     alias_type = TREE_TYPE (ptr.value);
 910                   /* Optional constant offset.  */
 911                   if (c_parser_next_token_is (parser, CPP_PLUS))
 912                     {
 913                       c_parser_consume_token (parser);
 914                       alias_off
 915                         = c_parser_gimple_postfix_expression (parser).value;
 916                       alias_off = fold_convert (alias_type, alias_off);
 917                     }
 918                   if (! alias_off)
 919                     alias_off = build_int_cst (alias_type, 0);
 920                   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 921                                              "expected %<)%>");
 922                 }
 923               if (! type_name || c_parser_error (parser))
 924                 {
 925                   c_parser_set_error (parser, false);
 926                   return expr;
 927                 }
 928               tree tem = NULL_TREE;
 929               tree type = groktypename (type_name, &tem, NULL);
 930               if (alignment)
 931                 type = build_aligned_type (type, tree_to_uhwi (alignment));
 932               expr.value = build2_loc (loc, MEM_REF,
 933                                        type, ptr.value, alias_off);
 934               break;
 935             }
 936           else if (strcmp (IDENTIFIER_POINTER (id), "_Literal") == 0)
 937             {
 938               /* _Literal '(' type-name ')' ( [ '-' ] constant | constructor ) */
 939               c_parser_consume_token (parser);
 940               tree type = NULL_TREE;
 941               if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
 942                 {
 943                   struct c_type_name *type_name = c_parser_type_name (parser);
 944                   tree tem;
 945                   if (type_name)
 946                     type = groktypename (type_name, &tem, NULL);
 947                   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 948                                              "expected %<)%>");
 949                 }
 950               if (! type)
 951                 {
 952                   c_parser_error (parser, "invalid _Literal");
 953                   return expr;
 954                 }
 955               if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
 956                 {
 957                   c_parser_consume_token (parser);
 958                   if (!AGGREGATE_TYPE_P (type)
 959                       && !VECTOR_TYPE_P (type))
 960                     {
 961                       c_parser_error (parser, "invalid type for _Literal with "
 962                                       "constructor");
 963                       c_parser_skip_until_found (parser, CPP_CLOSE_BRACE,
 964                                                  "expected %<}%>");
 965                       return expr;
 966                     }
 967                   vec<constructor_elt, va_gc> *v = NULL;
 968                   bool constant_p = true;
 969                   if (VECTOR_TYPE_P (type)
 970                       && !c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
 971                     {
 972                       vec_alloc (v, TYPE_VECTOR_SUBPARTS (type).to_constant ());
 973                       do
 974                         {
 975                           tree val
 976                             = c_parser_gimple_postfix_expression (parser).value;
 977                           if (! val
 978                               || val == error_mark_node
 979                               || (! CONSTANT_CLASS_P (val)
 980                                   && ! SSA_VAR_P (val)))
 981                             {
 982                               c_parser_error (parser, "invalid _Literal");
 983                               return expr;
 984                             }
 985                           CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, val);
 986                           if (! CONSTANT_CLASS_P (val))
 987                             constant_p = false;
 988                           if (c_parser_next_token_is (parser, CPP_COMMA))
 989                             c_parser_consume_token (parser);
 990                           else
 991                             break;
 992                         }
 993                       while (1);
 994                     }
 995                   if (c_parser_require (parser, CPP_CLOSE_BRACE,
 996                                         "expected %<}%>"))
 997                     {
 998                       if (v && constant_p)
 999                         expr.value = build_vector_from_ctor (type, v);
1000                       else
1001                         expr.value = build_constructor (type, v);
1002                     }
1003                   else
1004                     {
1005                       c_parser_skip_until_found (parser, CPP_CLOSE_BRACE,
1006                                                  "expected %<}%>");
1007                       return expr;
1008                     }
1009                 }
1010               else
1011                 {
1012                   bool neg_p;
1013                   if ((neg_p = c_parser_next_token_is (parser, CPP_MINUS)))
1014                     c_parser_consume_token (parser);
1015                   tree val = c_parser_gimple_postfix_expression (parser).value;
1016                   if (! val
1017                       || val == error_mark_node
1018                       || ! CONSTANT_CLASS_P (val))
1019                     {
1020                       c_parser_error (parser, "invalid _Literal");
1021                       return expr;
1022                     }
1023                   if (neg_p)
1024                     {
1025                       val = const_unop (NEGATE_EXPR, TREE_TYPE (val), val);
1026                       if (! val)
1027                         {
1028                           c_parser_error (parser, "invalid _Literal");
1029                           return expr;
1030                         }
1031                     }
1032                   expr.value = fold_convert (type, val);
1033                 }
1034               return expr;
1035             }
1036
1037           /* SSA name.  */
1038           unsigned version, ver_offset;
1039           if (! lookup_name (id)
1040               && c_parser_parse_ssa_name_id (id, &version, &ver_offset))
1041             {
1042               c_parser_consume_token (parser);
1043               expr.value = c_parser_parse_ssa_name (parser, id, NULL_TREE,
1044                                                     version, ver_offset);
1045               if (expr.value == error_mark_node)
1046                 return expr;
1047               set_c_expr_source_range (&expr, tok_range);
1048               /* For default definition SSA names.  */
1049               if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
1050                   && c_parser_peek_2nd_token (parser)->type == CPP_NAME
1051                   && strcmp ("D",
1052                              IDENTIFIER_POINTER
1053                                (c_parser_peek_2nd_token (parser)->value)) == 0
1054                   && c_parser_peek_nth_token (parser, 3)->type == CPP_CLOSE_PAREN)
1055                 {
1056                   c_parser_consume_token (parser);
1057                   c_parser_consume_token (parser);
1058                   c_parser_consume_token (parser);
1059                   if (! SSA_NAME_IS_DEFAULT_DEF (expr.value))
1060                     {
1061                       if (!SSA_NAME_VAR (expr.value))
1062                         {
1063                           error_at (loc, "anonymous SSA name cannot have"
1064                                     " default definition");
1065                           expr.value = error_mark_node;
1066                           return expr;
1067                         }
1068                       set_ssa_default_def (cfun, SSA_NAME_VAR (expr.value),
1069                                            expr.value);
1070                       SSA_NAME_DEF_STMT (expr.value) = gimple_build_nop ();
1071                     }
1072                 }
1073             }
1074           else
1075             {
1076               c_parser_consume_token (parser);
1077               expr.value
1078                 = build_external_ref (loc, id,
1079                                       (c_parser_peek_token (parser)->type
1080                                        == CPP_OPEN_PAREN), &expr.original_type);
1081               set_c_expr_source_range (&expr, tok_range);
1082             }
1083           break;
1084         }
1085       else
1086         {
1087           c_parser_error (parser, "expected expression");
1088           expr.set_error ();
1089           break;
1090         }
1091       break;
1092     default:
1093       c_parser_error (parser, "expected expression");
1094       expr.set_error ();
1095       break;
1096     }
1097   return c_parser_gimple_postfix_expression_after_primary
1098     (parser, EXPR_LOC_OR_LOC (expr.value, loc), expr);
1099 }
1100
1101 /* Parse a gimple postfix expression after the initial primary or compound
1102    literal.  */
1103
1104 static struct c_expr
1105 c_parser_gimple_postfix_expression_after_primary (c_parser *parser,
1106                                                   location_t expr_loc,
1107                                                   struct c_expr expr)
1108 {
1109   location_t start;
1110   location_t finish;
1111   tree ident;
1112   location_t comp_loc;
1113
1114   while (true)
1115     {
1116       location_t op_loc = c_parser_peek_token (parser)->location;
1117       switch (c_parser_peek_token (parser)->type)
1118         {
1119         case CPP_OPEN_SQUARE:
1120           {
1121             c_parser_consume_token (parser);
1122             tree idx = c_parser_gimple_unary_expression (parser).value;
1123
1124             if (! c_parser_require (parser, CPP_CLOSE_SQUARE, "expected %<]%>"))
1125               {
1126                 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
1127                 break;
1128               }
1129
1130             start = expr.get_start ();
1131             finish = c_parser_tokens_buf (parser, 0)->location;
1132             expr.value = build_array_ref (op_loc, expr.value, idx);
1133             set_c_expr_source_range (&expr, start, finish);
1134
1135             expr.original_code = ERROR_MARK;
1136             expr.original_type = NULL;
1137             break;
1138           }
1139         case CPP_OPEN_PAREN:
1140           {
1141             /* Function call.  */
1142             c_parser_consume_token (parser);
1143             auto_vec<tree> exprlist;
1144             if (! c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
1145               c_parser_gimple_expr_list (parser, &exprlist);
1146             c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
1147                                        "expected %<)%>");
1148             expr.value = build_call_array_loc
1149                 (expr_loc, TREE_TYPE (TREE_TYPE (expr.value)),
1150                  expr.value, exprlist.length (), exprlist.address ());
1151             expr.original_code = ERROR_MARK;
1152             expr.original_type = NULL;
1153             break;
1154           }
1155         case CPP_DOT:
1156           {
1157             /* Structure element reference.  */
1158             c_parser_consume_token (parser);
1159             if (c_parser_next_token_is (parser, CPP_NAME))
1160               {
1161                 c_token *comp_tok = c_parser_peek_token (parser);
1162                 ident = comp_tok->value;
1163                 comp_loc = comp_tok->location;
1164               }
1165             else
1166               {
1167                 c_parser_error (parser, "expected identifier");
1168                 expr.set_error ();
1169                 expr.original_code = ERROR_MARK;
1170                 expr.original_type = NULL;
1171                 return expr;
1172               }
1173             start = expr.get_start ();
1174             finish = c_parser_peek_token (parser)->get_finish ();
1175             c_parser_consume_token (parser);
1176             expr.value = build_component_ref (op_loc, expr.value, ident,
1177                                               comp_loc);
1178             set_c_expr_source_range (&expr, start, finish);
1179             expr.original_code = ERROR_MARK;
1180             if (TREE_CODE (expr.value) != COMPONENT_REF)
1181               expr.original_type = NULL;
1182             else
1183               {
1184                 /* Remember the original type of a bitfield.  */
1185                 tree field = TREE_OPERAND (expr.value, 1);
1186                 if (TREE_CODE (field) != FIELD_DECL)
1187                   expr.original_type = NULL;
1188                 else
1189                   expr.original_type = DECL_BIT_FIELD_TYPE (field);
1190               }
1191             break;
1192           }
1193         case CPP_DEREF:
1194           {
1195             /* Structure element reference.  */
1196             c_parser_consume_token (parser);
1197             if (c_parser_next_token_is (parser, CPP_NAME))
1198               {
1199                 c_token *comp_tok = c_parser_peek_token (parser);
1200                 ident = comp_tok->value;
1201                 comp_loc = comp_tok->location;
1202               }
1203             else
1204               {
1205                 c_parser_error (parser, "expected identifier");
1206                 expr.set_error ();
1207                 expr.original_code = ERROR_MARK;
1208                 expr.original_type = NULL;
1209                 return expr;
1210               }
1211             start = expr.get_start ();
1212             finish = c_parser_peek_token (parser)->get_finish ();
1213             c_parser_consume_token (parser);
1214             expr.value = build_component_ref (op_loc,
1215                                               build_simple_mem_ref_loc
1216                                                 (op_loc, expr.value),
1217                                               ident, comp_loc);
1218             set_c_expr_source_range (&expr, start, finish);
1219             expr.original_code = ERROR_MARK;
1220             if (TREE_CODE (expr.value) != COMPONENT_REF)
1221               expr.original_type = NULL;
1222             else
1223               {
1224                 /* Remember the original type of a bitfield.  */
1225                 tree field = TREE_OPERAND (expr.value, 1);
1226                 if (TREE_CODE (field) != FIELD_DECL)
1227                   expr.original_type = NULL;
1228                 else
1229                   expr.original_type = DECL_BIT_FIELD_TYPE (field);
1230               }
1231             break;
1232           }
1233         default:
1234           return expr;
1235         }
1236     }
1237 }
1238
1239 /* Parse expression list.
1240
1241    gimple-expr-list:
1242      gimple-unary-expression
1243      gimple-expr-list , gimple-unary-expression
1244
1245  */
1246
1247 static void
1248 c_parser_gimple_expr_list (c_parser *parser, vec<tree> *ret)
1249 {
1250   struct c_expr expr;
1251
1252   expr = c_parser_gimple_unary_expression (parser);
1253   ret->safe_push (expr.value);
1254   while (c_parser_next_token_is (parser, CPP_COMMA))
1255     {
1256       c_parser_consume_token (parser);
1257       expr = c_parser_gimple_unary_expression (parser);
1258       ret->safe_push (expr.value);
1259     }
1260 }
1261
1262 /* Parse gimple label.
1263
1264    gimple-label:
1265      identifier :
1266      case constant-expression :
1267      default :
1268
1269 */
1270
1271 static void
1272 c_parser_gimple_label (c_parser *parser, gimple_seq *seq)
1273 {
1274   tree name = c_parser_peek_token (parser)->value;
1275   location_t loc1 = c_parser_peek_token (parser)->location;
1276   gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
1277   c_parser_consume_token (parser);
1278   gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
1279   c_parser_consume_token (parser);
1280   tree label = define_label (loc1, name);
1281   gimple_seq_add_stmt (seq, gimple_build_label (label));
1282   return;
1283 }
1284
1285 /* Parse gimple/RTL pass list.
1286
1287    gimple-or-rtl-pass-list:
1288      startwith("pass-name")
1289  */
1290
1291 char *
1292 c_parser_gimple_or_rtl_pass_list (c_parser *parser)
1293 {
1294   char *pass = NULL;
1295
1296   /* Accept __GIMPLE/__RTL.  */
1297   if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
1298     return NULL;
1299   c_parser_consume_token (parser);
1300
1301   if (c_parser_next_token_is (parser, CPP_NAME))
1302     {
1303       const char *op = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
1304       c_parser_consume_token (parser);
1305       if (! strcmp (op, "startwith"))
1306         {
1307           if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1308             return NULL;
1309           if (c_parser_next_token_is_not (parser, CPP_STRING))
1310             {
1311               error_at (c_parser_peek_token (parser)->location,
1312                         "expected pass name");
1313               return NULL;
1314             }
1315           pass = xstrdup (TREE_STRING_POINTER
1316                                 (c_parser_peek_token (parser)->value));
1317           c_parser_consume_token (parser);
1318           if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
1319             return NULL;
1320         }
1321       else
1322         {
1323           error_at (c_parser_peek_token (parser)->location,
1324                     "invalid operation");
1325           return NULL;
1326         }
1327     }
1328
1329   if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
1330     return NULL;
1331
1332   return pass;
1333 }
1334
1335 /* Parse gimple local declaration.
1336
1337    declaration-specifiers:
1338      storage-class-specifier declaration-specifiers[opt]
1339      type-specifier declaration-specifiers[opt]
1340      type-qualifier declaration-specifiers[opt]
1341      function-specifier declaration-specifiers[opt]
1342      alignment-specifier declaration-specifiers[opt]
1343
1344    storage-class-specifier:
1345      typedef
1346      extern
1347      static
1348      auto
1349      register
1350
1351    type-specifier:
1352      void
1353      char
1354      short
1355      int
1356      long
1357      float
1358      double
1359      signed
1360      unsigned
1361      _Bool
1362      _Complex
1363
1364    type-qualifier:
1365      const
1366      restrict
1367      volatile
1368      address-space-qualifier
1369      _Atomic
1370
1371  */
1372
1373 static void
1374 c_parser_gimple_declaration (c_parser *parser)
1375 {
1376   struct c_declarator *declarator;
1377   struct c_declspecs *specs = build_null_declspecs ();
1378   c_parser_declspecs (parser, specs, true, true, true,
1379                       true, true, cla_nonabstract_decl);
1380   finish_declspecs (specs);
1381
1382   /* Provide better error recovery.  Note that a type name here is usually
1383      better diagnosed as a redeclaration.  */
1384   if (c_parser_next_token_starts_declspecs (parser)
1385       && ! c_parser_next_token_is (parser, CPP_NAME))
1386     {
1387       c_parser_error (parser, "expected %<;%>");
1388       c_parser_set_error (parser, false);
1389       return;
1390     }
1391
1392   bool dummy = false;
1393   declarator = c_parser_declarator (parser,
1394                                     specs->typespec_kind != ctsk_none,
1395                                     C_DTR_NORMAL, &dummy);
1396
1397   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1398     {
1399       /* Handle SSA name decls specially, they do not go into the identifier
1400          table but we simply build the SSA name for later lookup.  */
1401       unsigned version, ver_offset;
1402       if (declarator->kind == cdk_id
1403           && is_gimple_reg_type (specs->type)
1404           && c_parser_parse_ssa_name_id (declarator->u.id,
1405                                          &version, &ver_offset)
1406           /* The following restricts it to unnamed anonymous SSA names
1407              which fails parsing of named ones in dumps (we could
1408              decide to not dump their name for -gimple).  */
1409           && ver_offset == 0)
1410         c_parser_parse_ssa_name (parser, declarator->u.id, specs->type,
1411                                  version, ver_offset);
1412       else
1413         {
1414           tree postfix_attrs = NULL_TREE;
1415           tree all_prefix_attrs = specs->attrs;
1416           specs->attrs = NULL;
1417           tree decl = start_decl (declarator, specs, false,
1418                                   chainon (postfix_attrs, all_prefix_attrs));
1419           if (decl)
1420             finish_decl (decl, UNKNOWN_LOCATION, NULL_TREE, NULL_TREE,
1421                          NULL_TREE);
1422         }
1423     }
1424   else
1425     {
1426       c_parser_error (parser, "expected %<;%>");
1427       return;
1428     }
1429 }
1430
1431 /* Parse gimple goto statement.  */
1432
1433 static void
1434 c_parser_gimple_goto_stmt (location_t loc, tree label, gimple_seq *seq)
1435 {
1436   tree decl = lookup_label_for_goto (loc, label);
1437   gimple_seq_add_stmt (seq, gimple_build_goto (decl));
1438   return;
1439 }
1440
1441 /* Parse a parenthesized condition.
1442    gimple-condition:
1443      ( gimple-binary-expression )    */
1444
1445 static tree
1446 c_parser_gimple_paren_condition (c_parser *parser)
1447 {
1448   if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1449     return error_mark_node;
1450   tree cond = c_parser_gimple_binary_expression (parser).value;
1451   if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
1452     return error_mark_node;
1453   return cond;
1454 }
1455
1456 /* Parse gimple if-else statement.
1457
1458    if-statement:
1459      if ( gimple-binary-expression ) gimple-goto-statement
1460      if ( gimple-binary-expression ) gimple-goto-statement \
1461                                         else gimple-goto-statement
1462  */
1463
1464 static void
1465 c_parser_gimple_if_stmt (c_parser *parser, gimple_seq *seq)
1466 {
1467   tree t_label, f_label, label;
1468   location_t loc;
1469   c_parser_consume_token (parser);
1470   tree cond = c_parser_gimple_paren_condition (parser);
1471
1472   if (c_parser_next_token_is_keyword (parser, RID_GOTO))
1473     {
1474       loc = c_parser_peek_token (parser)->location;
1475       c_parser_consume_token (parser);
1476       if (! c_parser_next_token_is (parser, CPP_NAME))
1477         {
1478           c_parser_error (parser, "expected label");
1479           return;
1480         }
1481       label = c_parser_peek_token (parser)->value;
1482       c_parser_consume_token (parser);
1483       t_label = lookup_label_for_goto (loc, label);
1484       if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
1485         return;
1486     }
1487   else
1488     {
1489       c_parser_error (parser, "expected goto expression");
1490       return;
1491     }
1492
1493   if (c_parser_next_token_is_keyword (parser, RID_ELSE))
1494     c_parser_consume_token (parser);
1495   else
1496     {
1497       c_parser_error (parser, "expected else statement");
1498       return;
1499     }
1500
1501   if (c_parser_next_token_is_keyword (parser, RID_GOTO))
1502     {
1503       loc = c_parser_peek_token (parser)->location;
1504       c_parser_consume_token (parser);
1505       if (! c_parser_next_token_is (parser, CPP_NAME))
1506         {
1507           c_parser_error (parser, "expected label");
1508           return;
1509         }
1510       label = c_parser_peek_token (parser)->value;
1511       f_label = lookup_label_for_goto (loc, label);
1512       c_parser_consume_token (parser);
1513       if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
1514         return;
1515     }
1516   else
1517     {
1518       c_parser_error (parser, "expected goto expression");
1519       return;
1520     }
1521
1522   if (cond != error_mark_node)
1523     gimple_seq_add_stmt (seq, gimple_build_cond_from_tree (cond, t_label,
1524                                                            f_label));
1525 }
1526
1527 /* Parse gimple switch-statement.
1528
1529    gimple-switch-statement:
1530      switch (gimple-postfix-expression) gimple-case-statement
1531
1532    gimple-case-statement:
1533      gimple-case-statement
1534      gimple-label-statement : gimple-goto-statment
1535 */
1536
1537 static void
1538 c_parser_gimple_switch_stmt (c_parser *parser, gimple_seq *seq)
1539 {
1540   c_expr cond_expr;
1541   tree case_label, label;
1542   auto_vec<tree> labels;
1543   tree default_label = NULL_TREE;
1544   gimple_seq switch_body = NULL;
1545   c_parser_consume_token (parser);
1546
1547   if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1548     return;
1549   cond_expr = c_parser_gimple_postfix_expression (parser);
1550   if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
1551     return;
1552
1553   if (! c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
1554     return;
1555
1556   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
1557     {
1558       if (c_parser_next_token_is (parser, CPP_EOF))
1559         {
1560           c_parser_error (parser, "expected statement");
1561           return;
1562         }
1563
1564       switch (c_parser_peek_token (parser)->keyword)
1565         {
1566         case RID_CASE:
1567           {
1568             c_expr exp1;
1569             location_t loc = c_parser_peek_token (parser)->location;
1570             c_parser_consume_token (parser);
1571
1572             if (c_parser_next_token_is (parser, CPP_NAME)
1573                 || c_parser_peek_token (parser)->type == CPP_NUMBER)
1574               exp1 = c_parser_gimple_postfix_expression (parser);
1575             else
1576               {
1577                 c_parser_error (parser, "expected expression");
1578                 return;
1579               }
1580
1581             if (c_parser_next_token_is (parser, CPP_COLON))
1582               {
1583                 c_parser_consume_token (parser);
1584                 if (c_parser_next_token_is (parser, CPP_NAME))
1585                   {
1586                     label = c_parser_peek_token (parser)->value;
1587                     c_parser_consume_token (parser);
1588                     tree decl = lookup_label_for_goto (loc, label);
1589                     case_label = build_case_label (exp1.value, NULL_TREE,
1590                                                    decl);
1591                     labels.safe_push (case_label);
1592                     if (! c_parser_require (parser, CPP_SEMICOLON,
1593                                             "expected %<;%>"))
1594                       return;
1595                   }
1596                 else if (! c_parser_require (parser, CPP_NAME,
1597                                              "expected label"))
1598                   return;
1599               }
1600             else if (! c_parser_require (parser, CPP_SEMICOLON,
1601                                          "expected %<:%>"))
1602               return;
1603             break;
1604           }
1605         case RID_DEFAULT:
1606           {
1607             location_t loc = c_parser_peek_token (parser)->location;
1608             c_parser_consume_token (parser);
1609             if (c_parser_next_token_is (parser, CPP_COLON))
1610               {
1611                 c_parser_consume_token (parser);
1612                 if (c_parser_next_token_is (parser, CPP_NAME))
1613                   {
1614                     label = c_parser_peek_token (parser)->value;
1615                     c_parser_consume_token (parser);
1616                     tree decl = lookup_label_for_goto (loc, label);
1617                     default_label = build_case_label (NULL_TREE, NULL_TREE,
1618                                                       decl);
1619                     if (! c_parser_require (parser, CPP_SEMICOLON,
1620                                             "expected %<;%>"))
1621                       return;
1622                   }
1623                 else if (! c_parser_require (parser, CPP_NAME,
1624                                              "expected label"))
1625                   return;
1626               }
1627             else if (! c_parser_require (parser, CPP_SEMICOLON,
1628                                          "expected %<:%>"))
1629               return;
1630             break;
1631           }
1632         case RID_GOTO:
1633           {
1634             location_t loc = c_parser_peek_token (parser)->location;
1635             c_parser_consume_token (parser);
1636             if (c_parser_next_token_is (parser, CPP_NAME))
1637               {
1638                 c_parser_gimple_goto_stmt (loc,
1639                                            c_parser_peek_token
1640                                            (parser)->value,
1641                                            &switch_body);
1642                 c_parser_consume_token (parser);
1643                 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1644                   c_parser_consume_token (parser);
1645                 else
1646                   {
1647                     c_parser_error (parser, "expected semicolon");
1648                     return;
1649                   }
1650               }
1651             else if (! c_parser_require (parser, CPP_NAME,
1652                                          "expected label"))
1653               return;
1654             break;
1655           }
1656         default:
1657           c_parser_error (parser, "expected case label or goto statement");
1658           return;
1659         }
1660
1661     }
1662   if (! c_parser_require (parser, CPP_CLOSE_BRACE, "expected %<}%>"))
1663     return;
1664
1665   if (cond_expr.value != error_mark_node)
1666     {
1667       gimple_seq_add_stmt (seq, gimple_build_switch (cond_expr.value,
1668                                                      default_label, labels));
1669       gimple_seq_add_seq (seq, switch_body);
1670     }
1671 }
1672
1673 /* Parse gimple return statement.  */
1674
1675 static void
1676 c_parser_gimple_return_stmt (c_parser *parser, gimple_seq *seq)
1677 {
1678   location_t loc = c_parser_peek_token (parser)->location;
1679   gimple *ret = NULL;
1680   c_parser_consume_token (parser);
1681   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1682     {
1683       c_finish_gimple_return (loc, NULL_TREE);
1684       ret = gimple_build_return (NULL);
1685       gimple_seq_add_stmt (seq, ret);
1686     }
1687   else
1688     {
1689       location_t xloc = c_parser_peek_token (parser)->location;
1690       c_expr expr = c_parser_gimple_unary_expression (parser);
1691       if (expr.value != error_mark_node)
1692         {
1693           c_finish_gimple_return (xloc, expr.value);
1694           ret = gimple_build_return (expr.value);
1695           gimple_seq_add_stmt (seq, ret);
1696         }
1697     }
1698 }
1699
1700 /* Support function for c_parser_gimple_return_stmt.  */
1701
1702 static void
1703 c_finish_gimple_return (location_t loc, tree retval)
1704 {
1705   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
1706
1707   /* Use the expansion point to handle cases such as returning NULL
1708      in a function returning void.  */
1709   location_t xloc = expansion_point_location_if_in_system_header (loc);
1710
1711   if (TREE_THIS_VOLATILE (current_function_decl))
1712     warning_at (xloc, 0,
1713                 "function declared %<noreturn%> has a %<return%> statement");
1714
1715   if (! retval)
1716     current_function_returns_null = 1;
1717   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
1718     {
1719       current_function_returns_null = 1;
1720       if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
1721         {
1722           error_at
1723             (xloc, "%<return%> with a value, in function returning void");
1724           inform (DECL_SOURCE_LOCATION (current_function_decl),
1725                   "declared here");
1726         }
1727     }
1728   else if (TREE_CODE (valtype) != TREE_CODE (TREE_TYPE (retval)))
1729     {
1730       error_at
1731         (xloc, "invalid conversion in return statement");
1732       inform (DECL_SOURCE_LOCATION (current_function_decl),
1733               "declared here");
1734     }
1735   return;
1736 }