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      gimple-call-internal
 810
 811 */
 812
 813 static struct c_expr
 814 c_parser_gimple_postfix_expression (c_parser *parser)
 815 {
 816   location_t loc = c_parser_peek_token (parser)->location;
 817   source_range tok_range = c_parser_peek_token (parser)->get_range ();
 818   struct c_expr expr;
 819   expr.set_error ();
 820   switch (c_parser_peek_token (parser)->type)
 821     {
 822     case CPP_NUMBER:
 823       expr.value = c_parser_peek_token (parser)->value;
 824       set_c_expr_source_range (&expr, tok_range);
 825       loc = c_parser_peek_token (parser)->location;
 826       c_parser_consume_token (parser);
 827       break;
 828     case CPP_CHAR:
 829     case CPP_CHAR16:
 830     case CPP_CHAR32:
 831     case CPP_WCHAR:
 832       expr.value = c_parser_peek_token (parser)->value;
 833       set_c_expr_source_range (&expr, tok_range);
 834       c_parser_consume_token (parser);
 835       break;
 836     case CPP_STRING:
 837     case CPP_STRING16:
 838     case CPP_STRING32:
 839     case CPP_WSTRING:
 840     case CPP_UTF8STRING:
 841       expr.value = c_parser_peek_token (parser)->value;
 842       set_c_expr_source_range (&expr, tok_range);
 843       expr.original_code = STRING_CST;
 844       c_parser_consume_token (parser);
 845       break;
 846     case CPP_DOT:
 847       expr = c_parser_gimple_call_internal (parser);
 848       break;
 849     case CPP_NAME:
 850       if (c_parser_peek_token (parser)->id_kind == C_ID_ID)
 851         {
 852           tree id = c_parser_peek_token (parser)->value;
 853           if (strcmp (IDENTIFIER_POINTER (id), "__MEM") == 0)
 854             {
 855               /* __MEM '<' type-name [ ',' number ] '>'
 856                        '(' [ '(' type-name ')' ] unary-expression
 857                            [ '+' number ] ')'  */
 858               location_t loc = c_parser_peek_token (parser)->location;
 859               c_parser_consume_token (parser);
 860               struct c_type_name *type_name = NULL;
 861               tree alignment = NULL_TREE;
 862               if (c_parser_require (parser, CPP_LESS, "expected %<<%>"))
 863                 {
 864                   type_name = c_parser_type_name (parser);
 865                   /* Optional alignment.  */
 866                   if (c_parser_next_token_is (parser, CPP_COMMA))
 867                     {
 868                       c_parser_consume_token (parser);
 869                       alignment
 870                         = c_parser_gimple_postfix_expression (parser).value;
 871                     }
 872                   c_parser_skip_until_found (parser,
 873                                              CPP_GREATER, "expected %<>%>");
 874                 }
 875               struct c_expr ptr;
 876               ptr.value = error_mark_node;
 877               tree alias_off = NULL_TREE;
 878               if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
 879                 {
 880                   tree alias_type = NULL_TREE;
 881                   /* Optional alias-type cast.  */
 882                   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
 883                     {
 884                       c_parser_consume_token (parser);
 885                       struct c_type_name *alias_type_name
 886                         = c_parser_type_name (parser);
 887                       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 888                                                  "expected %<)%>");
 889                       if (alias_type_name)
 890                         {
 891                           tree tem;
 892                           alias_type = groktypename (alias_type_name,
 893                                                      &tem, NULL);
 894                         }
 895                     }
 896                   ptr = c_parser_gimple_unary_expression (parser);
 897                   if (ptr.value == error_mark_node
 898                       || ! POINTER_TYPE_P (TREE_TYPE (ptr.value)))
 899                     {
 900                       if (ptr.value != error_mark_node)
 901                         error_at (ptr.get_start (),
 902                                   "invalid type of %<__MEM%> operand");
 903                       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 904                                                  "expected %<)%>");
 905                       return expr;
 906                     }
 907                   if (! alias_type)
 908                     alias_type = TREE_TYPE (ptr.value);
 909                   /* Optional constant offset.  */
 910                   if (c_parser_next_token_is (parser, CPP_PLUS))
 911                     {
 912                       c_parser_consume_token (parser);
 913                       alias_off
 914                         = c_parser_gimple_postfix_expression (parser).value;
 915                       alias_off = fold_convert (alias_type, alias_off);
 916                     }
 917                   if (! alias_off)
 918                     alias_off = build_int_cst (alias_type, 0);
 919                   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 920                                              "expected %<)%>");
 921                 }
 922               if (! type_name || c_parser_error (parser))
 923                 {
 924                   c_parser_set_error (parser, false);
 925                   return expr;
 926                 }
 927               tree tem = NULL_TREE;
 928               tree type = groktypename (type_name, &tem, NULL);
 929               if (alignment)
 930                 type = build_aligned_type (type, tree_to_uhwi (alignment));
 931               expr.value = build2_loc (loc, MEM_REF,
 932                                        type, ptr.value, alias_off);
 933               break;
 934             }
 935           else if (strcmp (IDENTIFIER_POINTER (id), "_Literal") == 0)
 936             {
 937               /* _Literal '(' type-name ')' [ '-' ] constant */
 938               c_parser_consume_token (parser);
 939               tree type = NULL_TREE;
 940               if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
 941                 {
 942                   struct c_type_name *type_name = c_parser_type_name (parser);
 943                   tree tem;
 944                   if (type_name)
 945                     type = groktypename (type_name, &tem, NULL);
 946                   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 947                                              "expected %<)%>");
 948                 }
 949               bool neg_p;
 950               if ((neg_p = c_parser_next_token_is (parser, CPP_MINUS)))
 951                 c_parser_consume_token (parser);
 952               tree val = c_parser_gimple_postfix_expression (parser).value;
 953               if (! type
 954                   || ! val
 955                   || val == error_mark_node
 956                   || ! CONSTANT_CLASS_P (val))
 957                 {
 958                   c_parser_error (parser, "invalid _Literal");
 959                   return expr;
 960                 }
 961               if (neg_p)
 962                 {
 963                   val = const_unop (NEGATE_EXPR, TREE_TYPE (val), val);
 964                   if (! val)
 965                     {
 966                       c_parser_error (parser, "invalid _Literal");
 967                       return expr;
 968                     }
 969                 }
 970               expr.value = fold_convert (type, val);
 971               return expr;
 972             }
 973
 974           /* SSA name.  */
 975           unsigned version, ver_offset;
 976           if (! lookup_name (id)
 977               && c_parser_parse_ssa_name_id (id, &version, &ver_offset))
 978             {
 979               c_parser_consume_token (parser);
 980               expr.value = c_parser_parse_ssa_name (parser, id, NULL_TREE,
 981                                                     version, ver_offset);
 982               if (expr.value == error_mark_node)
 983                 return expr;
 984               set_c_expr_source_range (&expr, tok_range);
 985               /* For default definition SSA names.  */
 986               if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
 987                   && c_parser_peek_2nd_token (parser)->type == CPP_NAME
 988                   && strcmp ("D",
 989                              IDENTIFIER_POINTER
 990                                (c_parser_peek_2nd_token (parser)->value)) == 0
 991                   && c_parser_peek_nth_token (parser, 3)->type == CPP_CLOSE_PAREN)
 992                 {
 993                   c_parser_consume_token (parser);
 994                   c_parser_consume_token (parser);
 995                   c_parser_consume_token (parser);
 996                   if (! SSA_NAME_IS_DEFAULT_DEF (expr.value))
 997                     {
 998                       if (!SSA_NAME_VAR (expr.value))
 999                         {
1000                           error_at (loc, "anonymous SSA name cannot have"
1001                                     " default definition");
1002                           expr.value = error_mark_node;
1003                           return expr;
1004                         }
1005                       set_ssa_default_def (cfun, SSA_NAME_VAR (expr.value),
1006                                            expr.value);
1007                       SSA_NAME_DEF_STMT (expr.value) = gimple_build_nop ();
1008                     }
1009                 }
1010             }
1011           else
1012             {
1013               c_parser_consume_token (parser);
1014               expr.value
1015                 = build_external_ref (loc, id,
1016                                       (c_parser_peek_token (parser)->type
1017                                        == CPP_OPEN_PAREN), &expr.original_type);
1018               set_c_expr_source_range (&expr, tok_range);
1019             }
1020           break;
1021         }
1022       else
1023         {
1024           c_parser_error (parser, "expected expression");
1025           expr.set_error ();
1026           break;
1027         }
1028       break;
1029     default:
1030       c_parser_error (parser, "expected expression");
1031       expr.set_error ();
1032       break;
1033     }
1034   return c_parser_gimple_postfix_expression_after_primary
1035     (parser, EXPR_LOC_OR_LOC (expr.value, loc), expr);
1036 }
1037
1038 /* Parse a gimple postfix expression after the initial primary or compound
1039    literal.  */
1040
1041 static struct c_expr
1042 c_parser_gimple_postfix_expression_after_primary (c_parser *parser,
1043                                                   location_t expr_loc,
1044                                                   struct c_expr expr)
1045 {
1046   location_t start;
1047   location_t finish;
1048   tree ident;
1049   location_t comp_loc;
1050
1051   while (true)
1052     {
1053       location_t op_loc = c_parser_peek_token (parser)->location;
1054       switch (c_parser_peek_token (parser)->type)
1055         {
1056         case CPP_OPEN_SQUARE:
1057           {
1058             c_parser_consume_token (parser);
1059             tree idx = c_parser_gimple_unary_expression (parser).value;
1060
1061             if (! c_parser_require (parser, CPP_CLOSE_SQUARE, "expected %<]%>"))
1062               {
1063                 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
1064                 break;
1065               }
1066
1067             start = expr.get_start ();
1068             finish = c_parser_tokens_buf (parser, 0)->location;
1069             expr.value = build_array_ref (op_loc, expr.value, idx);
1070             set_c_expr_source_range (&expr, start, finish);
1071
1072             expr.original_code = ERROR_MARK;
1073             expr.original_type = NULL;
1074             break;
1075           }
1076         case CPP_OPEN_PAREN:
1077           {
1078             /* Function call.  */
1079             c_parser_consume_token (parser);
1080             auto_vec<tree> exprlist;
1081             if (! c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
1082               c_parser_gimple_expr_list (parser, &exprlist);
1083             c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
1084                                        "expected %<)%>");
1085             expr.value = build_call_array_loc
1086                 (expr_loc, TREE_TYPE (TREE_TYPE (expr.value)),
1087                  expr.value, exprlist.length (), exprlist.address ());
1088             expr.original_code = ERROR_MARK;
1089             expr.original_type = NULL;
1090             break;
1091           }
1092         case CPP_DOT:
1093           {
1094             /* Structure element reference.  */
1095             c_parser_consume_token (parser);
1096             if (c_parser_next_token_is (parser, CPP_NAME))
1097               {
1098                 c_token *comp_tok = c_parser_peek_token (parser);
1099                 ident = comp_tok->value;
1100                 comp_loc = comp_tok->location;
1101               }
1102             else
1103               {
1104                 c_parser_error (parser, "expected identifier");
1105                 expr.set_error ();
1106                 expr.original_code = ERROR_MARK;
1107                 expr.original_type = NULL;
1108                 return expr;
1109               }
1110             start = expr.get_start ();
1111             finish = c_parser_peek_token (parser)->get_finish ();
1112             c_parser_consume_token (parser);
1113             expr.value = build_component_ref (op_loc, expr.value, ident,
1114                                               comp_loc);
1115             set_c_expr_source_range (&expr, start, finish);
1116             expr.original_code = ERROR_MARK;
1117             if (TREE_CODE (expr.value) != COMPONENT_REF)
1118               expr.original_type = NULL;
1119             else
1120               {
1121                 /* Remember the original type of a bitfield.  */
1122                 tree field = TREE_OPERAND (expr.value, 1);
1123                 if (TREE_CODE (field) != FIELD_DECL)
1124                   expr.original_type = NULL;
1125                 else
1126                   expr.original_type = DECL_BIT_FIELD_TYPE (field);
1127               }
1128             break;
1129           }
1130         case CPP_DEREF:
1131           {
1132             /* Structure element reference.  */
1133             c_parser_consume_token (parser);
1134             if (c_parser_next_token_is (parser, CPP_NAME))
1135               {
1136                 c_token *comp_tok = c_parser_peek_token (parser);
1137                 ident = comp_tok->value;
1138                 comp_loc = comp_tok->location;
1139               }
1140             else
1141               {
1142                 c_parser_error (parser, "expected identifier");
1143                 expr.set_error ();
1144                 expr.original_code = ERROR_MARK;
1145                 expr.original_type = NULL;
1146                 return expr;
1147               }
1148             start = expr.get_start ();
1149             finish = c_parser_peek_token (parser)->get_finish ();
1150             c_parser_consume_token (parser);
1151             expr.value = build_component_ref (op_loc,
1152                                               build_simple_mem_ref_loc
1153                                                 (op_loc, expr.value),
1154                                               ident, comp_loc);
1155             set_c_expr_source_range (&expr, start, finish);
1156             expr.original_code = ERROR_MARK;
1157             if (TREE_CODE (expr.value) != COMPONENT_REF)
1158               expr.original_type = NULL;
1159             else
1160               {
1161                 /* Remember the original type of a bitfield.  */
1162                 tree field = TREE_OPERAND (expr.value, 1);
1163                 if (TREE_CODE (field) != FIELD_DECL)
1164                   expr.original_type = NULL;
1165                 else
1166                   expr.original_type = DECL_BIT_FIELD_TYPE (field);
1167               }
1168             break;
1169           }
1170         default:
1171           return expr;
1172         }
1173     }
1174 }
1175
1176 /* Parse expression list.
1177
1178    gimple-expr-list:
1179      gimple-unary-expression
1180      gimple-expr-list , gimple-unary-expression
1181
1182  */
1183
1184 static void
1185 c_parser_gimple_expr_list (c_parser *parser, vec<tree> *ret)
1186 {
1187   struct c_expr expr;
1188
1189   expr = c_parser_gimple_unary_expression (parser);
1190   ret->safe_push (expr.value);
1191   while (c_parser_next_token_is (parser, CPP_COMMA))
1192     {
1193       c_parser_consume_token (parser);
1194       expr = c_parser_gimple_unary_expression (parser);
1195       ret->safe_push (expr.value);
1196     }
1197 }
1198
1199 /* Parse gimple label.
1200
1201    gimple-label:
1202      identifier :
1203      case constant-expression :
1204      default :
1205
1206 */
1207
1208 static void
1209 c_parser_gimple_label (c_parser *parser, gimple_seq *seq)
1210 {
1211   tree name = c_parser_peek_token (parser)->value;
1212   location_t loc1 = c_parser_peek_token (parser)->location;
1213   gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
1214   c_parser_consume_token (parser);
1215   gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
1216   c_parser_consume_token (parser);
1217   tree label = define_label (loc1, name);
1218   gimple_seq_add_stmt (seq, gimple_build_label (label));
1219   return;
1220 }
1221
1222 /* Parse gimple/RTL pass list.
1223
1224    gimple-or-rtl-pass-list:
1225      startwith("pass-name")
1226  */
1227
1228 char *
1229 c_parser_gimple_or_rtl_pass_list (c_parser *parser)
1230 {
1231   char *pass = NULL;
1232
1233   /* Accept __GIMPLE/__RTL.  */
1234   if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
1235     return NULL;
1236   c_parser_consume_token (parser);
1237
1238   if (c_parser_next_token_is (parser, CPP_NAME))
1239     {
1240       const char *op = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
1241       c_parser_consume_token (parser);
1242       if (! strcmp (op, "startwith"))
1243         {
1244           if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1245             return NULL;
1246           if (c_parser_next_token_is_not (parser, CPP_STRING))
1247             {
1248               error_at (c_parser_peek_token (parser)->location,
1249                         "expected pass name");
1250               return NULL;
1251             }
1252           pass = xstrdup (TREE_STRING_POINTER
1253                                 (c_parser_peek_token (parser)->value));
1254           c_parser_consume_token (parser);
1255           if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
1256             return NULL;
1257         }
1258       else
1259         {
1260           error_at (c_parser_peek_token (parser)->location,
1261                     "invalid operation");
1262           return NULL;
1263         }
1264     }
1265
1266   if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
1267     return NULL;
1268
1269   return pass;
1270 }
1271
1272 /* Parse gimple local declaration.
1273
1274    declaration-specifiers:
1275      storage-class-specifier declaration-specifiers[opt]
1276      type-specifier declaration-specifiers[opt]
1277      type-qualifier declaration-specifiers[opt]
1278      function-specifier declaration-specifiers[opt]
1279      alignment-specifier declaration-specifiers[opt]
1280
1281    storage-class-specifier:
1282      typedef
1283      extern
1284      static
1285      auto
1286      register
1287
1288    type-specifier:
1289      void
1290      char
1291      short
1292      int
1293      long
1294      float
1295      double
1296      signed
1297      unsigned
1298      _Bool
1299      _Complex
1300
1301    type-qualifier:
1302      const
1303      restrict
1304      volatile
1305      address-space-qualifier
1306      _Atomic
1307
1308  */
1309
1310 static void
1311 c_parser_gimple_declaration (c_parser *parser)
1312 {
1313   struct c_declarator *declarator;
1314   struct c_declspecs *specs = build_null_declspecs ();
1315   c_parser_declspecs (parser, specs, true, true, true,
1316                       true, true, cla_nonabstract_decl);
1317   finish_declspecs (specs);
1318
1319   /* Provide better error recovery.  Note that a type name here is usually
1320      better diagnosed as a redeclaration.  */
1321   if (c_parser_next_token_starts_declspecs (parser)
1322       && ! c_parser_next_token_is (parser, CPP_NAME))
1323     {
1324       c_parser_error (parser, "expected %<;%>");
1325       c_parser_set_error (parser, false);
1326       return;
1327     }
1328
1329   bool dummy = false;
1330   declarator = c_parser_declarator (parser,
1331                                     specs->typespec_kind != ctsk_none,
1332                                     C_DTR_NORMAL, &dummy);
1333
1334   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1335     {
1336       /* Handle SSA name decls specially, they do not go into the identifier
1337          table but we simply build the SSA name for later lookup.  */
1338       unsigned version, ver_offset;
1339       if (declarator->kind == cdk_id
1340           && is_gimple_reg_type (specs->type)
1341           && c_parser_parse_ssa_name_id (declarator->u.id,
1342                                          &version, &ver_offset)
1343           /* The following restricts it to unnamed anonymous SSA names
1344              which fails parsing of named ones in dumps (we could
1345              decide to not dump their name for -gimple).  */
1346           && ver_offset == 0)
1347         c_parser_parse_ssa_name (parser, declarator->u.id, specs->type,
1348                                  version, ver_offset);
1349       else
1350         {
1351           tree postfix_attrs = NULL_TREE;
1352           tree all_prefix_attrs = specs->attrs;
1353           specs->attrs = NULL;
1354           tree decl = start_decl (declarator, specs, false,
1355                                   chainon (postfix_attrs, all_prefix_attrs));
1356           if (decl)
1357             finish_decl (decl, UNKNOWN_LOCATION, NULL_TREE, NULL_TREE,
1358                          NULL_TREE);
1359         }
1360     }
1361   else
1362     {
1363       c_parser_error (parser, "expected %<;%>");
1364       return;
1365     }
1366 }
1367
1368 /* Parse gimple goto statement.  */
1369
1370 static void
1371 c_parser_gimple_goto_stmt (location_t loc, tree label, gimple_seq *seq)
1372 {
1373   tree decl = lookup_label_for_goto (loc, label);
1374   gimple_seq_add_stmt (seq, gimple_build_goto (decl));
1375   return;
1376 }
1377
1378 /* Parse a parenthesized condition.
1379    gimple-condition:
1380      ( gimple-binary-expression )    */
1381
1382 static tree
1383 c_parser_gimple_paren_condition (c_parser *parser)
1384 {
1385   if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1386     return error_mark_node;
1387   tree cond = c_parser_gimple_binary_expression (parser).value;
1388   if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
1389     return error_mark_node;
1390   return cond;
1391 }
1392
1393 /* Parse gimple if-else statement.
1394
1395    if-statement:
1396      if ( gimple-binary-expression ) gimple-goto-statement
1397      if ( gimple-binary-expression ) gimple-goto-statement \
1398                                         else gimple-goto-statement
1399  */
1400
1401 static void
1402 c_parser_gimple_if_stmt (c_parser *parser, gimple_seq *seq)
1403 {
1404   tree t_label, f_label, label;
1405   location_t loc;
1406   c_parser_consume_token (parser);
1407   tree cond = c_parser_gimple_paren_condition (parser);
1408
1409   if (c_parser_next_token_is_keyword (parser, RID_GOTO))
1410     {
1411       loc = c_parser_peek_token (parser)->location;
1412       c_parser_consume_token (parser);
1413       if (! c_parser_next_token_is (parser, CPP_NAME))
1414         {
1415           c_parser_error (parser, "expected label");
1416           return;
1417         }
1418       label = c_parser_peek_token (parser)->value;
1419       c_parser_consume_token (parser);
1420       t_label = lookup_label_for_goto (loc, label);
1421       if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
1422         return;
1423     }
1424   else
1425     {
1426       c_parser_error (parser, "expected goto expression");
1427       return;
1428     }
1429
1430   if (c_parser_next_token_is_keyword (parser, RID_ELSE))
1431     c_parser_consume_token (parser);
1432   else
1433     {
1434       c_parser_error (parser, "expected else statement");
1435       return;
1436     }
1437
1438   if (c_parser_next_token_is_keyword (parser, RID_GOTO))
1439     {
1440       loc = c_parser_peek_token (parser)->location;
1441       c_parser_consume_token (parser);
1442       if (! c_parser_next_token_is (parser, CPP_NAME))
1443         {
1444           c_parser_error (parser, "expected label");
1445           return;
1446         }
1447       label = c_parser_peek_token (parser)->value;
1448       f_label = lookup_label_for_goto (loc, label);
1449       c_parser_consume_token (parser);
1450       if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
1451         return;
1452     }
1453   else
1454     {
1455       c_parser_error (parser, "expected goto expression");
1456       return;
1457     }
1458
1459   if (cond != error_mark_node)
1460     gimple_seq_add_stmt (seq, gimple_build_cond_from_tree (cond, t_label,
1461                                                            f_label));
1462 }
1463
1464 /* Parse gimple switch-statement.
1465
1466    gimple-switch-statement:
1467      switch (gimple-postfix-expression) gimple-case-statement
1468
1469    gimple-case-statement:
1470      gimple-case-statement
1471      gimple-label-statement : gimple-goto-statment
1472 */
1473
1474 static void
1475 c_parser_gimple_switch_stmt (c_parser *parser, gimple_seq *seq)
1476 {
1477   c_expr cond_expr;
1478   tree case_label, label;
1479   auto_vec<tree> labels;
1480   tree default_label = NULL_TREE;
1481   gimple_seq switch_body = NULL;
1482   c_parser_consume_token (parser);
1483
1484   if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1485     return;
1486   cond_expr = c_parser_gimple_postfix_expression (parser);
1487   if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
1488     return;
1489
1490   if (! c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
1491     return;
1492
1493   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
1494     {
1495       if (c_parser_next_token_is (parser, CPP_EOF))
1496         {
1497           c_parser_error (parser, "expected statement");
1498           return;
1499         }
1500
1501       switch (c_parser_peek_token (parser)->keyword)
1502         {
1503         case RID_CASE:
1504           {
1505             c_expr exp1;
1506             location_t loc = c_parser_peek_token (parser)->location;
1507             c_parser_consume_token (parser);
1508
1509             if (c_parser_next_token_is (parser, CPP_NAME)
1510                 || c_parser_peek_token (parser)->type == CPP_NUMBER)
1511               exp1 = c_parser_gimple_postfix_expression (parser);
1512             else
1513               {
1514                 c_parser_error (parser, "expected expression");
1515                 return;
1516               }
1517
1518             if (c_parser_next_token_is (parser, CPP_COLON))
1519               {
1520                 c_parser_consume_token (parser);
1521                 if (c_parser_next_token_is (parser, CPP_NAME))
1522                   {
1523                     label = c_parser_peek_token (parser)->value;
1524                     c_parser_consume_token (parser);
1525                     tree decl = lookup_label_for_goto (loc, label);
1526                     case_label = build_case_label (exp1.value, NULL_TREE,
1527                                                    decl);
1528                     labels.safe_push (case_label);
1529                     if (! c_parser_require (parser, CPP_SEMICOLON,
1530                                             "expected %<;%>"))
1531                       return;
1532                   }
1533                 else if (! c_parser_require (parser, CPP_NAME,
1534                                              "expected label"))
1535                   return;
1536               }
1537             else if (! c_parser_require (parser, CPP_SEMICOLON,
1538                                          "expected %<:%>"))
1539               return;
1540             break;
1541           }
1542         case RID_DEFAULT:
1543           {
1544             location_t loc = c_parser_peek_token (parser)->location;
1545             c_parser_consume_token (parser);
1546             if (c_parser_next_token_is (parser, CPP_COLON))
1547               {
1548                 c_parser_consume_token (parser);
1549                 if (c_parser_next_token_is (parser, CPP_NAME))
1550                   {
1551                     label = c_parser_peek_token (parser)->value;
1552                     c_parser_consume_token (parser);
1553                     tree decl = lookup_label_for_goto (loc, label);
1554                     default_label = build_case_label (NULL_TREE, NULL_TREE,
1555                                                       decl);
1556                     if (! c_parser_require (parser, CPP_SEMICOLON,
1557                                             "expected %<;%>"))
1558                       return;
1559                   }
1560                 else if (! c_parser_require (parser, CPP_NAME,
1561                                              "expected label"))
1562                   return;
1563               }
1564             else if (! c_parser_require (parser, CPP_SEMICOLON,
1565                                          "expected %<:%>"))
1566               return;
1567             break;
1568           }
1569         case RID_GOTO:
1570           {
1571             location_t loc = c_parser_peek_token (parser)->location;
1572             c_parser_consume_token (parser);
1573             if (c_parser_next_token_is (parser, CPP_NAME))
1574               {
1575                 c_parser_gimple_goto_stmt (loc,
1576                                            c_parser_peek_token
1577                                            (parser)->value,
1578                                            &switch_body);
1579                 c_parser_consume_token (parser);
1580                 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1581                   c_parser_consume_token (parser);
1582                 else
1583                   {
1584                     c_parser_error (parser, "expected semicolon");
1585                     return;
1586                   }
1587               }
1588             else if (! c_parser_require (parser, CPP_NAME,
1589                                          "expected label"))
1590               return;
1591             break;
1592           }
1593         default:
1594           c_parser_error (parser, "expected case label or goto statement");
1595           return;
1596         }
1597
1598     }
1599   if (! c_parser_require (parser, CPP_CLOSE_BRACE, "expected %<}%>"))
1600     return;
1601
1602   if (cond_expr.value != error_mark_node)
1603     {
1604       gimple_seq_add_stmt (seq, gimple_build_switch (cond_expr.value,
1605                                                      default_label, labels));
1606       gimple_seq_add_seq (seq, switch_body);
1607     }
1608 }
1609
1610 /* Parse gimple return statement.  */
1611
1612 static void
1613 c_parser_gimple_return_stmt (c_parser *parser, gimple_seq *seq)
1614 {
1615   location_t loc = c_parser_peek_token (parser)->location;
1616   gimple *ret = NULL;
1617   c_parser_consume_token (parser);
1618   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1619     {
1620       c_finish_gimple_return (loc, NULL_TREE);
1621       ret = gimple_build_return (NULL);
1622       gimple_seq_add_stmt (seq, ret);
1623     }
1624   else
1625     {
1626       location_t xloc = c_parser_peek_token (parser)->location;
1627       c_expr expr = c_parser_gimple_unary_expression (parser);
1628       if (expr.value != error_mark_node)
1629         {
1630           c_finish_gimple_return (xloc, expr.value);
1631           ret = gimple_build_return (expr.value);
1632           gimple_seq_add_stmt (seq, ret);
1633         }
1634     }
1635 }
1636
1637 /* Support function for c_parser_gimple_return_stmt.  */
1638
1639 static void
1640 c_finish_gimple_return (location_t loc, tree retval)
1641 {
1642   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
1643
1644   /* Use the expansion point to handle cases such as returning NULL
1645      in a function returning void.  */
1646   location_t xloc = expansion_point_location_if_in_system_header (loc);
1647
1648   if (TREE_THIS_VOLATILE (current_function_decl))
1649     warning_at (xloc, 0,
1650                 "function declared %<noreturn%> has a %<return%> statement");
1651
1652   if (! retval)
1653     current_function_returns_null = 1;
1654   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
1655     {
1656       current_function_returns_null = 1;
1657       if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
1658         {
1659           error_at
1660             (xloc, "%<return%> with a value, in function returning void");
1661           inform (DECL_SOURCE_LOCATION (current_function_decl),
1662                   "declared here");
1663         }
1664     }
1665   else if (TREE_CODE (valtype) != TREE_CODE (TREE_TYPE (retval)))
1666     {
1667       error_at
1668         (xloc, "invalid conversion in return statement");
1669       inform (DECL_SOURCE_LOCATION (current_function_decl),
1670               "declared here");
1671     }
1672   return;
1673 }