gcc/c/gimple-parser.c

   1 /* Parser for GIMPLE.
   2    Copyright (C) 2016-2017 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 "tree-dump.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_generic, 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.value = error_mark_node;
 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);
 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           goto build_unary_expr;
 333         break;
 334       }
 335     case CPP_KEYWORD:
 336       if (c_parser_peek_token (parser)->keyword != RID_REALPART
 337           && c_parser_peek_token (parser)->keyword != RID_IMAGPART)
 338         break;
 339       /* Fallthru.  */
 340     case CPP_AND:
 341     case CPP_PLUS:
 342     case CPP_MINUS:
 343     case CPP_COMPL:
 344     case CPP_NOT:
 345     case CPP_MULT: /* pointer deref */
 346     build_unary_expr:
 347       rhs = c_parser_gimple_unary_expression (parser);
 348       if (rhs.value != error_mark_node)
 349         {
 350           assign = gimple_build_assign (lhs.value, rhs.value);
 351           gimple_set_location (assign, loc);
 352           gimple_seq_add_stmt (seq, assign);
 353         }
 354       return;
 355
 356     default:;
 357     }
 358
 359   /* GIMPLE PHI statement.  */
 360   if (c_parser_next_token_is_keyword (parser, RID_PHI))
 361     {
 362       c_parser_consume_token (parser);
 363
 364       if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
 365         return;
 366
 367       if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
 368         c_parser_consume_token (parser);
 369
 370       while (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
 371         {
 372           if (c_parser_next_token_is (parser, CPP_NAME)
 373               && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
 374             {
 375               arg = lookup_label_for_goto (loc,
 376                                            c_parser_peek_token (parser)->value);
 377               c_parser_consume_token (parser);
 378
 379               if (c_parser_next_token_is (parser, CPP_COLON))
 380                 c_parser_consume_token (parser);
 381               vargs.safe_push (arg);
 382             }
 383           else if (c_parser_next_token_is (parser, CPP_COMMA))
 384             c_parser_consume_token (parser);
 385           else
 386             {
 387               arg = c_parser_gimple_unary_expression (parser).value;
 388               vargs.safe_push (arg);
 389             }
 390         }
 391
 392       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 393                                  "expected %<)%>");
 394
 395       /* Build internal function for PHI.  */
 396       gcall *call_stmt = gimple_build_call_internal_vec (IFN_PHI, vargs);
 397       gimple_call_set_lhs (call_stmt, lhs.value);
 398       gimple_set_location (call_stmt, UNKNOWN_LOCATION);
 399       gimple_seq_add_stmt (seq, call_stmt);
 400       return;
 401     }
 402
 403   /* GIMPLE call with lhs.  */
 404   if (c_parser_next_token_is (parser, CPP_NAME)
 405       && c_parser_peek_2nd_token (parser)->type == CPP_OPEN_PAREN
 406       && lookup_name (c_parser_peek_token (parser)->value))
 407     {
 408       rhs = c_parser_gimple_unary_expression (parser);
 409       if (rhs.value != error_mark_node)
 410         {
 411           gimple *call = gimple_build_call_from_tree (rhs.value);
 412           gimple_call_set_lhs (call, lhs.value);
 413           gimple_seq_add_stmt (seq, call);
 414           gimple_set_location (call, loc);
 415         }
 416       return;
 417     }
 418
 419   rhs = c_parser_gimple_binary_expression (parser);
 420   if (lhs.value != error_mark_node
 421       && rhs.value != error_mark_node)
 422     {
 423       assign = gimple_build_assign (lhs.value, rhs.value);
 424       gimple_seq_add_stmt (seq, assign);
 425       gimple_set_location (assign, loc);
 426     }
 427   return;
 428 }
 429
 430 /* Parse gimple binary expr.
 431
 432    gimple-binary-expression:
 433      gimple-unary-expression * gimple-unary-expression
 434      gimple-unary-expression / gimple-unary-expression
 435      gimple-unary-expression % gimple-unary-expression
 436      gimple-unary-expression + gimple-unary-expression
 437      gimple-unary-expression - gimple-unary-expression
 438      gimple-unary-expression << gimple-unary-expression
 439      gimple-unary-expression >> gimple-unary-expression
 440      gimple-unary-expression < gimple-unary-expression
 441      gimple-unary-expression > gimple-unary-expression
 442      gimple-unary-expression <= gimple-unary-expression
 443      gimple-unary-expression >= gimple-unary-expression
 444      gimple-unary-expression == gimple-unary-expression
 445      gimple-unary-expression != gimple-unary-expression
 446      gimple-unary-expression & gimple-unary-expression
 447      gimple-unary-expression ^ gimple-unary-expression
 448      gimple-unary-expression | gimple-unary-expression
 449
 450 */
 451
 452 static c_expr
 453 c_parser_gimple_binary_expression (c_parser *parser)
 454 {
 455   /* Location of the binary operator.  */
 456   struct c_expr ret, lhs, rhs;
 457   enum tree_code code = ERROR_MARK;
 458   ret.value = error_mark_node;
 459   lhs = c_parser_gimple_postfix_expression (parser);
 460   if (c_parser_error (parser))
 461     return ret;
 462   tree ret_type = TREE_TYPE (lhs.value);
 463   switch (c_parser_peek_token (parser)->type)
 464     {
 465     case CPP_MULT:
 466       code = MULT_EXPR;
 467       break;
 468     case CPP_DIV:
 469       code = TRUNC_DIV_EXPR;
 470       break;
 471     case CPP_MOD:
 472       code = TRUNC_MOD_EXPR;
 473       break;
 474     case CPP_PLUS:
 475       if (POINTER_TYPE_P (TREE_TYPE (lhs.value)))
 476         code = POINTER_PLUS_EXPR;
 477       else
 478         code = PLUS_EXPR;
 479       break;
 480     case CPP_MINUS:
 481       code = MINUS_EXPR;
 482       break;
 483     case CPP_LSHIFT:
 484       code = LSHIFT_EXPR;
 485       break;
 486     case CPP_RSHIFT:
 487       code = RSHIFT_EXPR;
 488       break;
 489     case CPP_LESS:
 490       code = LT_EXPR;
 491       ret_type = boolean_type_node;
 492       break;
 493     case CPP_GREATER:
 494       code = GT_EXPR;
 495       ret_type = boolean_type_node;
 496       break;
 497     case CPP_LESS_EQ:
 498       code = LE_EXPR;
 499       ret_type = boolean_type_node;
 500       break;
 501     case CPP_GREATER_EQ:
 502       code = GE_EXPR;
 503       ret_type = boolean_type_node;
 504       break;
 505     case CPP_EQ_EQ:
 506       code = EQ_EXPR;
 507       ret_type = boolean_type_node;
 508       break;
 509     case CPP_NOT_EQ:
 510       code = NE_EXPR;
 511       ret_type = boolean_type_node;
 512       break;
 513     case CPP_AND:
 514       code = BIT_AND_EXPR;
 515       break;
 516     case CPP_XOR:
 517       code = BIT_XOR_EXPR;
 518       break;
 519     case CPP_OR:
 520       code = BIT_IOR_EXPR;
 521       break;
 522     case CPP_AND_AND:
 523       c_parser_error (parser, "%<&&%> not valid in GIMPLE");
 524       return ret;
 525     case CPP_OR_OR:
 526       c_parser_error (parser, "%<||%> not valid in GIMPLE");
 527       return ret;
 528     default:
 529       /* Not a binary expression.  */
 530       return lhs;
 531     }
 532   location_t ret_loc = c_parser_peek_token (parser)->location;
 533   c_parser_consume_token (parser);
 534   rhs = c_parser_gimple_postfix_expression (parser);
 535   if (lhs.value != error_mark_node && rhs.value != error_mark_node)
 536     ret.value = build2_loc (ret_loc, code, ret_type, lhs.value, rhs.value);
 537   return ret;
 538 }
 539
 540 /* Parse gimple unary expression.
 541
 542    gimple-unary-expression:
 543      gimple-postfix-expression
 544      unary-operator gimple-postfix-expression
 545
 546    unary-operator: one of
 547      & * + - ~ abs_expr
 548 */
 549
 550 static c_expr
 551 c_parser_gimple_unary_expression (c_parser *parser)
 552 {
 553   struct c_expr ret, op;
 554   location_t op_loc = c_parser_peek_token (parser)->location;
 555   location_t finish;
 556   ret.original_code = ERROR_MARK;
 557   ret.original_type = NULL;
 558   ret.value = error_mark_node;
 559   switch (c_parser_peek_token (parser)->type)
 560     {
 561     case CPP_AND:
 562       c_parser_consume_token (parser);
 563       op = c_parser_gimple_postfix_expression (parser);
 564       mark_exp_read (op.value);
 565       return parser_build_unary_op (op_loc, ADDR_EXPR, op);
 566     case CPP_MULT:
 567       {
 568         c_parser_consume_token (parser);
 569         op = c_parser_gimple_postfix_expression (parser);
 570         if (op.value == error_mark_node)
 571           return ret;
 572         finish = op.get_finish ();
 573         location_t combined_loc = make_location (op_loc, op_loc, finish);
 574         ret.value = build_simple_mem_ref_loc (combined_loc, op.value);
 575         TREE_SIDE_EFFECTS (ret.value)
 576           = TREE_THIS_VOLATILE (ret.value)
 577           = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op.value)));
 578         ret.src_range.m_start = op_loc;
 579         ret.src_range.m_finish = finish;
 580         return ret;
 581       }
 582     case CPP_PLUS:
 583       c_parser_consume_token (parser);
 584       op = c_parser_gimple_postfix_expression (parser);
 585       return parser_build_unary_op (op_loc, CONVERT_EXPR, op);
 586     case CPP_MINUS:
 587       c_parser_consume_token (parser);
 588       op = c_parser_gimple_postfix_expression (parser);
 589       return parser_build_unary_op (op_loc, NEGATE_EXPR, op);
 590     case CPP_COMPL:
 591       c_parser_consume_token (parser);
 592       op = c_parser_gimple_postfix_expression (parser);
 593       return parser_build_unary_op (op_loc, BIT_NOT_EXPR, op);
 594     case CPP_NOT:
 595       c_parser_error (parser, "%<!%> not valid in GIMPLE");
 596       return ret;
 597     case CPP_KEYWORD:
 598       switch (c_parser_peek_token (parser)->keyword)
 599         {
 600         case RID_REALPART:
 601           c_parser_consume_token (parser);
 602           op = c_parser_gimple_postfix_expression (parser);
 603           return parser_build_unary_op (op_loc, REALPART_EXPR, op);
 604         case RID_IMAGPART:
 605           c_parser_consume_token (parser);
 606           op = c_parser_gimple_postfix_expression (parser);
 607           return parser_build_unary_op (op_loc, IMAGPART_EXPR, op);
 608         default:
 609           return c_parser_gimple_postfix_expression (parser);
 610         }
 611     case CPP_NAME:
 612         {
 613           tree id = c_parser_peek_token (parser)->value;
 614           if (strcmp (IDENTIFIER_POINTER (id), "__ABS") == 0)
 615             {
 616               c_parser_consume_token (parser);
 617               op = c_parser_gimple_postfix_expression (parser);
 618               return parser_build_unary_op (op_loc, ABS_EXPR, op);
 619             }
 620           else
 621             return c_parser_gimple_postfix_expression (parser);
 622         }
 623     default:
 624       return c_parser_gimple_postfix_expression (parser);
 625     }
 626 }
 627
 628 /* Decompose ID into base name (ID until ver_offset) and VERSION.  Return
 629    true if ID matches a SSA name.  */
 630
 631 static bool
 632 c_parser_parse_ssa_name_id (tree id, unsigned *version, unsigned *ver_offset)
 633 {
 634   const char *token = IDENTIFIER_POINTER (id);
 635   const char *var_version = strrchr (token, '_');
 636   if (! var_version)
 637     return false;
 638
 639   *ver_offset = var_version - token;
 640   for (const char *p = var_version + 1; *p; ++p)
 641     if (! ISDIGIT (*p))
 642       return false;
 643   *version = atoi (var_version + 1);
 644   return *version > 0;
 645 }
 646
 647 /* Get at the actual SSA name ID with VERSION starting at VER_OFFSET.
 648    TYPE is the type if the SSA name is being declared.  */
 649
 650 static tree
 651 c_parser_parse_ssa_name (c_parser *parser,
 652                          tree id, tree type, unsigned version,
 653                          unsigned ver_offset)
 654 {
 655   tree name = NULL_TREE;
 656   const char *token = IDENTIFIER_POINTER (id);
 657
 658   if (ver_offset == 0)
 659     {
 660       /* Anonymous unnamed SSA name.  */
 661       if (version < num_ssa_names)
 662         name = ssa_name (version);
 663       if (! name)
 664         {
 665           if (! type)
 666             {
 667               c_parser_error (parser, "SSA name undeclared");
 668               return error_mark_node;
 669             }
 670           name = make_ssa_name_fn (cfun, type, NULL, version);
 671         }
 672     }
 673   else
 674     {
 675       if (version < num_ssa_names)
 676         name = ssa_name (version);
 677       if (! name)
 678         {
 679           /* Separate var name from version.  */
 680           char *var_name = XNEWVEC (char, ver_offset + 1);
 681           memcpy (var_name, token, ver_offset);
 682           var_name[ver_offset] = '\0';
 683           /* lookup for parent decl.  */
 684           id = get_identifier (var_name);
 685           tree parent = lookup_name (id);
 686           XDELETEVEC (var_name);
 687           if (! parent || parent == error_mark_node)
 688             {
 689               c_parser_error (parser, "base variable or SSA name undeclared");
 690               return error_mark_node;
 691             }
 692           if (VECTOR_TYPE_P (TREE_TYPE (parent))
 693               || TREE_CODE (TREE_TYPE (parent)) == COMPLEX_TYPE)
 694             DECL_GIMPLE_REG_P (parent) = 1;
 695           name = make_ssa_name_fn (cfun, parent,
 696                                    gimple_build_nop (), version);
 697         }
 698     }
 699
 700   return name;
 701 }
 702
 703 /* Parse gimple postfix expression.
 704
 705    gimple-postfix-expression:
 706      gimple-primary-expression
 707      gimple-primary-xpression [ gimple-primary-expression ]
 708      gimple-primary-expression ( gimple-argument-expression-list[opt] )
 709      postfix-expression . identifier
 710      postfix-expression -> identifier
 711
 712    gimple-argument-expression-list:
 713      gimple-unary-expression
 714      gimple-argument-expression-list , gimple-unary-expression
 715
 716    gimple-primary-expression:
 717      identifier
 718      constant
 719      string-literal
 720
 721 */
 722
 723 static struct c_expr
 724 c_parser_gimple_postfix_expression (c_parser *parser)
 725 {
 726   struct c_expr expr;
 727   location_t loc = c_parser_peek_token (parser)->location;
 728   source_range tok_range = c_parser_peek_token (parser)->get_range ();
 729   expr.original_code = ERROR_MARK;
 730   expr.original_type = NULL;
 731   switch (c_parser_peek_token (parser)->type)
 732     {
 733     case CPP_NUMBER:
 734       expr.value = c_parser_peek_token (parser)->value;
 735       set_c_expr_source_range (&expr, tok_range);
 736       loc = c_parser_peek_token (parser)->location;
 737       c_parser_consume_token (parser);
 738       break;
 739     case CPP_CHAR:
 740     case CPP_CHAR16:
 741     case CPP_CHAR32:
 742     case CPP_WCHAR:
 743       expr.value = c_parser_peek_token (parser)->value;
 744       set_c_expr_source_range (&expr, tok_range);
 745       c_parser_consume_token (parser);
 746       break;
 747     case CPP_STRING:
 748     case CPP_STRING16:
 749     case CPP_STRING32:
 750     case CPP_WSTRING:
 751     case CPP_UTF8STRING:
 752       expr.value = c_parser_peek_token (parser)->value;
 753       set_c_expr_source_range (&expr, tok_range);
 754       expr.original_code = STRING_CST;
 755       c_parser_consume_token (parser);
 756       break;
 757     case CPP_NAME:
 758       if (c_parser_peek_token (parser)->id_kind == C_ID_ID)
 759         {
 760           tree id = c_parser_peek_token (parser)->value;
 761           if (strcmp (IDENTIFIER_POINTER (id), "__MEM") == 0)
 762             {
 763               /* __MEM '<' type-name [ ',' number ] '>'
 764                        '(' [ '(' type-name ')' ] unary-expression
 765                            [ '+' number ] ')'  */
 766               location_t loc = c_parser_peek_token (parser)->location;
 767               c_parser_consume_token (parser);
 768               struct c_type_name *type_name = NULL;
 769               tree alignment = NULL_TREE;
 770               if (c_parser_require (parser, CPP_LESS, "expected %<<%>"))
 771                 {
 772                   type_name = c_parser_type_name (parser);
 773                   /* Optional alignment.  */
 774                   if (c_parser_next_token_is (parser, CPP_COMMA))
 775                     {
 776                       c_parser_consume_token (parser);
 777                       alignment
 778                         = c_parser_gimple_postfix_expression (parser).value;
 779                     }
 780                   c_parser_skip_until_found (parser,
 781                                              CPP_GREATER, "expected %<>%>");
 782                 }
 783               struct c_expr ptr;
 784               ptr.value = error_mark_node;
 785               tree alias_off = NULL_TREE;
 786               if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
 787                 {
 788                   tree alias_type = NULL_TREE;
 789                   /* Optional alias-type cast.  */
 790                   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
 791                     {
 792                       c_parser_consume_token (parser);
 793                       struct c_type_name *alias_type_name
 794                         = c_parser_type_name (parser);
 795                       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 796                                                  "expected %<)%>");
 797                       if (alias_type_name)
 798                         {
 799                           tree tem;
 800                           alias_type = groktypename (alias_type_name,
 801                                                      &tem, NULL);
 802                         }
 803                     }
 804                   ptr = c_parser_gimple_unary_expression (parser);
 805                   if (! alias_type)
 806                     alias_type = TREE_TYPE (ptr.value);
 807                   /* Optional constant offset.  */
 808                   if (c_parser_next_token_is (parser, CPP_PLUS))
 809                     {
 810                       c_parser_consume_token (parser);
 811                       alias_off
 812                         = c_parser_gimple_postfix_expression (parser).value;
 813                       alias_off = fold_convert (alias_type, alias_off);
 814                     }
 815                   if (! alias_off)
 816                     alias_off = build_int_cst (alias_type, 0);
 817                   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 818                                              "expected %<)%>");
 819                 }
 820               if (! type_name || c_parser_error (parser))
 821                 {
 822                   c_parser_set_error (parser, false);
 823                   return expr;
 824                 }
 825               tree tem = NULL_TREE;
 826               tree type = groktypename (type_name, &tem, NULL);
 827               if (alignment)
 828                 type = build_aligned_type (type, tree_to_uhwi (alignment));
 829               expr.value = build2_loc (loc, MEM_REF,
 830                                        type, ptr.value, alias_off);
 831               break;
 832             }
 833           else if (strcmp (IDENTIFIER_POINTER (id), "_Literal") == 0)
 834             {
 835               /* _Literal '(' type-name ')' number  */
 836               c_parser_consume_token (parser);
 837               tree type = NULL_TREE;
 838               if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
 839                 {
 840                   struct c_type_name *type_name = c_parser_type_name (parser);
 841                   tree tem;
 842                   if (type_name)
 843                     type = groktypename (type_name, &tem, NULL);
 844                   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 845                                              "expected %<)%>");
 846                 }
 847               tree val = c_parser_gimple_postfix_expression (parser).value;
 848               if (! type
 849                   || ! val
 850                   || val == error_mark_node
 851                   || TREE_CODE (val) != INTEGER_CST)
 852                 {
 853                   c_parser_error (parser, "invalid _Literal");
 854                   return expr;
 855                 }
 856               expr.value = fold_convert (type, val);
 857               return expr;
 858             }
 859           /* SSA name.  */
 860           unsigned version, ver_offset;
 861           if (! lookup_name (id)
 862               && c_parser_parse_ssa_name_id (id, &version, &ver_offset))
 863             {
 864               c_parser_consume_token (parser);
 865               expr.value = c_parser_parse_ssa_name (parser, id, NULL_TREE,
 866                                                     version, ver_offset);
 867               set_c_expr_source_range (&expr, tok_range);
 868               /* For default definition SSA names.  */
 869               if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
 870                   && c_parser_peek_2nd_token (parser)->type == CPP_NAME
 871                   && strcmp ("D",
 872                              IDENTIFIER_POINTER
 873                                (c_parser_peek_2nd_token (parser)->value)) == 0
 874                   && c_parser_peek_nth_token (parser, 3)->type == CPP_CLOSE_PAREN)
 875                 {
 876                   c_parser_consume_token (parser);
 877                   c_parser_consume_token (parser);
 878                   c_parser_consume_token (parser);
 879                   if (! SSA_NAME_IS_DEFAULT_DEF (expr.value))
 880                     {
 881                       set_ssa_default_def (cfun, SSA_NAME_VAR (expr.value),
 882                                            expr.value);
 883                       SSA_NAME_DEF_STMT (expr.value) = gimple_build_nop ();
 884                     }
 885                 }
 886             }
 887           else
 888             {
 889               c_parser_consume_token (parser);
 890               expr.value
 891                 = build_external_ref (loc, id,
 892                                       (c_parser_peek_token (parser)->type
 893                                        == CPP_OPEN_PAREN), &expr.original_type);
 894               set_c_expr_source_range (&expr, tok_range);
 895             }
 896           break;
 897         }
 898       else
 899         {
 900           c_parser_error (parser, "expected expression");
 901           expr.set_error ();
 902           break;
 903         }
 904       break;
 905     default:
 906       c_parser_error (parser, "expected expression");
 907       expr.set_error ();
 908       break;
 909     }
 910   return c_parser_gimple_postfix_expression_after_primary
 911     (parser, EXPR_LOC_OR_LOC (expr.value, loc), expr);
 912 }
 913
 914 /* Parse a gimple postfix expression after the initial primary or compound
 915    literal.  */
 916
 917 static struct c_expr
 918 c_parser_gimple_postfix_expression_after_primary (c_parser *parser,
 919                                                   location_t expr_loc,
 920                                                   struct c_expr expr)
 921 {
 922   location_t start;
 923   location_t finish;
 924   tree ident;
 925   location_t comp_loc;
 926
 927   while (true)
 928     {
 929       location_t op_loc = c_parser_peek_token (parser)->location;
 930       switch (c_parser_peek_token (parser)->type)
 931         {
 932         case CPP_OPEN_SQUARE:
 933           {
 934             c_parser_consume_token (parser);
 935             tree idx = c_parser_gimple_unary_expression (parser).value;
 936
 937             if (! c_parser_require (parser, CPP_CLOSE_SQUARE, "expected %<]%>"))
 938               {
 939                 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
 940                 break;
 941               }
 942
 943             start = expr.get_start ();
 944             finish = c_parser_tokens_buf (parser, 0)->location;
 945             expr.value = build_array_ref (op_loc, expr.value, idx);
 946             set_c_expr_source_range (&expr, start, finish);
 947
 948             expr.original_code = ERROR_MARK;
 949             expr.original_type = NULL;
 950             break;
 951           }
 952         case CPP_OPEN_PAREN:
 953           {
 954             /* Function call.  */
 955             c_parser_consume_token (parser);
 956             auto_vec<tree> exprlist;
 957             if (! c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
 958               c_parser_gimple_expr_list (parser, &exprlist);
 959             c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 960                                        "expected %<)%>");
 961             expr.value = build_call_array_loc
 962                 (expr_loc, TREE_TYPE (TREE_TYPE (expr.value)),
 963                  expr.value, exprlist.length (), exprlist.address ());
 964             expr.original_code = ERROR_MARK;
 965             expr.original_type = NULL;
 966             break;
 967           }
 968         case CPP_DOT:
 969           {
 970             /* Structure element reference.  */
 971             c_parser_consume_token (parser);
 972             if (c_parser_next_token_is (parser, CPP_NAME))
 973               {
 974                 c_token *comp_tok = c_parser_peek_token (parser);
 975                 ident = comp_tok->value;
 976                 comp_loc = comp_tok->location;
 977               }
 978             else
 979               {
 980                 c_parser_error (parser, "expected identifier");
 981                 expr.set_error ();
 982                 expr.original_code = ERROR_MARK;
 983                 expr.original_type = NULL;
 984                 return expr;
 985               }
 986             start = expr.get_start ();
 987             finish = c_parser_peek_token (parser)->get_finish ();
 988             c_parser_consume_token (parser);
 989             expr.value = build_component_ref (op_loc, expr.value, ident,
 990                                               comp_loc);
 991             set_c_expr_source_range (&expr, start, finish);
 992             expr.original_code = ERROR_MARK;
 993             if (TREE_CODE (expr.value) != COMPONENT_REF)
 994               expr.original_type = NULL;
 995             else
 996               {
 997                 /* Remember the original type of a bitfield.  */
 998                 tree field = TREE_OPERAND (expr.value, 1);
 999                 if (TREE_CODE (field) != FIELD_DECL)
1000                   expr.original_type = NULL;
1001                 else
1002                   expr.original_type = DECL_BIT_FIELD_TYPE (field);
1003               }
1004             break;
1005           }
1006         case CPP_DEREF:
1007           {
1008             /* Structure element reference.  */
1009             c_parser_consume_token (parser);
1010             if (c_parser_next_token_is (parser, CPP_NAME))
1011               {
1012                 c_token *comp_tok = c_parser_peek_token (parser);
1013                 ident = comp_tok->value;
1014                 comp_loc = comp_tok->location;
1015               }
1016             else
1017               {
1018                 c_parser_error (parser, "expected identifier");
1019                 expr.set_error ();
1020                 expr.original_code = ERROR_MARK;
1021                 expr.original_type = NULL;
1022                 return expr;
1023               }
1024             start = expr.get_start ();
1025             finish = c_parser_peek_token (parser)->get_finish ();
1026             c_parser_consume_token (parser);
1027             expr.value = build_component_ref (op_loc,
1028                                               build_simple_mem_ref_loc
1029                                                 (op_loc, expr.value),
1030                                               ident, comp_loc);
1031             set_c_expr_source_range (&expr, start, finish);
1032             expr.original_code = ERROR_MARK;
1033             if (TREE_CODE (expr.value) != COMPONENT_REF)
1034               expr.original_type = NULL;
1035             else
1036               {
1037                 /* Remember the original type of a bitfield.  */
1038                 tree field = TREE_OPERAND (expr.value, 1);
1039                 if (TREE_CODE (field) != FIELD_DECL)
1040                   expr.original_type = NULL;
1041                 else
1042                   expr.original_type = DECL_BIT_FIELD_TYPE (field);
1043               }
1044             break;
1045           }
1046         default:
1047           return expr;
1048         }
1049     }
1050 }
1051
1052 /* Parse expression list.
1053
1054    gimple-expr-list:
1055      gimple-unary-expression
1056      gimple-expr-list , gimple-unary-expression
1057
1058  */
1059
1060 static void
1061 c_parser_gimple_expr_list (c_parser *parser, vec<tree> *ret)
1062 {
1063   struct c_expr expr;
1064
1065   expr = c_parser_gimple_unary_expression (parser);
1066   ret->safe_push (expr.value);
1067   while (c_parser_next_token_is (parser, CPP_COMMA))
1068     {
1069       c_parser_consume_token (parser);
1070       expr = c_parser_gimple_unary_expression (parser);
1071       ret->safe_push (expr.value);
1072     }
1073 }
1074
1075 /* Parse gimple label.
1076
1077    gimple-label:
1078      identifier :
1079      case constant-expression :
1080      default :
1081
1082 */
1083
1084 static void
1085 c_parser_gimple_label (c_parser *parser, gimple_seq *seq)
1086 {
1087   tree name = c_parser_peek_token (parser)->value;
1088   location_t loc1 = c_parser_peek_token (parser)->location;
1089   gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
1090   c_parser_consume_token (parser);
1091   gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
1092   c_parser_consume_token (parser);
1093   tree label = define_label (loc1, name);
1094   gimple_seq_add_stmt (seq, gimple_build_label (label));
1095   return;
1096 }
1097
1098 /* Parse gimple/RTL pass list.
1099
1100    gimple-or-rtl-pass-list:
1101      startwith("pass-name")
1102  */
1103
1104 char *
1105 c_parser_gimple_or_rtl_pass_list (c_parser *parser)
1106 {
1107   char *pass = NULL;
1108
1109   /* Accept __GIMPLE/__RTL.  */
1110   if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
1111     return NULL;
1112   c_parser_consume_token (parser);
1113
1114   if (c_parser_next_token_is (parser, CPP_NAME))
1115     {
1116       const char *op = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
1117       c_parser_consume_token (parser);
1118       if (! strcmp (op, "startwith"))
1119         {
1120           if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1121             return NULL;
1122           if (c_parser_next_token_is_not (parser, CPP_STRING))
1123             {
1124               error_at (c_parser_peek_token (parser)->location,
1125                         "expected pass name");
1126               return NULL;
1127             }
1128           pass = xstrdup (TREE_STRING_POINTER
1129                                 (c_parser_peek_token (parser)->value));
1130           c_parser_consume_token (parser);
1131           if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
1132             return NULL;
1133         }
1134       else
1135         {
1136           error_at (c_parser_peek_token (parser)->location,
1137                     "invalid operation");
1138           return NULL;
1139         }
1140     }
1141
1142   if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
1143     return NULL;
1144
1145   return pass;
1146 }
1147
1148 /* Parse gimple local declaration.
1149
1150    declaration-specifiers:
1151      storage-class-specifier declaration-specifiers[opt]
1152      type-specifier declaration-specifiers[opt]
1153      type-qualifier declaration-specifiers[opt]
1154      function-specifier declaration-specifiers[opt]
1155      alignment-specifier declaration-specifiers[opt]
1156
1157    storage-class-specifier:
1158      typedef
1159      extern
1160      static
1161      auto
1162      register
1163
1164    type-specifier:
1165      void
1166      char
1167      short
1168      int
1169      long
1170      float
1171      double
1172      signed
1173      unsigned
1174      _Bool
1175      _Complex
1176
1177    type-qualifier:
1178      const
1179      restrict
1180      volatile
1181      address-space-qualifier
1182      _Atomic
1183
1184  */
1185
1186 static void
1187 c_parser_gimple_declaration (c_parser *parser)
1188 {
1189   struct c_declarator *declarator;
1190   struct c_declspecs *specs = build_null_declspecs ();
1191   c_parser_declspecs (parser, specs, true, true, true,
1192                       true, true, cla_nonabstract_decl);
1193   finish_declspecs (specs);
1194
1195   /* Provide better error recovery.  Note that a type name here is usually
1196      better diagnosed as a redeclaration.  */
1197   if (c_parser_next_token_starts_declspecs (parser)
1198       && ! c_parser_next_token_is (parser, CPP_NAME))
1199     {
1200       c_parser_error (parser, "expected %<;%>");
1201       c_parser_set_error (parser, false);
1202       return;
1203     }
1204
1205   bool dummy = false;
1206   declarator = c_parser_declarator (parser,
1207                                     specs->typespec_kind != ctsk_none,
1208                                     C_DTR_NORMAL, &dummy);
1209
1210   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1211     {
1212       /* Handle SSA name decls specially, they do not go into the identifier
1213          table but we simply build the SSA name for later lookup.  */
1214       unsigned version, ver_offset;
1215       if (declarator->kind == cdk_id
1216           && is_gimple_reg_type (specs->type)
1217           && c_parser_parse_ssa_name_id (declarator->u.id,
1218                                          &version, &ver_offset)
1219           /* The following restricts it to unnamed anonymous SSA names
1220              which fails parsing of named ones in dumps (we could
1221              decide to not dump their name for -gimple).  */
1222           && ver_offset == 0)
1223         c_parser_parse_ssa_name (parser, declarator->u.id, specs->type,
1224                                  version, ver_offset);
1225       else
1226         {
1227           tree postfix_attrs = NULL_TREE;
1228           tree all_prefix_attrs = specs->attrs;
1229           specs->attrs = NULL;
1230           tree decl = start_decl (declarator, specs, false,
1231                                   chainon (postfix_attrs, all_prefix_attrs));
1232           if (decl)
1233             finish_decl (decl, UNKNOWN_LOCATION, NULL_TREE, NULL_TREE,
1234                          NULL_TREE);
1235         }
1236     }
1237   else
1238     {
1239       c_parser_error (parser, "expected %<;%>");
1240       return;
1241     }
1242 }
1243
1244 /* Parse gimple goto statement.  */
1245
1246 static void
1247 c_parser_gimple_goto_stmt (location_t loc, tree label, gimple_seq *seq)
1248 {
1249   tree decl = lookup_label_for_goto (loc, label);
1250   gimple_seq_add_stmt (seq, gimple_build_goto (decl));
1251   return;
1252 }
1253
1254 /* Parse a parenthesized condition.
1255    gimple-condition:
1256      ( gimple-binary-expression )    */
1257
1258 static tree
1259 c_parser_gimple_paren_condition (c_parser *parser)
1260 {
1261   if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1262     return error_mark_node;
1263   tree cond = c_parser_gimple_binary_expression (parser).value;
1264   if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
1265     return error_mark_node;
1266   return cond;
1267 }
1268
1269 /* Parse gimple if-else statement.
1270
1271    if-statement:
1272      if ( gimple-binary-expression ) gimple-goto-statement
1273      if ( gimple-binary-expression ) gimple-goto-statement \
1274                                         else gimple-goto-statement
1275  */
1276
1277 static void
1278 c_parser_gimple_if_stmt (c_parser *parser, gimple_seq *seq)
1279 {
1280   tree t_label, f_label, label;
1281   location_t loc;
1282   c_parser_consume_token (parser);
1283   tree cond = c_parser_gimple_paren_condition (parser);
1284
1285   if (c_parser_next_token_is_keyword (parser, RID_GOTO))
1286     {
1287       loc = c_parser_peek_token (parser)->location;
1288       c_parser_consume_token (parser);
1289       label = c_parser_peek_token (parser)->value;
1290       t_label = lookup_label_for_goto (loc, label);
1291       c_parser_consume_token (parser);
1292       if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
1293         return;
1294     }
1295   else
1296     {
1297       c_parser_error (parser, "expected goto expression");
1298       return;
1299     }
1300
1301   if (c_parser_next_token_is_keyword (parser, RID_ELSE))
1302     c_parser_consume_token (parser);
1303   else
1304     {
1305       c_parser_error (parser, "expected else statement");
1306       return;
1307     }
1308
1309   if (c_parser_next_token_is_keyword (parser, RID_GOTO))
1310     {
1311       loc = c_parser_peek_token (parser)->location;
1312       c_parser_consume_token (parser);
1313       label = c_parser_peek_token (parser)->value;
1314       f_label = lookup_label_for_goto (loc, label);
1315       c_parser_consume_token (parser);
1316       if (! c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
1317         return;
1318     }
1319   else
1320     {
1321       c_parser_error (parser, "expected goto expression");
1322       return;
1323     }
1324
1325   if (cond != error_mark_node)
1326     gimple_seq_add_stmt (seq, gimple_build_cond_from_tree (cond, t_label,
1327                                                            f_label));
1328 }
1329
1330 /* Parse gimple switch-statement.
1331
1332    gimple-switch-statement:
1333      switch (gimple-postfix-expression) gimple-case-statement
1334
1335    gimple-case-statement:
1336      gimple-case-statement
1337      gimple-label-statement : gimple-goto-statment
1338 */
1339
1340 static void
1341 c_parser_gimple_switch_stmt (c_parser *parser, gimple_seq *seq)
1342 {
1343   c_expr cond_expr;
1344   tree case_label, label;
1345   auto_vec<tree> labels;
1346   tree default_label = NULL_TREE;
1347   gimple_seq switch_body = NULL;
1348   c_parser_consume_token (parser);
1349
1350   if (! c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1351     return;
1352   cond_expr = c_parser_gimple_postfix_expression (parser);
1353   if (! c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
1354     return;
1355
1356   if (! c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
1357     return;
1358
1359   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
1360     {
1361       if (c_parser_next_token_is (parser, CPP_EOF))
1362         {
1363           c_parser_error (parser, "expected statement");
1364           return;
1365         }
1366
1367       switch (c_parser_peek_token (parser)->keyword)
1368         {
1369         case RID_CASE:
1370           {
1371             c_expr exp1;
1372             location_t loc = c_parser_peek_token (parser)->location;
1373             c_parser_consume_token (parser);
1374
1375             if (c_parser_next_token_is (parser, CPP_NAME)
1376                 || c_parser_peek_token (parser)->type == CPP_NUMBER)
1377               exp1 = c_parser_gimple_postfix_expression (parser);
1378             else
1379               {
1380                 c_parser_error (parser, "expected expression");
1381                 return;
1382               }
1383
1384             if (c_parser_next_token_is (parser, CPP_COLON))
1385               {
1386                 c_parser_consume_token (parser);
1387                 if (c_parser_next_token_is (parser, CPP_NAME))
1388                   {
1389                     label = c_parser_peek_token (parser)->value;
1390                     c_parser_consume_token (parser);
1391                     tree decl = lookup_label_for_goto (loc, label);
1392                     case_label = build_case_label (exp1.value, NULL_TREE,
1393                                                    decl);
1394                     labels.safe_push (case_label);
1395                     if (! c_parser_require (parser, CPP_SEMICOLON,
1396                                             "expected %<;%>"))
1397                       return;
1398                   }
1399                 else if (! c_parser_require (parser, CPP_NAME,
1400                                              "expected label"))
1401                   return;
1402               }
1403             else if (! c_parser_require (parser, CPP_SEMICOLON,
1404                                          "expected %<:%>"))
1405               return;
1406             break;
1407           }
1408         case RID_DEFAULT:
1409           {
1410             location_t loc = c_parser_peek_token (parser)->location;
1411             c_parser_consume_token (parser);
1412             if (c_parser_next_token_is (parser, CPP_COLON))
1413               {
1414                 c_parser_consume_token (parser);
1415                 if (c_parser_next_token_is (parser, CPP_NAME))
1416                   {
1417                     label = c_parser_peek_token (parser)->value;
1418                     c_parser_consume_token (parser);
1419                     tree decl = lookup_label_for_goto (loc, label);
1420                     default_label = build_case_label (NULL_TREE, NULL_TREE,
1421                                                       decl);
1422                     if (! c_parser_require (parser, CPP_SEMICOLON,
1423                                             "expected %<;%>"))
1424                       return;
1425                   }
1426                 else if (! c_parser_require (parser, CPP_NAME,
1427                                              "expected label"))
1428                   return;
1429               }
1430             else if (! c_parser_require (parser, CPP_SEMICOLON,
1431                                          "expected %<:%>"))
1432               return;
1433             break;
1434           }
1435         case RID_GOTO:
1436           {
1437             location_t loc = c_parser_peek_token (parser)->location;
1438             c_parser_consume_token (parser);
1439             if (c_parser_next_token_is (parser, CPP_NAME))
1440               {
1441                 c_parser_gimple_goto_stmt (loc,
1442                                            c_parser_peek_token
1443                                            (parser)->value,
1444                                            &switch_body);
1445                 c_parser_consume_token (parser);
1446                 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1447                   c_parser_consume_token (parser);
1448                 else
1449                   {
1450                     c_parser_error (parser, "expected semicolon");
1451                     return;
1452                   }
1453               }
1454             else if (! c_parser_require (parser, CPP_NAME,
1455                                          "expected label"))
1456               return;
1457             break;
1458           }
1459         default:
1460           c_parser_error (parser, "expected case label or goto statement");
1461           return;
1462         }
1463
1464     }
1465   if (! c_parser_require (parser, CPP_CLOSE_BRACE, "expected %<}%>"))
1466     return;
1467
1468   if (cond_expr.value != error_mark_node)
1469     {
1470       gimple_seq_add_stmt (seq, gimple_build_switch (cond_expr.value,
1471                                                      default_label, labels));
1472       gimple_seq_add_seq (seq, switch_body);
1473     }
1474 }
1475
1476 /* Parse gimple return statement.  */
1477
1478 static void
1479 c_parser_gimple_return_stmt (c_parser *parser, gimple_seq *seq)
1480 {
1481   location_t loc = c_parser_peek_token (parser)->location;
1482   gimple *ret = NULL;
1483   c_parser_consume_token (parser);
1484   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1485     {
1486       c_finish_gimple_return (loc, NULL_TREE);
1487       ret = gimple_build_return (NULL);
1488       gimple_seq_add_stmt (seq, ret);
1489     }
1490   else
1491     {
1492       location_t xloc = c_parser_peek_token (parser)->location;
1493       c_expr expr = c_parser_gimple_unary_expression (parser);
1494       if (expr.value != error_mark_node)
1495         {
1496           c_finish_gimple_return (xloc, expr.value);
1497           ret = gimple_build_return (expr.value);
1498           gimple_seq_add_stmt (seq, ret);
1499         }
1500     }
1501 }
1502
1503 /* Support function for c_parser_gimple_return_stmt.  */
1504
1505 static void
1506 c_finish_gimple_return (location_t loc, tree retval)
1507 {
1508   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
1509
1510   /* Use the expansion point to handle cases such as returning NULL
1511      in a function returning void.  */
1512   source_location xloc = expansion_point_location_if_in_system_header (loc);
1513
1514   if (TREE_THIS_VOLATILE (current_function_decl))
1515     warning_at (xloc, 0,
1516                 "function declared %<noreturn%> has a %<return%> statement");
1517
1518   if (! retval)
1519     current_function_returns_null = 1;
1520   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
1521     {
1522       current_function_returns_null = 1;
1523       if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
1524         {
1525           error_at
1526             (xloc, "%<return%> with a value, in function returning void");
1527           inform (DECL_SOURCE_LOCATION (current_function_decl),
1528                   "declared here");
1529         }
1530     }
1531   else if (TREE_CODE (valtype) != TREE_CODE (TREE_TYPE (retval)))
1532     {
1533       error_at
1534         (xloc, "invalid conversion in return statement");
1535       inform (DECL_SOURCE_LOCATION (current_function_decl),
1536               "declared here");
1537     }
1538   return;
1539 }