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