gcc/c/gimple-parser.c

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