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