builtins.def: (_Float<N> and _Float<N>X BUILT_IN_CEIL): Add _Float<N> and _Float...
[official-gcc.git] / gcc / gimplify.c
blobeb4ad967d0d7b6b362a5d74a2e556050e01d37ae
1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002-2017 Free Software Foundation, Inc.
4 Major work done by Sebastian Pop <s.pop@laposte.net>,
5 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
12 version.
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "backend.h"
27 #include "target.h"
28 #include "rtl.h"
29 #include "tree.h"
30 #include "memmodel.h"
31 #include "tm_p.h"
32 #include "gimple.h"
33 #include "gimple-predict.h"
34 #include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
35 #include "ssa.h"
36 #include "cgraph.h"
37 #include "tree-pretty-print.h"
38 #include "diagnostic-core.h"
39 #include "alias.h"
40 #include "fold-const.h"
41 #include "calls.h"
42 #include "varasm.h"
43 #include "stmt.h"
44 #include "expr.h"
45 #include "gimple-fold.h"
46 #include "tree-eh.h"
47 #include "gimplify.h"
48 #include "gimple-iterator.h"
49 #include "stor-layout.h"
50 #include "print-tree.h"
51 #include "tree-iterator.h"
52 #include "tree-inline.h"
53 #include "langhooks.h"
54 #include "tree-cfg.h"
55 #include "tree-ssa.h"
56 #include "omp-general.h"
57 #include "omp-low.h"
58 #include "gimple-low.h"
59 #include "gomp-constants.h"
60 #include "splay-tree.h"
61 #include "gimple-walk.h"
62 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
63 #include "builtins.h"
64 #include "stringpool.h"
65 #include "attribs.h"
66 #include "asan.h"
67 #include "dbgcnt.h"
69 /* Hash set of poisoned variables in a bind expr. */
70 static hash_set<tree> *asan_poisoned_variables = NULL;
72 enum gimplify_omp_var_data
74 GOVD_SEEN = 1,
75 GOVD_EXPLICIT = 2,
76 GOVD_SHARED = 4,
77 GOVD_PRIVATE = 8,
78 GOVD_FIRSTPRIVATE = 16,
79 GOVD_LASTPRIVATE = 32,
80 GOVD_REDUCTION = 64,
81 GOVD_LOCAL = 128,
82 GOVD_MAP = 256,
83 GOVD_DEBUG_PRIVATE = 512,
84 GOVD_PRIVATE_OUTER_REF = 1024,
85 GOVD_LINEAR = 2048,
86 GOVD_ALIGNED = 4096,
88 /* Flag for GOVD_MAP: don't copy back. */
89 GOVD_MAP_TO_ONLY = 8192,
91 /* Flag for GOVD_LINEAR or GOVD_LASTPRIVATE: no outer reference. */
92 GOVD_LINEAR_LASTPRIVATE_NO_OUTER = 16384,
94 GOVD_MAP_0LEN_ARRAY = 32768,
96 /* Flag for GOVD_MAP, if it is always, to or always, tofrom mapping. */
97 GOVD_MAP_ALWAYS_TO = 65536,
99 /* Flag for shared vars that are or might be stored to in the region. */
100 GOVD_WRITTEN = 131072,
102 /* Flag for GOVD_MAP, if it is a forced mapping. */
103 GOVD_MAP_FORCE = 262144,
105 /* Flag for GOVD_MAP: must be present already. */
106 GOVD_MAP_FORCE_PRESENT = 524288,
108 GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
109 | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LINEAR
110 | GOVD_LOCAL)
114 enum omp_region_type
116 ORT_WORKSHARE = 0x00,
117 ORT_SIMD = 0x01,
119 ORT_PARALLEL = 0x02,
120 ORT_COMBINED_PARALLEL = 0x03,
122 ORT_TASK = 0x04,
123 ORT_UNTIED_TASK = 0x05,
125 ORT_TEAMS = 0x08,
126 ORT_COMBINED_TEAMS = 0x09,
128 /* Data region. */
129 ORT_TARGET_DATA = 0x10,
131 /* Data region with offloading. */
132 ORT_TARGET = 0x20,
133 ORT_COMBINED_TARGET = 0x21,
135 /* OpenACC variants. */
136 ORT_ACC = 0x40, /* A generic OpenACC region. */
137 ORT_ACC_DATA = ORT_ACC | ORT_TARGET_DATA, /* Data construct. */
138 ORT_ACC_PARALLEL = ORT_ACC | ORT_TARGET, /* Parallel construct */
139 ORT_ACC_KERNELS = ORT_ACC | ORT_TARGET | 0x80, /* Kernels construct. */
140 ORT_ACC_HOST_DATA = ORT_ACC | ORT_TARGET_DATA | 0x80, /* Host data. */
142 /* Dummy OpenMP region, used to disable expansion of
143 DECL_VALUE_EXPRs in taskloop pre body. */
144 ORT_NONE = 0x100
147 /* Gimplify hashtable helper. */
149 struct gimplify_hasher : free_ptr_hash <elt_t>
151 static inline hashval_t hash (const elt_t *);
152 static inline bool equal (const elt_t *, const elt_t *);
155 struct gimplify_ctx
157 struct gimplify_ctx *prev_context;
159 vec<gbind *> bind_expr_stack;
160 tree temps;
161 gimple_seq conditional_cleanups;
162 tree exit_label;
163 tree return_temp;
165 vec<tree> case_labels;
166 hash_set<tree> *live_switch_vars;
167 /* The formal temporary table. Should this be persistent? */
168 hash_table<gimplify_hasher> *temp_htab;
170 int conditions;
171 unsigned into_ssa : 1;
172 unsigned allow_rhs_cond_expr : 1;
173 unsigned in_cleanup_point_expr : 1;
174 unsigned keep_stack : 1;
175 unsigned save_stack : 1;
176 unsigned in_switch_expr : 1;
179 struct gimplify_omp_ctx
181 struct gimplify_omp_ctx *outer_context;
182 splay_tree variables;
183 hash_set<tree> *privatized_types;
184 /* Iteration variables in an OMP_FOR. */
185 vec<tree> loop_iter_var;
186 location_t location;
187 enum omp_clause_default_kind default_kind;
188 enum omp_region_type region_type;
189 bool combined_loop;
190 bool distribute;
191 bool target_map_scalars_firstprivate;
192 bool target_map_pointers_as_0len_arrays;
193 bool target_firstprivatize_array_bases;
196 static struct gimplify_ctx *gimplify_ctxp;
197 static struct gimplify_omp_ctx *gimplify_omp_ctxp;
199 /* Forward declaration. */
200 static enum gimplify_status gimplify_compound_expr (tree *, gimple_seq *, bool);
201 static hash_map<tree, tree> *oacc_declare_returns;
202 static enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *,
203 bool (*) (tree), fallback_t, bool);
205 /* Shorter alias name for the above function for use in gimplify.c
206 only. */
208 static inline void
209 gimplify_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
211 gimple_seq_add_stmt_without_update (seq_p, gs);
214 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
215 NULL, a new sequence is allocated. This function is
216 similar to gimple_seq_add_seq, but does not scan the operands.
217 During gimplification, we need to manipulate statement sequences
218 before the def/use vectors have been constructed. */
220 static void
221 gimplify_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
223 gimple_stmt_iterator si;
225 if (src == NULL)
226 return;
228 si = gsi_last (*dst_p);
229 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
233 /* Pointer to a list of allocated gimplify_ctx structs to be used for pushing
234 and popping gimplify contexts. */
236 static struct gimplify_ctx *ctx_pool = NULL;
238 /* Return a gimplify context struct from the pool. */
240 static inline struct gimplify_ctx *
241 ctx_alloc (void)
243 struct gimplify_ctx * c = ctx_pool;
245 if (c)
246 ctx_pool = c->prev_context;
247 else
248 c = XNEW (struct gimplify_ctx);
250 memset (c, '\0', sizeof (*c));
251 return c;
254 /* Put gimplify context C back into the pool. */
256 static inline void
257 ctx_free (struct gimplify_ctx *c)
259 c->prev_context = ctx_pool;
260 ctx_pool = c;
263 /* Free allocated ctx stack memory. */
265 void
266 free_gimplify_stack (void)
268 struct gimplify_ctx *c;
270 while ((c = ctx_pool))
272 ctx_pool = c->prev_context;
273 free (c);
278 /* Set up a context for the gimplifier. */
280 void
281 push_gimplify_context (bool in_ssa, bool rhs_cond_ok)
283 struct gimplify_ctx *c = ctx_alloc ();
285 c->prev_context = gimplify_ctxp;
286 gimplify_ctxp = c;
287 gimplify_ctxp->into_ssa = in_ssa;
288 gimplify_ctxp->allow_rhs_cond_expr = rhs_cond_ok;
291 /* Tear down a context for the gimplifier. If BODY is non-null, then
292 put the temporaries into the outer BIND_EXPR. Otherwise, put them
293 in the local_decls.
295 BODY is not a sequence, but the first tuple in a sequence. */
297 void
298 pop_gimplify_context (gimple *body)
300 struct gimplify_ctx *c = gimplify_ctxp;
302 gcc_assert (c
303 && (!c->bind_expr_stack.exists ()
304 || c->bind_expr_stack.is_empty ()));
305 c->bind_expr_stack.release ();
306 gimplify_ctxp = c->prev_context;
308 if (body)
309 declare_vars (c->temps, body, false);
310 else
311 record_vars (c->temps);
313 delete c->temp_htab;
314 c->temp_htab = NULL;
315 ctx_free (c);
318 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
320 static void
321 gimple_push_bind_expr (gbind *bind_stmt)
323 gimplify_ctxp->bind_expr_stack.reserve (8);
324 gimplify_ctxp->bind_expr_stack.safe_push (bind_stmt);
327 /* Pop the first element off the stack of bindings. */
329 static void
330 gimple_pop_bind_expr (void)
332 gimplify_ctxp->bind_expr_stack.pop ();
335 /* Return the first element of the stack of bindings. */
337 gbind *
338 gimple_current_bind_expr (void)
340 return gimplify_ctxp->bind_expr_stack.last ();
343 /* Return the stack of bindings created during gimplification. */
345 vec<gbind *>
346 gimple_bind_expr_stack (void)
348 return gimplify_ctxp->bind_expr_stack;
351 /* Return true iff there is a COND_EXPR between us and the innermost
352 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
354 static bool
355 gimple_conditional_context (void)
357 return gimplify_ctxp->conditions > 0;
360 /* Note that we've entered a COND_EXPR. */
362 static void
363 gimple_push_condition (void)
365 #ifdef ENABLE_GIMPLE_CHECKING
366 if (gimplify_ctxp->conditions == 0)
367 gcc_assert (gimple_seq_empty_p (gimplify_ctxp->conditional_cleanups));
368 #endif
369 ++(gimplify_ctxp->conditions);
372 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
373 now, add any conditional cleanups we've seen to the prequeue. */
375 static void
376 gimple_pop_condition (gimple_seq *pre_p)
378 int conds = --(gimplify_ctxp->conditions);
380 gcc_assert (conds >= 0);
381 if (conds == 0)
383 gimplify_seq_add_seq (pre_p, gimplify_ctxp->conditional_cleanups);
384 gimplify_ctxp->conditional_cleanups = NULL;
388 /* A stable comparison routine for use with splay trees and DECLs. */
390 static int
391 splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
393 tree a = (tree) xa;
394 tree b = (tree) xb;
396 return DECL_UID (a) - DECL_UID (b);
399 /* Create a new omp construct that deals with variable remapping. */
401 static struct gimplify_omp_ctx *
402 new_omp_context (enum omp_region_type region_type)
404 struct gimplify_omp_ctx *c;
406 c = XCNEW (struct gimplify_omp_ctx);
407 c->outer_context = gimplify_omp_ctxp;
408 c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
409 c->privatized_types = new hash_set<tree>;
410 c->location = input_location;
411 c->region_type = region_type;
412 if ((region_type & ORT_TASK) == 0)
413 c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
414 else
415 c->default_kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
417 return c;
420 /* Destroy an omp construct that deals with variable remapping. */
422 static void
423 delete_omp_context (struct gimplify_omp_ctx *c)
425 splay_tree_delete (c->variables);
426 delete c->privatized_types;
427 c->loop_iter_var.release ();
428 XDELETE (c);
431 static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
432 static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
434 /* Both gimplify the statement T and append it to *SEQ_P. This function
435 behaves exactly as gimplify_stmt, but you don't have to pass T as a
436 reference. */
438 void
439 gimplify_and_add (tree t, gimple_seq *seq_p)
441 gimplify_stmt (&t, seq_p);
444 /* Gimplify statement T into sequence *SEQ_P, and return the first
445 tuple in the sequence of generated tuples for this statement.
446 Return NULL if gimplifying T produced no tuples. */
448 static gimple *
449 gimplify_and_return_first (tree t, gimple_seq *seq_p)
451 gimple_stmt_iterator last = gsi_last (*seq_p);
453 gimplify_and_add (t, seq_p);
455 if (!gsi_end_p (last))
457 gsi_next (&last);
458 return gsi_stmt (last);
460 else
461 return gimple_seq_first_stmt (*seq_p);
464 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
465 LHS, or for a call argument. */
467 static bool
468 is_gimple_mem_rhs (tree t)
470 /* If we're dealing with a renamable type, either source or dest must be
471 a renamed variable. */
472 if (is_gimple_reg_type (TREE_TYPE (t)))
473 return is_gimple_val (t);
474 else
475 return is_gimple_val (t) || is_gimple_lvalue (t);
478 /* Return true if T is a CALL_EXPR or an expression that can be
479 assigned to a temporary. Note that this predicate should only be
480 used during gimplification. See the rationale for this in
481 gimplify_modify_expr. */
483 static bool
484 is_gimple_reg_rhs_or_call (tree t)
486 return (get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS
487 || TREE_CODE (t) == CALL_EXPR);
490 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
491 this predicate should only be used during gimplification. See the
492 rationale for this in gimplify_modify_expr. */
494 static bool
495 is_gimple_mem_rhs_or_call (tree t)
497 /* If we're dealing with a renamable type, either source or dest must be
498 a renamed variable. */
499 if (is_gimple_reg_type (TREE_TYPE (t)))
500 return is_gimple_val (t);
501 else
502 return (is_gimple_val (t)
503 || is_gimple_lvalue (t)
504 || TREE_CLOBBER_P (t)
505 || TREE_CODE (t) == CALL_EXPR);
508 /* Create a temporary with a name derived from VAL. Subroutine of
509 lookup_tmp_var; nobody else should call this function. */
511 static inline tree
512 create_tmp_from_val (tree val)
514 /* Drop all qualifiers and address-space information from the value type. */
515 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (val));
516 tree var = create_tmp_var (type, get_name (val));
517 if (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
518 || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE)
519 DECL_GIMPLE_REG_P (var) = 1;
520 return var;
523 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
524 an existing expression temporary. */
526 static tree
527 lookup_tmp_var (tree val, bool is_formal)
529 tree ret;
531 /* If not optimizing, never really reuse a temporary. local-alloc
532 won't allocate any variable that is used in more than one basic
533 block, which means it will go into memory, causing much extra
534 work in reload and final and poorer code generation, outweighing
535 the extra memory allocation here. */
536 if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
537 ret = create_tmp_from_val (val);
538 else
540 elt_t elt, *elt_p;
541 elt_t **slot;
543 elt.val = val;
544 if (!gimplify_ctxp->temp_htab)
545 gimplify_ctxp->temp_htab = new hash_table<gimplify_hasher> (1000);
546 slot = gimplify_ctxp->temp_htab->find_slot (&elt, INSERT);
547 if (*slot == NULL)
549 elt_p = XNEW (elt_t);
550 elt_p->val = val;
551 elt_p->temp = ret = create_tmp_from_val (val);
552 *slot = elt_p;
554 else
556 elt_p = *slot;
557 ret = elt_p->temp;
561 return ret;
564 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
566 static tree
567 internal_get_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
568 bool is_formal, bool allow_ssa)
570 tree t, mod;
572 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
573 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
574 gimplify_expr (&val, pre_p, post_p, is_gimple_reg_rhs_or_call,
575 fb_rvalue);
577 if (allow_ssa
578 && gimplify_ctxp->into_ssa
579 && is_gimple_reg_type (TREE_TYPE (val)))
581 t = make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val)));
582 if (! gimple_in_ssa_p (cfun))
584 const char *name = get_name (val);
585 if (name)
586 SET_SSA_NAME_VAR_OR_IDENTIFIER (t, create_tmp_var_name (name));
589 else
590 t = lookup_tmp_var (val, is_formal);
592 mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
594 SET_EXPR_LOCATION (mod, EXPR_LOC_OR_LOC (val, input_location));
596 /* gimplify_modify_expr might want to reduce this further. */
597 gimplify_and_add (mod, pre_p);
598 ggc_free (mod);
600 return t;
603 /* Return a formal temporary variable initialized with VAL. PRE_P is as
604 in gimplify_expr. Only use this function if:
606 1) The value of the unfactored expression represented by VAL will not
607 change between the initialization and use of the temporary, and
608 2) The temporary will not be otherwise modified.
610 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
611 and #2 means it is inappropriate for && temps.
613 For other cases, use get_initialized_tmp_var instead. */
615 tree
616 get_formal_tmp_var (tree val, gimple_seq *pre_p)
618 return internal_get_tmp_var (val, pre_p, NULL, true, true);
621 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
622 are as in gimplify_expr. */
624 tree
625 get_initialized_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
626 bool allow_ssa)
628 return internal_get_tmp_var (val, pre_p, post_p, false, allow_ssa);
631 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
632 generate debug info for them; otherwise don't. */
634 void
635 declare_vars (tree vars, gimple *gs, bool debug_info)
637 tree last = vars;
638 if (last)
640 tree temps, block;
642 gbind *scope = as_a <gbind *> (gs);
644 temps = nreverse (last);
646 block = gimple_bind_block (scope);
647 gcc_assert (!block || TREE_CODE (block) == BLOCK);
648 if (!block || !debug_info)
650 DECL_CHAIN (last) = gimple_bind_vars (scope);
651 gimple_bind_set_vars (scope, temps);
653 else
655 /* We need to attach the nodes both to the BIND_EXPR and to its
656 associated BLOCK for debugging purposes. The key point here
657 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
658 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
659 if (BLOCK_VARS (block))
660 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
661 else
663 gimple_bind_set_vars (scope,
664 chainon (gimple_bind_vars (scope), temps));
665 BLOCK_VARS (block) = temps;
671 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
672 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
673 no such upper bound can be obtained. */
675 static void
676 force_constant_size (tree var)
678 /* The only attempt we make is by querying the maximum size of objects
679 of the variable's type. */
681 HOST_WIDE_INT max_size;
683 gcc_assert (VAR_P (var));
685 max_size = max_int_size_in_bytes (TREE_TYPE (var));
687 gcc_assert (max_size >= 0);
689 DECL_SIZE_UNIT (var)
690 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size);
691 DECL_SIZE (var)
692 = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT);
695 /* Push the temporary variable TMP into the current binding. */
697 void
698 gimple_add_tmp_var_fn (struct function *fn, tree tmp)
700 gcc_assert (!DECL_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
702 /* Later processing assumes that the object size is constant, which might
703 not be true at this point. Force the use of a constant upper bound in
704 this case. */
705 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (tmp)))
706 force_constant_size (tmp);
708 DECL_CONTEXT (tmp) = fn->decl;
709 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
711 record_vars_into (tmp, fn->decl);
714 /* Push the temporary variable TMP into the current binding. */
716 void
717 gimple_add_tmp_var (tree tmp)
719 gcc_assert (!DECL_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
721 /* Later processing assumes that the object size is constant, which might
722 not be true at this point. Force the use of a constant upper bound in
723 this case. */
724 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (tmp)))
725 force_constant_size (tmp);
727 DECL_CONTEXT (tmp) = current_function_decl;
728 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
730 if (gimplify_ctxp)
732 DECL_CHAIN (tmp) = gimplify_ctxp->temps;
733 gimplify_ctxp->temps = tmp;
735 /* Mark temporaries local within the nearest enclosing parallel. */
736 if (gimplify_omp_ctxp)
738 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
739 while (ctx
740 && (ctx->region_type == ORT_WORKSHARE
741 || ctx->region_type == ORT_SIMD
742 || ctx->region_type == ORT_ACC))
743 ctx = ctx->outer_context;
744 if (ctx)
745 omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
748 else if (cfun)
749 record_vars (tmp);
750 else
752 gimple_seq body_seq;
754 /* This case is for nested functions. We need to expose the locals
755 they create. */
756 body_seq = gimple_body (current_function_decl);
757 declare_vars (tmp, gimple_seq_first_stmt (body_seq), false);
763 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
764 nodes that are referenced more than once in GENERIC functions. This is
765 necessary because gimplification (translation into GIMPLE) is performed
766 by modifying tree nodes in-place, so gimplication of a shared node in a
767 first context could generate an invalid GIMPLE form in a second context.
769 This is achieved with a simple mark/copy/unmark algorithm that walks the
770 GENERIC representation top-down, marks nodes with TREE_VISITED the first
771 time it encounters them, duplicates them if they already have TREE_VISITED
772 set, and finally removes the TREE_VISITED marks it has set.
774 The algorithm works only at the function level, i.e. it generates a GENERIC
775 representation of a function with no nodes shared within the function when
776 passed a GENERIC function (except for nodes that are allowed to be shared).
778 At the global level, it is also necessary to unshare tree nodes that are
779 referenced in more than one function, for the same aforementioned reason.
780 This requires some cooperation from the front-end. There are 2 strategies:
782 1. Manual unsharing. The front-end needs to call unshare_expr on every
783 expression that might end up being shared across functions.
785 2. Deep unsharing. This is an extension of regular unsharing. Instead
786 of calling unshare_expr on expressions that might be shared across
787 functions, the front-end pre-marks them with TREE_VISITED. This will
788 ensure that they are unshared on the first reference within functions
789 when the regular unsharing algorithm runs. The counterpart is that
790 this algorithm must look deeper than for manual unsharing, which is
791 specified by LANG_HOOKS_DEEP_UNSHARING.
793 If there are only few specific cases of node sharing across functions, it is
794 probably easier for a front-end to unshare the expressions manually. On the
795 contrary, if the expressions generated at the global level are as widespread
796 as expressions generated within functions, deep unsharing is very likely the
797 way to go. */
799 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
800 These nodes model computations that must be done once. If we were to
801 unshare something like SAVE_EXPR(i++), the gimplification process would
802 create wrong code. However, if DATA is non-null, it must hold a pointer
803 set that is used to unshare the subtrees of these nodes. */
805 static tree
806 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
808 tree t = *tp;
809 enum tree_code code = TREE_CODE (t);
811 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
812 copy their subtrees if we can make sure to do it only once. */
813 if (code == SAVE_EXPR || code == TARGET_EXPR || code == BIND_EXPR)
815 if (data && !((hash_set<tree> *)data)->add (t))
817 else
818 *walk_subtrees = 0;
821 /* Stop at types, decls, constants like copy_tree_r. */
822 else if (TREE_CODE_CLASS (code) == tcc_type
823 || TREE_CODE_CLASS (code) == tcc_declaration
824 || TREE_CODE_CLASS (code) == tcc_constant)
825 *walk_subtrees = 0;
827 /* Cope with the statement expression extension. */
828 else if (code == STATEMENT_LIST)
831 /* Leave the bulk of the work to copy_tree_r itself. */
832 else
833 copy_tree_r (tp, walk_subtrees, NULL);
835 return NULL_TREE;
838 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
839 If *TP has been visited already, then *TP is deeply copied by calling
840 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
842 static tree
843 copy_if_shared_r (tree *tp, int *walk_subtrees, void *data)
845 tree t = *tp;
846 enum tree_code code = TREE_CODE (t);
848 /* Skip types, decls, and constants. But we do want to look at their
849 types and the bounds of types. Mark them as visited so we properly
850 unmark their subtrees on the unmark pass. If we've already seen them,
851 don't look down further. */
852 if (TREE_CODE_CLASS (code) == tcc_type
853 || TREE_CODE_CLASS (code) == tcc_declaration
854 || TREE_CODE_CLASS (code) == tcc_constant)
856 if (TREE_VISITED (t))
857 *walk_subtrees = 0;
858 else
859 TREE_VISITED (t) = 1;
862 /* If this node has been visited already, unshare it and don't look
863 any deeper. */
864 else if (TREE_VISITED (t))
866 walk_tree (tp, mostly_copy_tree_r, data, NULL);
867 *walk_subtrees = 0;
870 /* Otherwise, mark the node as visited and keep looking. */
871 else
872 TREE_VISITED (t) = 1;
874 return NULL_TREE;
877 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
878 copy_if_shared_r callback unmodified. */
880 static inline void
881 copy_if_shared (tree *tp, void *data)
883 walk_tree (tp, copy_if_shared_r, data, NULL);
886 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
887 any nested functions. */
889 static void
890 unshare_body (tree fndecl)
892 struct cgraph_node *cgn = cgraph_node::get (fndecl);
893 /* If the language requires deep unsharing, we need a pointer set to make
894 sure we don't repeatedly unshare subtrees of unshareable nodes. */
895 hash_set<tree> *visited
896 = lang_hooks.deep_unsharing ? new hash_set<tree> : NULL;
898 copy_if_shared (&DECL_SAVED_TREE (fndecl), visited);
899 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl)), visited);
900 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl)), visited);
902 delete visited;
904 if (cgn)
905 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
906 unshare_body (cgn->decl);
909 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
910 Subtrees are walked until the first unvisited node is encountered. */
912 static tree
913 unmark_visited_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
915 tree t = *tp;
917 /* If this node has been visited, unmark it and keep looking. */
918 if (TREE_VISITED (t))
919 TREE_VISITED (t) = 0;
921 /* Otherwise, don't look any deeper. */
922 else
923 *walk_subtrees = 0;
925 return NULL_TREE;
928 /* Unmark the visited trees rooted at *TP. */
930 static inline void
931 unmark_visited (tree *tp)
933 walk_tree (tp, unmark_visited_r, NULL, NULL);
936 /* Likewise, but mark all trees as not visited. */
938 static void
939 unvisit_body (tree fndecl)
941 struct cgraph_node *cgn = cgraph_node::get (fndecl);
943 unmark_visited (&DECL_SAVED_TREE (fndecl));
944 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl)));
945 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl)));
947 if (cgn)
948 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
949 unvisit_body (cgn->decl);
952 /* Unconditionally make an unshared copy of EXPR. This is used when using
953 stored expressions which span multiple functions, such as BINFO_VTABLE,
954 as the normal unsharing process can't tell that they're shared. */
956 tree
957 unshare_expr (tree expr)
959 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
960 return expr;
963 /* Worker for unshare_expr_without_location. */
965 static tree
966 prune_expr_location (tree *tp, int *walk_subtrees, void *)
968 if (EXPR_P (*tp))
969 SET_EXPR_LOCATION (*tp, UNKNOWN_LOCATION);
970 else
971 *walk_subtrees = 0;
972 return NULL_TREE;
975 /* Similar to unshare_expr but also prune all expression locations
976 from EXPR. */
978 tree
979 unshare_expr_without_location (tree expr)
981 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
982 if (EXPR_P (expr))
983 walk_tree (&expr, prune_expr_location, NULL, NULL);
984 return expr;
987 /* Return the EXPR_LOCATION of EXPR, if it (maybe recursively) has
988 one, OR_ELSE otherwise. The location of a STATEMENT_LISTs
989 comprising at least one DEBUG_BEGIN_STMT followed by exactly one
990 EXPR is the location of the EXPR. */
992 static location_t
993 rexpr_location (tree expr, location_t or_else = UNKNOWN_LOCATION)
995 if (!expr)
996 return or_else;
998 if (EXPR_HAS_LOCATION (expr))
999 return EXPR_LOCATION (expr);
1001 if (TREE_CODE (expr) != STATEMENT_LIST)
1002 return or_else;
1004 tree_stmt_iterator i = tsi_start (expr);
1006 bool found = false;
1007 while (!tsi_end_p (i) && TREE_CODE (tsi_stmt (i)) == DEBUG_BEGIN_STMT)
1009 found = true;
1010 tsi_next (&i);
1013 if (!found || !tsi_one_before_end_p (i))
1014 return or_else;
1016 return rexpr_location (tsi_stmt (i), or_else);
1019 /* Return TRUE iff EXPR (maybe recursively) has a location; see
1020 rexpr_location for the potential recursion. */
1022 static inline bool
1023 rexpr_has_location (tree expr)
1025 return rexpr_location (expr) != UNKNOWN_LOCATION;
1029 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1030 contain statements and have a value. Assign its value to a temporary
1031 and give it void_type_node. Return the temporary, or NULL_TREE if
1032 WRAPPER was already void. */
1034 tree
1035 voidify_wrapper_expr (tree wrapper, tree temp)
1037 tree type = TREE_TYPE (wrapper);
1038 if (type && !VOID_TYPE_P (type))
1040 tree *p;
1042 /* Set p to point to the body of the wrapper. Loop until we find
1043 something that isn't a wrapper. */
1044 for (p = &wrapper; p && *p; )
1046 switch (TREE_CODE (*p))
1048 case BIND_EXPR:
1049 TREE_SIDE_EFFECTS (*p) = 1;
1050 TREE_TYPE (*p) = void_type_node;
1051 /* For a BIND_EXPR, the body is operand 1. */
1052 p = &BIND_EXPR_BODY (*p);
1053 break;
1055 case CLEANUP_POINT_EXPR:
1056 case TRY_FINALLY_EXPR:
1057 case TRY_CATCH_EXPR:
1058 TREE_SIDE_EFFECTS (*p) = 1;
1059 TREE_TYPE (*p) = void_type_node;
1060 p = &TREE_OPERAND (*p, 0);
1061 break;
1063 case STATEMENT_LIST:
1065 tree_stmt_iterator i = tsi_last (*p);
1066 TREE_SIDE_EFFECTS (*p) = 1;
1067 TREE_TYPE (*p) = void_type_node;
1068 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
1070 break;
1072 case COMPOUND_EXPR:
1073 /* Advance to the last statement. Set all container types to
1074 void. */
1075 for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
1077 TREE_SIDE_EFFECTS (*p) = 1;
1078 TREE_TYPE (*p) = void_type_node;
1080 break;
1082 case TRANSACTION_EXPR:
1083 TREE_SIDE_EFFECTS (*p) = 1;
1084 TREE_TYPE (*p) = void_type_node;
1085 p = &TRANSACTION_EXPR_BODY (*p);
1086 break;
1088 default:
1089 /* Assume that any tree upon which voidify_wrapper_expr is
1090 directly called is a wrapper, and that its body is op0. */
1091 if (p == &wrapper)
1093 TREE_SIDE_EFFECTS (*p) = 1;
1094 TREE_TYPE (*p) = void_type_node;
1095 p = &TREE_OPERAND (*p, 0);
1096 break;
1098 goto out;
1102 out:
1103 if (p == NULL || IS_EMPTY_STMT (*p))
1104 temp = NULL_TREE;
1105 else if (temp)
1107 /* The wrapper is on the RHS of an assignment that we're pushing
1108 down. */
1109 gcc_assert (TREE_CODE (temp) == INIT_EXPR
1110 || TREE_CODE (temp) == MODIFY_EXPR);
1111 TREE_OPERAND (temp, 1) = *p;
1112 *p = temp;
1114 else
1116 temp = create_tmp_var (type, "retval");
1117 *p = build2 (INIT_EXPR, type, temp, *p);
1120 return temp;
1123 return NULL_TREE;
1126 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1127 a temporary through which they communicate. */
1129 static void
1130 build_stack_save_restore (gcall **save, gcall **restore)
1132 tree tmp_var;
1134 *save = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE), 0);
1135 tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
1136 gimple_call_set_lhs (*save, tmp_var);
1138 *restore
1139 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE),
1140 1, tmp_var);
1143 /* Generate IFN_ASAN_MARK call that poisons shadow of a for DECL variable. */
1145 static tree
1146 build_asan_poison_call_expr (tree decl)
1148 /* Do not poison variables that have size equal to zero. */
1149 tree unit_size = DECL_SIZE_UNIT (decl);
1150 if (zerop (unit_size))
1151 return NULL_TREE;
1153 tree base = build_fold_addr_expr (decl);
1155 return build_call_expr_internal_loc (UNKNOWN_LOCATION, IFN_ASAN_MARK,
1156 void_type_node, 3,
1157 build_int_cst (integer_type_node,
1158 ASAN_MARK_POISON),
1159 base, unit_size);
1162 /* Generate IFN_ASAN_MARK call that would poison or unpoison, depending
1163 on POISON flag, shadow memory of a DECL variable. The call will be
1164 put on location identified by IT iterator, where BEFORE flag drives
1165 position where the stmt will be put. */
1167 static void
1168 asan_poison_variable (tree decl, bool poison, gimple_stmt_iterator *it,
1169 bool before)
1171 /* When within an OMP context, do not emit ASAN_MARK internal fns. */
1172 if (gimplify_omp_ctxp)
1173 return;
1175 tree unit_size = DECL_SIZE_UNIT (decl);
1176 tree base = build_fold_addr_expr (decl);
1178 /* Do not poison variables that have size equal to zero. */
1179 if (zerop (unit_size))
1180 return;
1182 /* It's necessary to have all stack variables aligned to ASAN granularity
1183 bytes. */
1184 if (DECL_ALIGN_UNIT (decl) <= ASAN_SHADOW_GRANULARITY)
1185 SET_DECL_ALIGN (decl, BITS_PER_UNIT * ASAN_SHADOW_GRANULARITY);
1187 HOST_WIDE_INT flags = poison ? ASAN_MARK_POISON : ASAN_MARK_UNPOISON;
1189 gimple *g
1190 = gimple_build_call_internal (IFN_ASAN_MARK, 3,
1191 build_int_cst (integer_type_node, flags),
1192 base, unit_size);
1194 if (before)
1195 gsi_insert_before (it, g, GSI_NEW_STMT);
1196 else
1197 gsi_insert_after (it, g, GSI_NEW_STMT);
1200 /* Generate IFN_ASAN_MARK internal call that depending on POISON flag
1201 either poisons or unpoisons a DECL. Created statement is appended
1202 to SEQ_P gimple sequence. */
1204 static void
1205 asan_poison_variable (tree decl, bool poison, gimple_seq *seq_p)
1207 gimple_stmt_iterator it = gsi_last (*seq_p);
1208 bool before = false;
1210 if (gsi_end_p (it))
1211 before = true;
1213 asan_poison_variable (decl, poison, &it, before);
1216 /* Sort pair of VAR_DECLs A and B by DECL_UID. */
1218 static int
1219 sort_by_decl_uid (const void *a, const void *b)
1221 const tree *t1 = (const tree *)a;
1222 const tree *t2 = (const tree *)b;
1224 int uid1 = DECL_UID (*t1);
1225 int uid2 = DECL_UID (*t2);
1227 if (uid1 < uid2)
1228 return -1;
1229 else if (uid1 > uid2)
1230 return 1;
1231 else
1232 return 0;
1235 /* Generate IFN_ASAN_MARK internal call for all VARIABLES
1236 depending on POISON flag. Created statement is appended
1237 to SEQ_P gimple sequence. */
1239 static void
1240 asan_poison_variables (hash_set<tree> *variables, bool poison, gimple_seq *seq_p)
1242 unsigned c = variables->elements ();
1243 if (c == 0)
1244 return;
1246 auto_vec<tree> sorted_variables (c);
1248 for (hash_set<tree>::iterator it = variables->begin ();
1249 it != variables->end (); ++it)
1250 sorted_variables.safe_push (*it);
1252 sorted_variables.qsort (sort_by_decl_uid);
1254 unsigned i;
1255 tree var;
1256 FOR_EACH_VEC_ELT (sorted_variables, i, var)
1258 asan_poison_variable (var, poison, seq_p);
1260 /* Add use_after_scope_memory attribute for the variable in order
1261 to prevent re-written into SSA. */
1262 if (!lookup_attribute (ASAN_USE_AFTER_SCOPE_ATTRIBUTE,
1263 DECL_ATTRIBUTES (var)))
1264 DECL_ATTRIBUTES (var)
1265 = tree_cons (get_identifier (ASAN_USE_AFTER_SCOPE_ATTRIBUTE),
1266 integer_one_node,
1267 DECL_ATTRIBUTES (var));
1271 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1273 static enum gimplify_status
1274 gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
1276 tree bind_expr = *expr_p;
1277 bool old_keep_stack = gimplify_ctxp->keep_stack;
1278 bool old_save_stack = gimplify_ctxp->save_stack;
1279 tree t;
1280 gbind *bind_stmt;
1281 gimple_seq body, cleanup;
1282 gcall *stack_save;
1283 location_t start_locus = 0, end_locus = 0;
1284 tree ret_clauses = NULL;
1286 tree temp = voidify_wrapper_expr (bind_expr, NULL);
1288 /* Mark variables seen in this bind expr. */
1289 for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
1291 if (VAR_P (t))
1293 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1295 /* Mark variable as local. */
1296 if (ctx && ctx->region_type != ORT_NONE && !DECL_EXTERNAL (t)
1297 && (! DECL_SEEN_IN_BIND_EXPR_P (t)
1298 || splay_tree_lookup (ctx->variables,
1299 (splay_tree_key) t) == NULL))
1301 if (ctx->region_type == ORT_SIMD
1302 && TREE_ADDRESSABLE (t)
1303 && !TREE_STATIC (t))
1304 omp_add_variable (ctx, t, GOVD_PRIVATE | GOVD_SEEN);
1305 else
1306 omp_add_variable (ctx, t, GOVD_LOCAL | GOVD_SEEN);
1309 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
1311 if (DECL_HARD_REGISTER (t) && !is_global_var (t) && cfun)
1312 cfun->has_local_explicit_reg_vars = true;
1315 /* Preliminarily mark non-addressed complex variables as eligible
1316 for promotion to gimple registers. We'll transform their uses
1317 as we find them. */
1318 if ((TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
1319 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
1320 && !TREE_THIS_VOLATILE (t)
1321 && (VAR_P (t) && !DECL_HARD_REGISTER (t))
1322 && !needs_to_live_in_memory (t))
1323 DECL_GIMPLE_REG_P (t) = 1;
1326 bind_stmt = gimple_build_bind (BIND_EXPR_VARS (bind_expr), NULL,
1327 BIND_EXPR_BLOCK (bind_expr));
1328 gimple_push_bind_expr (bind_stmt);
1330 gimplify_ctxp->keep_stack = false;
1331 gimplify_ctxp->save_stack = false;
1333 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1334 body = NULL;
1335 gimplify_stmt (&BIND_EXPR_BODY (bind_expr), &body);
1336 gimple_bind_set_body (bind_stmt, body);
1338 /* Source location wise, the cleanup code (stack_restore and clobbers)
1339 belongs to the end of the block, so propagate what we have. The
1340 stack_save operation belongs to the beginning of block, which we can
1341 infer from the bind_expr directly if the block has no explicit
1342 assignment. */
1343 if (BIND_EXPR_BLOCK (bind_expr))
1345 end_locus = BLOCK_SOURCE_END_LOCATION (BIND_EXPR_BLOCK (bind_expr));
1346 start_locus = BLOCK_SOURCE_LOCATION (BIND_EXPR_BLOCK (bind_expr));
1348 if (start_locus == 0)
1349 start_locus = EXPR_LOCATION (bind_expr);
1351 cleanup = NULL;
1352 stack_save = NULL;
1354 /* If the code both contains VLAs and calls alloca, then we cannot reclaim
1355 the stack space allocated to the VLAs. */
1356 if (gimplify_ctxp->save_stack && !gimplify_ctxp->keep_stack)
1358 gcall *stack_restore;
1360 /* Save stack on entry and restore it on exit. Add a try_finally
1361 block to achieve this. */
1362 build_stack_save_restore (&stack_save, &stack_restore);
1364 gimple_set_location (stack_save, start_locus);
1365 gimple_set_location (stack_restore, end_locus);
1367 gimplify_seq_add_stmt (&cleanup, stack_restore);
1370 /* Add clobbers for all variables that go out of scope. */
1371 for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
1373 if (VAR_P (t)
1374 && !is_global_var (t)
1375 && DECL_CONTEXT (t) == current_function_decl)
1377 if (!DECL_HARD_REGISTER (t)
1378 && !TREE_THIS_VOLATILE (t)
1379 && !DECL_HAS_VALUE_EXPR_P (t)
1380 /* Only care for variables that have to be in memory. Others
1381 will be rewritten into SSA names, hence moved to the
1382 top-level. */
1383 && !is_gimple_reg (t)
1384 && flag_stack_reuse != SR_NONE)
1386 tree clobber = build_constructor (TREE_TYPE (t), NULL);
1387 gimple *clobber_stmt;
1388 TREE_THIS_VOLATILE (clobber) = 1;
1389 clobber_stmt = gimple_build_assign (t, clobber);
1390 gimple_set_location (clobber_stmt, end_locus);
1391 gimplify_seq_add_stmt (&cleanup, clobber_stmt);
1394 if (flag_openacc && oacc_declare_returns != NULL)
1396 tree *c = oacc_declare_returns->get (t);
1397 if (c != NULL)
1399 if (ret_clauses)
1400 OMP_CLAUSE_CHAIN (*c) = ret_clauses;
1402 ret_clauses = *c;
1404 oacc_declare_returns->remove (t);
1406 if (oacc_declare_returns->elements () == 0)
1408 delete oacc_declare_returns;
1409 oacc_declare_returns = NULL;
1415 if (asan_poisoned_variables != NULL
1416 && asan_poisoned_variables->contains (t))
1418 asan_poisoned_variables->remove (t);
1419 asan_poison_variable (t, true, &cleanup);
1422 if (gimplify_ctxp->live_switch_vars != NULL
1423 && gimplify_ctxp->live_switch_vars->contains (t))
1424 gimplify_ctxp->live_switch_vars->remove (t);
1427 if (ret_clauses)
1429 gomp_target *stmt;
1430 gimple_stmt_iterator si = gsi_start (cleanup);
1432 stmt = gimple_build_omp_target (NULL, GF_OMP_TARGET_KIND_OACC_DECLARE,
1433 ret_clauses);
1434 gsi_insert_seq_before_without_update (&si, stmt, GSI_NEW_STMT);
1437 if (cleanup)
1439 gtry *gs;
1440 gimple_seq new_body;
1442 new_body = NULL;
1443 gs = gimple_build_try (gimple_bind_body (bind_stmt), cleanup,
1444 GIMPLE_TRY_FINALLY);
1446 if (stack_save)
1447 gimplify_seq_add_stmt (&new_body, stack_save);
1448 gimplify_seq_add_stmt (&new_body, gs);
1449 gimple_bind_set_body (bind_stmt, new_body);
1452 /* keep_stack propagates all the way up to the outermost BIND_EXPR. */
1453 if (!gimplify_ctxp->keep_stack)
1454 gimplify_ctxp->keep_stack = old_keep_stack;
1455 gimplify_ctxp->save_stack = old_save_stack;
1457 gimple_pop_bind_expr ();
1459 gimplify_seq_add_stmt (pre_p, bind_stmt);
1461 if (temp)
1463 *expr_p = temp;
1464 return GS_OK;
1467 *expr_p = NULL_TREE;
1468 return GS_ALL_DONE;
1471 /* Maybe add early return predict statement to PRE_P sequence. */
1473 static void
1474 maybe_add_early_return_predict_stmt (gimple_seq *pre_p)
1476 /* If we are not in a conditional context, add PREDICT statement. */
1477 if (gimple_conditional_context ())
1479 gimple *predict = gimple_build_predict (PRED_TREE_EARLY_RETURN,
1480 NOT_TAKEN);
1481 gimplify_seq_add_stmt (pre_p, predict);
1485 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1486 GIMPLE value, it is assigned to a new temporary and the statement is
1487 re-written to return the temporary.
1489 PRE_P points to the sequence where side effects that must happen before
1490 STMT should be stored. */
1492 static enum gimplify_status
1493 gimplify_return_expr (tree stmt, gimple_seq *pre_p)
1495 greturn *ret;
1496 tree ret_expr = TREE_OPERAND (stmt, 0);
1497 tree result_decl, result;
1499 if (ret_expr == error_mark_node)
1500 return GS_ERROR;
1502 if (!ret_expr
1503 || TREE_CODE (ret_expr) == RESULT_DECL)
1505 maybe_add_early_return_predict_stmt (pre_p);
1506 greturn *ret = gimple_build_return (ret_expr);
1507 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1508 gimplify_seq_add_stmt (pre_p, ret);
1509 return GS_ALL_DONE;
1512 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1513 result_decl = NULL_TREE;
1514 else
1516 result_decl = TREE_OPERAND (ret_expr, 0);
1518 /* See through a return by reference. */
1519 if (TREE_CODE (result_decl) == INDIRECT_REF)
1520 result_decl = TREE_OPERAND (result_decl, 0);
1522 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
1523 || TREE_CODE (ret_expr) == INIT_EXPR)
1524 && TREE_CODE (result_decl) == RESULT_DECL);
1527 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1528 Recall that aggregate_value_p is FALSE for any aggregate type that is
1529 returned in registers. If we're returning values in registers, then
1530 we don't want to extend the lifetime of the RESULT_DECL, particularly
1531 across another call. In addition, for those aggregates for which
1532 hard_function_value generates a PARALLEL, we'll die during normal
1533 expansion of structure assignments; there's special code in expand_return
1534 to handle this case that does not exist in expand_expr. */
1535 if (!result_decl)
1536 result = NULL_TREE;
1537 else if (aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1539 if (TREE_CODE (DECL_SIZE (result_decl)) != INTEGER_CST)
1541 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl)))
1542 gimplify_type_sizes (TREE_TYPE (result_decl), pre_p);
1543 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1544 should be effectively allocated by the caller, i.e. all calls to
1545 this function must be subject to the Return Slot Optimization. */
1546 gimplify_one_sizepos (&DECL_SIZE (result_decl), pre_p);
1547 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl), pre_p);
1549 result = result_decl;
1551 else if (gimplify_ctxp->return_temp)
1552 result = gimplify_ctxp->return_temp;
1553 else
1555 result = create_tmp_reg (TREE_TYPE (result_decl));
1557 /* ??? With complex control flow (usually involving abnormal edges),
1558 we can wind up warning about an uninitialized value for this. Due
1559 to how this variable is constructed and initialized, this is never
1560 true. Give up and never warn. */
1561 TREE_NO_WARNING (result) = 1;
1563 gimplify_ctxp->return_temp = result;
1566 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1567 Then gimplify the whole thing. */
1568 if (result != result_decl)
1569 TREE_OPERAND (ret_expr, 0) = result;
1571 gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1573 maybe_add_early_return_predict_stmt (pre_p);
1574 ret = gimple_build_return (result);
1575 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1576 gimplify_seq_add_stmt (pre_p, ret);
1578 return GS_ALL_DONE;
1581 /* Gimplify a variable-length array DECL. */
1583 static void
1584 gimplify_vla_decl (tree decl, gimple_seq *seq_p)
1586 /* This is a variable-sized decl. Simplify its size and mark it
1587 for deferred expansion. */
1588 tree t, addr, ptr_type;
1590 gimplify_one_sizepos (&DECL_SIZE (decl), seq_p);
1591 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), seq_p);
1593 /* Don't mess with a DECL_VALUE_EXPR set by the front-end. */
1594 if (DECL_HAS_VALUE_EXPR_P (decl))
1595 return;
1597 /* All occurrences of this decl in final gimplified code will be
1598 replaced by indirection. Setting DECL_VALUE_EXPR does two
1599 things: First, it lets the rest of the gimplifier know what
1600 replacement to use. Second, it lets the debug info know
1601 where to find the value. */
1602 ptr_type = build_pointer_type (TREE_TYPE (decl));
1603 addr = create_tmp_var (ptr_type, get_name (decl));
1604 DECL_IGNORED_P (addr) = 0;
1605 t = build_fold_indirect_ref (addr);
1606 TREE_THIS_NOTRAP (t) = 1;
1607 SET_DECL_VALUE_EXPR (decl, t);
1608 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1610 t = build_alloca_call_expr (DECL_SIZE_UNIT (decl), DECL_ALIGN (decl),
1611 max_int_size_in_bytes (TREE_TYPE (decl)));
1612 /* The call has been built for a variable-sized object. */
1613 CALL_ALLOCA_FOR_VAR_P (t) = 1;
1614 t = fold_convert (ptr_type, t);
1615 t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
1617 gimplify_and_add (t, seq_p);
1620 /* A helper function to be called via walk_tree. Mark all labels under *TP
1621 as being forced. To be called for DECL_INITIAL of static variables. */
1623 static tree
1624 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1626 if (TYPE_P (*tp))
1627 *walk_subtrees = 0;
1628 if (TREE_CODE (*tp) == LABEL_DECL)
1630 FORCED_LABEL (*tp) = 1;
1631 cfun->has_forced_label_in_static = 1;
1634 return NULL_TREE;
1637 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1638 and initialization explicit. */
1640 static enum gimplify_status
1641 gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p)
1643 tree stmt = *stmt_p;
1644 tree decl = DECL_EXPR_DECL (stmt);
1646 *stmt_p = NULL_TREE;
1648 if (TREE_TYPE (decl) == error_mark_node)
1649 return GS_ERROR;
1651 if ((TREE_CODE (decl) == TYPE_DECL
1652 || VAR_P (decl))
1653 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1655 gimplify_type_sizes (TREE_TYPE (decl), seq_p);
1656 if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
1657 gimplify_type_sizes (TREE_TYPE (TREE_TYPE (decl)), seq_p);
1660 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1661 in case its size expressions contain problematic nodes like CALL_EXPR. */
1662 if (TREE_CODE (decl) == TYPE_DECL
1663 && DECL_ORIGINAL_TYPE (decl)
1664 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl)))
1666 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl), seq_p);
1667 if (TREE_CODE (DECL_ORIGINAL_TYPE (decl)) == REFERENCE_TYPE)
1668 gimplify_type_sizes (TREE_TYPE (DECL_ORIGINAL_TYPE (decl)), seq_p);
1671 if (VAR_P (decl) && !DECL_EXTERNAL (decl))
1673 tree init = DECL_INITIAL (decl);
1674 bool is_vla = false;
1676 if (TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1677 || (!TREE_STATIC (decl)
1678 && flag_stack_check == GENERIC_STACK_CHECK
1679 && compare_tree_int (DECL_SIZE_UNIT (decl),
1680 STACK_CHECK_MAX_VAR_SIZE) > 0))
1682 gimplify_vla_decl (decl, seq_p);
1683 is_vla = true;
1686 if (asan_poisoned_variables
1687 && !is_vla
1688 && TREE_ADDRESSABLE (decl)
1689 && !TREE_STATIC (decl)
1690 && !DECL_HAS_VALUE_EXPR_P (decl)
1691 && DECL_ALIGN (decl) <= MAX_SUPPORTED_STACK_ALIGNMENT
1692 && dbg_cnt (asan_use_after_scope))
1694 asan_poisoned_variables->add (decl);
1695 asan_poison_variable (decl, false, seq_p);
1696 if (!DECL_ARTIFICIAL (decl) && gimplify_ctxp->live_switch_vars)
1697 gimplify_ctxp->live_switch_vars->add (decl);
1700 /* Some front ends do not explicitly declare all anonymous
1701 artificial variables. We compensate here by declaring the
1702 variables, though it would be better if the front ends would
1703 explicitly declare them. */
1704 if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1705 && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1706 gimple_add_tmp_var (decl);
1708 if (init && init != error_mark_node)
1710 if (!TREE_STATIC (decl))
1712 DECL_INITIAL (decl) = NULL_TREE;
1713 init = build2 (INIT_EXPR, void_type_node, decl, init);
1714 gimplify_and_add (init, seq_p);
1715 ggc_free (init);
1717 else
1718 /* We must still examine initializers for static variables
1719 as they may contain a label address. */
1720 walk_tree (&init, force_labels_r, NULL, NULL);
1724 return GS_ALL_DONE;
1727 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1728 and replacing the LOOP_EXPR with goto, but if the loop contains an
1729 EXIT_EXPR, we need to append a label for it to jump to. */
1731 static enum gimplify_status
1732 gimplify_loop_expr (tree *expr_p, gimple_seq *pre_p)
1734 tree saved_label = gimplify_ctxp->exit_label;
1735 tree start_label = create_artificial_label (UNKNOWN_LOCATION);
1737 gimplify_seq_add_stmt (pre_p, gimple_build_label (start_label));
1739 gimplify_ctxp->exit_label = NULL_TREE;
1741 gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1743 gimplify_seq_add_stmt (pre_p, gimple_build_goto (start_label));
1745 if (gimplify_ctxp->exit_label)
1746 gimplify_seq_add_stmt (pre_p,
1747 gimple_build_label (gimplify_ctxp->exit_label));
1749 gimplify_ctxp->exit_label = saved_label;
1751 *expr_p = NULL;
1752 return GS_ALL_DONE;
1755 /* Gimplify a statement list onto a sequence. These may be created either
1756 by an enlightened front-end, or by shortcut_cond_expr. */
1758 static enum gimplify_status
1759 gimplify_statement_list (tree *expr_p, gimple_seq *pre_p)
1761 tree temp = voidify_wrapper_expr (*expr_p, NULL);
1763 tree_stmt_iterator i = tsi_start (*expr_p);
1765 while (!tsi_end_p (i))
1767 gimplify_stmt (tsi_stmt_ptr (i), pre_p);
1768 tsi_delink (&i);
1771 if (temp)
1773 *expr_p = temp;
1774 return GS_OK;
1777 return GS_ALL_DONE;
1780 /* Callback for walk_gimple_seq. */
1782 static tree
1783 warn_switch_unreachable_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
1784 struct walk_stmt_info *wi)
1786 gimple *stmt = gsi_stmt (*gsi_p);
1788 *handled_ops_p = true;
1789 switch (gimple_code (stmt))
1791 case GIMPLE_TRY:
1792 /* A compiler-generated cleanup or a user-written try block.
1793 If it's empty, don't dive into it--that would result in
1794 worse location info. */
1795 if (gimple_try_eval (stmt) == NULL)
1797 wi->info = stmt;
1798 return integer_zero_node;
1800 /* Fall through. */
1801 case GIMPLE_BIND:
1802 case GIMPLE_CATCH:
1803 case GIMPLE_EH_FILTER:
1804 case GIMPLE_TRANSACTION:
1805 /* Walk the sub-statements. */
1806 *handled_ops_p = false;
1807 break;
1809 case GIMPLE_DEBUG:
1810 /* Ignore these. We may generate them before declarations that
1811 are never executed. If there's something to warn about,
1812 there will be non-debug stmts too, and we'll catch those. */
1813 break;
1815 case GIMPLE_CALL:
1816 if (gimple_call_internal_p (stmt, IFN_ASAN_MARK))
1818 *handled_ops_p = false;
1819 break;
1821 /* Fall through. */
1822 default:
1823 /* Save the first "real" statement (not a decl/lexical scope/...). */
1824 wi->info = stmt;
1825 return integer_zero_node;
1827 return NULL_TREE;
1830 /* Possibly warn about unreachable statements between switch's controlling
1831 expression and the first case. SEQ is the body of a switch expression. */
1833 static void
1834 maybe_warn_switch_unreachable (gimple_seq seq)
1836 if (!warn_switch_unreachable
1837 /* This warning doesn't play well with Fortran when optimizations
1838 are on. */
1839 || lang_GNU_Fortran ()
1840 || seq == NULL)
1841 return;
1843 struct walk_stmt_info wi;
1844 memset (&wi, 0, sizeof (wi));
1845 walk_gimple_seq (seq, warn_switch_unreachable_r, NULL, &wi);
1846 gimple *stmt = (gimple *) wi.info;
1848 if (stmt && gimple_code (stmt) != GIMPLE_LABEL)
1850 if (gimple_code (stmt) == GIMPLE_GOTO
1851 && TREE_CODE (gimple_goto_dest (stmt)) == LABEL_DECL
1852 && DECL_ARTIFICIAL (gimple_goto_dest (stmt)))
1853 /* Don't warn for compiler-generated gotos. These occur
1854 in Duff's devices, for example. */;
1855 else
1856 warning_at (gimple_location (stmt), OPT_Wswitch_unreachable,
1857 "statement will never be executed");
1862 /* A label entry that pairs label and a location. */
1863 struct label_entry
1865 tree label;
1866 location_t loc;
1869 /* Find LABEL in vector of label entries VEC. */
1871 static struct label_entry *
1872 find_label_entry (const auto_vec<struct label_entry> *vec, tree label)
1874 unsigned int i;
1875 struct label_entry *l;
1877 FOR_EACH_VEC_ELT (*vec, i, l)
1878 if (l->label == label)
1879 return l;
1880 return NULL;
1883 /* Return true if LABEL, a LABEL_DECL, represents a case label
1884 in a vector of labels CASES. */
1886 static bool
1887 case_label_p (const vec<tree> *cases, tree label)
1889 unsigned int i;
1890 tree l;
1892 FOR_EACH_VEC_ELT (*cases, i, l)
1893 if (CASE_LABEL (l) == label)
1894 return true;
1895 return false;
1898 /* Find the last nondebug statement in a scope STMT. */
1900 static gimple *
1901 last_stmt_in_scope (gimple *stmt)
1903 if (!stmt)
1904 return NULL;
1906 switch (gimple_code (stmt))
1908 case GIMPLE_BIND:
1910 gbind *bind = as_a <gbind *> (stmt);
1911 stmt = gimple_seq_last_nondebug_stmt (gimple_bind_body (bind));
1912 return last_stmt_in_scope (stmt);
1915 case GIMPLE_TRY:
1917 gtry *try_stmt = as_a <gtry *> (stmt);
1918 stmt = gimple_seq_last_nondebug_stmt (gimple_try_eval (try_stmt));
1919 gimple *last_eval = last_stmt_in_scope (stmt);
1920 if (gimple_stmt_may_fallthru (last_eval)
1921 && (last_eval == NULL
1922 || !gimple_call_internal_p (last_eval, IFN_FALLTHROUGH))
1923 && gimple_try_kind (try_stmt) == GIMPLE_TRY_FINALLY)
1925 stmt = gimple_seq_last_nondebug_stmt (gimple_try_cleanup (try_stmt));
1926 return last_stmt_in_scope (stmt);
1928 else
1929 return last_eval;
1932 case GIMPLE_DEBUG:
1933 gcc_unreachable ();
1935 default:
1936 return stmt;
1940 /* Collect interesting labels in LABELS and return the statement preceding
1941 another case label, or a user-defined label. */
1943 static gimple *
1944 collect_fallthrough_labels (gimple_stmt_iterator *gsi_p,
1945 auto_vec <struct label_entry> *labels)
1947 gimple *prev = NULL;
1951 if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_BIND)
1953 /* Recognize the special GIMPLE_BIND added by gimplify_switch_expr,
1954 which starts on a GIMPLE_SWITCH and ends with a break label.
1955 Handle that as a single statement that can fall through. */
1956 gbind *bind = as_a <gbind *> (gsi_stmt (*gsi_p));
1957 gimple *first = gimple_seq_first_stmt (gimple_bind_body (bind));
1958 gimple *last = gimple_seq_last_stmt (gimple_bind_body (bind));
1959 if (last
1960 && gimple_code (first) == GIMPLE_SWITCH
1961 && gimple_code (last) == GIMPLE_LABEL)
1963 tree label = gimple_label_label (as_a <glabel *> (last));
1964 if (SWITCH_BREAK_LABEL_P (label))
1966 prev = bind;
1967 gsi_next (gsi_p);
1968 continue;
1972 if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_BIND
1973 || gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_TRY)
1975 /* Nested scope. Only look at the last statement of
1976 the innermost scope. */
1977 location_t bind_loc = gimple_location (gsi_stmt (*gsi_p));
1978 gimple *last = last_stmt_in_scope (gsi_stmt (*gsi_p));
1979 if (last)
1981 prev = last;
1982 /* It might be a label without a location. Use the
1983 location of the scope then. */
1984 if (!gimple_has_location (prev))
1985 gimple_set_location (prev, bind_loc);
1987 gsi_next (gsi_p);
1988 continue;
1991 /* Ifs are tricky. */
1992 if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_COND)
1994 gcond *cond_stmt = as_a <gcond *> (gsi_stmt (*gsi_p));
1995 tree false_lab = gimple_cond_false_label (cond_stmt);
1996 location_t if_loc = gimple_location (cond_stmt);
1998 /* If we have e.g.
1999 if (i > 1) goto <D.2259>; else goto D;
2000 we can't do much with the else-branch. */
2001 if (!DECL_ARTIFICIAL (false_lab))
2002 break;
2004 /* Go on until the false label, then one step back. */
2005 for (; !gsi_end_p (*gsi_p); gsi_next (gsi_p))
2007 gimple *stmt = gsi_stmt (*gsi_p);
2008 if (gimple_code (stmt) == GIMPLE_LABEL
2009 && gimple_label_label (as_a <glabel *> (stmt)) == false_lab)
2010 break;
2013 /* Not found? Oops. */
2014 if (gsi_end_p (*gsi_p))
2015 break;
2017 struct label_entry l = { false_lab, if_loc };
2018 labels->safe_push (l);
2020 /* Go to the last statement of the then branch. */
2021 gsi_prev (gsi_p);
2023 /* if (i != 0) goto <D.1759>; else goto <D.1760>;
2024 <D.1759>:
2025 <stmt>;
2026 goto <D.1761>;
2027 <D.1760>:
2029 if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_GOTO
2030 && !gimple_has_location (gsi_stmt (*gsi_p)))
2032 /* Look at the statement before, it might be
2033 attribute fallthrough, in which case don't warn. */
2034 gsi_prev (gsi_p);
2035 bool fallthru_before_dest
2036 = gimple_call_internal_p (gsi_stmt (*gsi_p), IFN_FALLTHROUGH);
2037 gsi_next (gsi_p);
2038 tree goto_dest = gimple_goto_dest (gsi_stmt (*gsi_p));
2039 if (!fallthru_before_dest)
2041 struct label_entry l = { goto_dest, if_loc };
2042 labels->safe_push (l);
2045 /* And move back. */
2046 gsi_next (gsi_p);
2049 /* Remember the last statement. Skip labels that are of no interest
2050 to us. */
2051 if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_LABEL)
2053 tree label = gimple_label_label (as_a <glabel *> (gsi_stmt (*gsi_p)));
2054 if (find_label_entry (labels, label))
2055 prev = gsi_stmt (*gsi_p);
2057 else if (gimple_call_internal_p (gsi_stmt (*gsi_p), IFN_ASAN_MARK))
2059 else if (!is_gimple_debug (gsi_stmt (*gsi_p)))
2060 prev = gsi_stmt (*gsi_p);
2061 gsi_next (gsi_p);
2063 while (!gsi_end_p (*gsi_p)
2064 /* Stop if we find a case or a user-defined label. */
2065 && (gimple_code (gsi_stmt (*gsi_p)) != GIMPLE_LABEL
2066 || !gimple_has_location (gsi_stmt (*gsi_p))));
2068 return prev;
2071 /* Return true if the switch fallthough warning should occur. LABEL is
2072 the label statement that we're falling through to. */
2074 static bool
2075 should_warn_for_implicit_fallthrough (gimple_stmt_iterator *gsi_p, tree label)
2077 gimple_stmt_iterator gsi = *gsi_p;
2079 /* Don't warn if the label is marked with a "falls through" comment. */
2080 if (FALLTHROUGH_LABEL_P (label))
2081 return false;
2083 /* Don't warn for non-case labels followed by a statement:
2084 case 0:
2085 foo ();
2086 label:
2087 bar ();
2088 as these are likely intentional. */
2089 if (!case_label_p (&gimplify_ctxp->case_labels, label))
2091 tree l;
2092 while (!gsi_end_p (gsi)
2093 && gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL
2094 && (l = gimple_label_label (as_a <glabel *> (gsi_stmt (gsi))))
2095 && !case_label_p (&gimplify_ctxp->case_labels, l))
2096 gsi_next_nondebug (&gsi);
2097 if (gsi_end_p (gsi) || gimple_code (gsi_stmt (gsi)) != GIMPLE_LABEL)
2098 return false;
2101 /* Don't warn for terminated branches, i.e. when the subsequent case labels
2102 immediately breaks. */
2103 gsi = *gsi_p;
2105 /* Skip all immediately following labels. */
2106 while (!gsi_end_p (gsi)
2107 && (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL
2108 || gimple_code (gsi_stmt (gsi)) == GIMPLE_PREDICT))
2109 gsi_next_nondebug (&gsi);
2111 /* { ... something; default:; } */
2112 if (gsi_end_p (gsi)
2113 /* { ... something; default: break; } or
2114 { ... something; default: goto L; } */
2115 || gimple_code (gsi_stmt (gsi)) == GIMPLE_GOTO
2116 /* { ... something; default: return; } */
2117 || gimple_code (gsi_stmt (gsi)) == GIMPLE_RETURN)
2118 return false;
2120 return true;
2123 /* Callback for walk_gimple_seq. */
2125 static tree
2126 warn_implicit_fallthrough_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
2127 struct walk_stmt_info *)
2129 gimple *stmt = gsi_stmt (*gsi_p);
2131 *handled_ops_p = true;
2132 switch (gimple_code (stmt))
2134 case GIMPLE_TRY:
2135 case GIMPLE_BIND:
2136 case GIMPLE_CATCH:
2137 case GIMPLE_EH_FILTER:
2138 case GIMPLE_TRANSACTION:
2139 /* Walk the sub-statements. */
2140 *handled_ops_p = false;
2141 break;
2143 /* Find a sequence of form:
2145 GIMPLE_LABEL
2146 [...]
2147 <may fallthru stmt>
2148 GIMPLE_LABEL
2150 and possibly warn. */
2151 case GIMPLE_LABEL:
2153 /* Found a label. Skip all immediately following labels. */
2154 while (!gsi_end_p (*gsi_p)
2155 && gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_LABEL)
2156 gsi_next_nondebug (gsi_p);
2158 /* There might be no more statements. */
2159 if (gsi_end_p (*gsi_p))
2160 return integer_zero_node;
2162 /* Vector of labels that fall through. */
2163 auto_vec <struct label_entry> labels;
2164 gimple *prev = collect_fallthrough_labels (gsi_p, &labels);
2166 /* There might be no more statements. */
2167 if (gsi_end_p (*gsi_p))
2168 return integer_zero_node;
2170 gimple *next = gsi_stmt (*gsi_p);
2171 tree label;
2172 /* If what follows is a label, then we may have a fallthrough. */
2173 if (gimple_code (next) == GIMPLE_LABEL
2174 && gimple_has_location (next)
2175 && (label = gimple_label_label (as_a <glabel *> (next)))
2176 && prev != NULL)
2178 struct label_entry *l;
2179 bool warned_p = false;
2180 if (!should_warn_for_implicit_fallthrough (gsi_p, label))
2181 /* Quiet. */;
2182 else if (gimple_code (prev) == GIMPLE_LABEL
2183 && (label = gimple_label_label (as_a <glabel *> (prev)))
2184 && (l = find_label_entry (&labels, label)))
2185 warned_p = warning_at (l->loc, OPT_Wimplicit_fallthrough_,
2186 "this statement may fall through");
2187 else if (!gimple_call_internal_p (prev, IFN_FALLTHROUGH)
2188 /* Try to be clever and don't warn when the statement
2189 can't actually fall through. */
2190 && gimple_stmt_may_fallthru (prev)
2191 && gimple_has_location (prev))
2192 warned_p = warning_at (gimple_location (prev),
2193 OPT_Wimplicit_fallthrough_,
2194 "this statement may fall through");
2195 if (warned_p)
2196 inform (gimple_location (next), "here");
2198 /* Mark this label as processed so as to prevent multiple
2199 warnings in nested switches. */
2200 FALLTHROUGH_LABEL_P (label) = true;
2202 /* So that next warn_implicit_fallthrough_r will start looking for
2203 a new sequence starting with this label. */
2204 gsi_prev (gsi_p);
2207 break;
2208 default:
2209 break;
2211 return NULL_TREE;
2214 /* Warn when a switch case falls through. */
2216 static void
2217 maybe_warn_implicit_fallthrough (gimple_seq seq)
2219 if (!warn_implicit_fallthrough)
2220 return;
2222 /* This warning is meant for C/C++/ObjC/ObjC++ only. */
2223 if (!(lang_GNU_C ()
2224 || lang_GNU_CXX ()
2225 || lang_GNU_OBJC ()))
2226 return;
2228 struct walk_stmt_info wi;
2229 memset (&wi, 0, sizeof (wi));
2230 walk_gimple_seq (seq, warn_implicit_fallthrough_r, NULL, &wi);
2233 /* Callback for walk_gimple_seq. */
2235 static tree
2236 expand_FALLTHROUGH_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
2237 struct walk_stmt_info *)
2239 gimple *stmt = gsi_stmt (*gsi_p);
2241 *handled_ops_p = true;
2242 switch (gimple_code (stmt))
2244 case GIMPLE_TRY:
2245 case GIMPLE_BIND:
2246 case GIMPLE_CATCH:
2247 case GIMPLE_EH_FILTER:
2248 case GIMPLE_TRANSACTION:
2249 /* Walk the sub-statements. */
2250 *handled_ops_p = false;
2251 break;
2252 case GIMPLE_CALL:
2253 if (gimple_call_internal_p (stmt, IFN_FALLTHROUGH))
2255 gsi_remove (gsi_p, true);
2256 if (gsi_end_p (*gsi_p))
2257 return integer_zero_node;
2259 bool found = false;
2260 location_t loc = gimple_location (stmt);
2262 gimple_stmt_iterator gsi2 = *gsi_p;
2263 stmt = gsi_stmt (gsi2);
2264 if (gimple_code (stmt) == GIMPLE_GOTO && !gimple_has_location (stmt))
2266 /* Go on until the artificial label. */
2267 tree goto_dest = gimple_goto_dest (stmt);
2268 for (; !gsi_end_p (gsi2); gsi_next (&gsi2))
2270 if (gimple_code (gsi_stmt (gsi2)) == GIMPLE_LABEL
2271 && gimple_label_label (as_a <glabel *> (gsi_stmt (gsi2)))
2272 == goto_dest)
2273 break;
2276 /* Not found? Stop. */
2277 if (gsi_end_p (gsi2))
2278 break;
2280 /* Look one past it. */
2281 gsi_next (&gsi2);
2284 /* We're looking for a case label or default label here. */
2285 while (!gsi_end_p (gsi2))
2287 stmt = gsi_stmt (gsi2);
2288 if (gimple_code (stmt) == GIMPLE_LABEL)
2290 tree label = gimple_label_label (as_a <glabel *> (stmt));
2291 if (gimple_has_location (stmt) && DECL_ARTIFICIAL (label))
2293 found = true;
2294 break;
2297 else if (gimple_call_internal_p (stmt, IFN_ASAN_MARK))
2299 else if (!is_gimple_debug (stmt))
2300 /* Anything else is not expected. */
2301 break;
2302 gsi_next (&gsi2);
2304 if (!found)
2305 warning_at (loc, 0, "attribute %<fallthrough%> not preceding "
2306 "a case label or default label");
2308 break;
2309 default:
2310 break;
2312 return NULL_TREE;
2315 /* Expand all FALLTHROUGH () calls in SEQ. */
2317 static void
2318 expand_FALLTHROUGH (gimple_seq *seq_p)
2320 struct walk_stmt_info wi;
2321 memset (&wi, 0, sizeof (wi));
2322 walk_gimple_seq_mod (seq_p, expand_FALLTHROUGH_r, NULL, &wi);
2326 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
2327 branch to. */
2329 static enum gimplify_status
2330 gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
2332 tree switch_expr = *expr_p;
2333 gimple_seq switch_body_seq = NULL;
2334 enum gimplify_status ret;
2335 tree index_type = TREE_TYPE (switch_expr);
2336 if (index_type == NULL_TREE)
2337 index_type = TREE_TYPE (SWITCH_COND (switch_expr));
2339 ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, is_gimple_val,
2340 fb_rvalue);
2341 if (ret == GS_ERROR || ret == GS_UNHANDLED)
2342 return ret;
2344 if (SWITCH_BODY (switch_expr))
2346 vec<tree> labels;
2347 vec<tree> saved_labels;
2348 hash_set<tree> *saved_live_switch_vars = NULL;
2349 tree default_case = NULL_TREE;
2350 gswitch *switch_stmt;
2352 /* Save old labels, get new ones from body, then restore the old
2353 labels. Save all the things from the switch body to append after. */
2354 saved_labels = gimplify_ctxp->case_labels;
2355 gimplify_ctxp->case_labels.create (8);
2357 /* Do not create live_switch_vars if SWITCH_BODY is not a BIND_EXPR. */
2358 saved_live_switch_vars = gimplify_ctxp->live_switch_vars;
2359 tree_code body_type = TREE_CODE (SWITCH_BODY (switch_expr));
2360 if (body_type == BIND_EXPR || body_type == STATEMENT_LIST)
2361 gimplify_ctxp->live_switch_vars = new hash_set<tree> (4);
2362 else
2363 gimplify_ctxp->live_switch_vars = NULL;
2365 bool old_in_switch_expr = gimplify_ctxp->in_switch_expr;
2366 gimplify_ctxp->in_switch_expr = true;
2368 gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq);
2370 gimplify_ctxp->in_switch_expr = old_in_switch_expr;
2371 maybe_warn_switch_unreachable (switch_body_seq);
2372 maybe_warn_implicit_fallthrough (switch_body_seq);
2373 /* Only do this for the outermost GIMPLE_SWITCH. */
2374 if (!gimplify_ctxp->in_switch_expr)
2375 expand_FALLTHROUGH (&switch_body_seq);
2377 labels = gimplify_ctxp->case_labels;
2378 gimplify_ctxp->case_labels = saved_labels;
2380 if (gimplify_ctxp->live_switch_vars)
2382 gcc_assert (gimplify_ctxp->live_switch_vars->elements () == 0);
2383 delete gimplify_ctxp->live_switch_vars;
2385 gimplify_ctxp->live_switch_vars = saved_live_switch_vars;
2387 preprocess_case_label_vec_for_gimple (labels, index_type,
2388 &default_case);
2390 bool add_bind = false;
2391 if (!default_case)
2393 glabel *new_default;
2395 default_case
2396 = build_case_label (NULL_TREE, NULL_TREE,
2397 create_artificial_label (UNKNOWN_LOCATION));
2398 if (old_in_switch_expr)
2400 SWITCH_BREAK_LABEL_P (CASE_LABEL (default_case)) = 1;
2401 add_bind = true;
2403 new_default = gimple_build_label (CASE_LABEL (default_case));
2404 gimplify_seq_add_stmt (&switch_body_seq, new_default);
2406 else if (old_in_switch_expr)
2408 gimple *last = gimple_seq_last_stmt (switch_body_seq);
2409 if (last && gimple_code (last) == GIMPLE_LABEL)
2411 tree label = gimple_label_label (as_a <glabel *> (last));
2412 if (SWITCH_BREAK_LABEL_P (label))
2413 add_bind = true;
2417 switch_stmt = gimple_build_switch (SWITCH_COND (switch_expr),
2418 default_case, labels);
2419 /* For the benefit of -Wimplicit-fallthrough, if switch_body_seq
2420 ends with a GIMPLE_LABEL holding SWITCH_BREAK_LABEL_P LABEL_DECL,
2421 wrap the GIMPLE_SWITCH up to that GIMPLE_LABEL into a GIMPLE_BIND,
2422 so that we can easily find the start and end of the switch
2423 statement. */
2424 if (add_bind)
2426 gimple_seq bind_body = NULL;
2427 gimplify_seq_add_stmt (&bind_body, switch_stmt);
2428 gimple_seq_add_seq (&bind_body, switch_body_seq);
2429 gbind *bind = gimple_build_bind (NULL_TREE, bind_body, NULL_TREE);
2430 gimple_set_location (bind, EXPR_LOCATION (switch_expr));
2431 gimplify_seq_add_stmt (pre_p, bind);
2433 else
2435 gimplify_seq_add_stmt (pre_p, switch_stmt);
2436 gimplify_seq_add_seq (pre_p, switch_body_seq);
2438 labels.release ();
2440 else
2441 gcc_unreachable ();
2443 return GS_ALL_DONE;
2446 /* Gimplify the LABEL_EXPR pointed to by EXPR_P. */
2448 static enum gimplify_status
2449 gimplify_label_expr (tree *expr_p, gimple_seq *pre_p)
2451 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
2452 == current_function_decl);
2454 tree label = LABEL_EXPR_LABEL (*expr_p);
2455 glabel *label_stmt = gimple_build_label (label);
2456 gimple_set_location (label_stmt, EXPR_LOCATION (*expr_p));
2457 gimplify_seq_add_stmt (pre_p, label_stmt);
2459 if (lookup_attribute ("cold", DECL_ATTRIBUTES (label)))
2460 gimple_seq_add_stmt (pre_p, gimple_build_predict (PRED_COLD_LABEL,
2461 NOT_TAKEN));
2462 else if (lookup_attribute ("hot", DECL_ATTRIBUTES (label)))
2463 gimple_seq_add_stmt (pre_p, gimple_build_predict (PRED_HOT_LABEL,
2464 TAKEN));
2466 return GS_ALL_DONE;
2469 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
2471 static enum gimplify_status
2472 gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
2474 struct gimplify_ctx *ctxp;
2475 glabel *label_stmt;
2477 /* Invalid programs can play Duff's Device type games with, for example,
2478 #pragma omp parallel. At least in the C front end, we don't
2479 detect such invalid branches until after gimplification, in the
2480 diagnose_omp_blocks pass. */
2481 for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
2482 if (ctxp->case_labels.exists ())
2483 break;
2485 label_stmt = gimple_build_label (CASE_LABEL (*expr_p));
2486 gimple_set_location (label_stmt, EXPR_LOCATION (*expr_p));
2487 ctxp->case_labels.safe_push (*expr_p);
2488 gimplify_seq_add_stmt (pre_p, label_stmt);
2490 return GS_ALL_DONE;
2493 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
2494 if necessary. */
2496 tree
2497 build_and_jump (tree *label_p)
2499 if (label_p == NULL)
2500 /* If there's nowhere to jump, just fall through. */
2501 return NULL_TREE;
2503 if (*label_p == NULL_TREE)
2505 tree label = create_artificial_label (UNKNOWN_LOCATION);
2506 *label_p = label;
2509 return build1 (GOTO_EXPR, void_type_node, *label_p);
2512 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
2513 This also involves building a label to jump to and communicating it to
2514 gimplify_loop_expr through gimplify_ctxp->exit_label. */
2516 static enum gimplify_status
2517 gimplify_exit_expr (tree *expr_p)
2519 tree cond = TREE_OPERAND (*expr_p, 0);
2520 tree expr;
2522 expr = build_and_jump (&gimplify_ctxp->exit_label);
2523 expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
2524 *expr_p = expr;
2526 return GS_OK;
2529 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
2530 different from its canonical type, wrap the whole thing inside a
2531 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
2532 type.
2534 The canonical type of a COMPONENT_REF is the type of the field being
2535 referenced--unless the field is a bit-field which can be read directly
2536 in a smaller mode, in which case the canonical type is the
2537 sign-appropriate type corresponding to that mode. */
2539 static void
2540 canonicalize_component_ref (tree *expr_p)
2542 tree expr = *expr_p;
2543 tree type;
2545 gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
2547 if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
2548 type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
2549 else
2550 type = TREE_TYPE (TREE_OPERAND (expr, 1));
2552 /* One could argue that all the stuff below is not necessary for
2553 the non-bitfield case and declare it a FE error if type
2554 adjustment would be needed. */
2555 if (TREE_TYPE (expr) != type)
2557 #ifdef ENABLE_TYPES_CHECKING
2558 tree old_type = TREE_TYPE (expr);
2559 #endif
2560 int type_quals;
2562 /* We need to preserve qualifiers and propagate them from
2563 operand 0. */
2564 type_quals = TYPE_QUALS (type)
2565 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
2566 if (TYPE_QUALS (type) != type_quals)
2567 type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
2569 /* Set the type of the COMPONENT_REF to the underlying type. */
2570 TREE_TYPE (expr) = type;
2572 #ifdef ENABLE_TYPES_CHECKING
2573 /* It is now a FE error, if the conversion from the canonical
2574 type to the original expression type is not useless. */
2575 gcc_assert (useless_type_conversion_p (old_type, type));
2576 #endif
2580 /* If a NOP conversion is changing a pointer to array of foo to a pointer
2581 to foo, embed that change in the ADDR_EXPR by converting
2582 T array[U];
2583 (T *)&array
2585 &array[L]
2586 where L is the lower bound. For simplicity, only do this for constant
2587 lower bound.
2588 The constraint is that the type of &array[L] is trivially convertible
2589 to T *. */
2591 static void
2592 canonicalize_addr_expr (tree *expr_p)
2594 tree expr = *expr_p;
2595 tree addr_expr = TREE_OPERAND (expr, 0);
2596 tree datype, ddatype, pddatype;
2598 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
2599 if (!POINTER_TYPE_P (TREE_TYPE (expr))
2600 || TREE_CODE (addr_expr) != ADDR_EXPR)
2601 return;
2603 /* The addr_expr type should be a pointer to an array. */
2604 datype = TREE_TYPE (TREE_TYPE (addr_expr));
2605 if (TREE_CODE (datype) != ARRAY_TYPE)
2606 return;
2608 /* The pointer to element type shall be trivially convertible to
2609 the expression pointer type. */
2610 ddatype = TREE_TYPE (datype);
2611 pddatype = build_pointer_type (ddatype);
2612 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)),
2613 pddatype))
2614 return;
2616 /* The lower bound and element sizes must be constant. */
2617 if (!TYPE_SIZE_UNIT (ddatype)
2618 || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
2619 || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
2620 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
2621 return;
2623 /* All checks succeeded. Build a new node to merge the cast. */
2624 *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
2625 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
2626 NULL_TREE, NULL_TREE);
2627 *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
2629 /* We can have stripped a required restrict qualifier above. */
2630 if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
2631 *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
2634 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
2635 underneath as appropriate. */
2637 static enum gimplify_status
2638 gimplify_conversion (tree *expr_p)
2640 location_t loc = EXPR_LOCATION (*expr_p);
2641 gcc_assert (CONVERT_EXPR_P (*expr_p));
2643 /* Then strip away all but the outermost conversion. */
2644 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
2646 /* And remove the outermost conversion if it's useless. */
2647 if (tree_ssa_useless_type_conversion (*expr_p))
2648 *expr_p = TREE_OPERAND (*expr_p, 0);
2650 /* If we still have a conversion at the toplevel,
2651 then canonicalize some constructs. */
2652 if (CONVERT_EXPR_P (*expr_p))
2654 tree sub = TREE_OPERAND (*expr_p, 0);
2656 /* If a NOP conversion is changing the type of a COMPONENT_REF
2657 expression, then canonicalize its type now in order to expose more
2658 redundant conversions. */
2659 if (TREE_CODE (sub) == COMPONENT_REF)
2660 canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
2662 /* If a NOP conversion is changing a pointer to array of foo
2663 to a pointer to foo, embed that change in the ADDR_EXPR. */
2664 else if (TREE_CODE (sub) == ADDR_EXPR)
2665 canonicalize_addr_expr (expr_p);
2668 /* If we have a conversion to a non-register type force the
2669 use of a VIEW_CONVERT_EXPR instead. */
2670 if (CONVERT_EXPR_P (*expr_p) && !is_gimple_reg_type (TREE_TYPE (*expr_p)))
2671 *expr_p = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (*expr_p),
2672 TREE_OPERAND (*expr_p, 0));
2674 /* Canonicalize CONVERT_EXPR to NOP_EXPR. */
2675 if (TREE_CODE (*expr_p) == CONVERT_EXPR)
2676 TREE_SET_CODE (*expr_p, NOP_EXPR);
2678 return GS_OK;
2681 /* Nonlocal VLAs seen in the current function. */
2682 static hash_set<tree> *nonlocal_vlas;
2684 /* The VAR_DECLs created for nonlocal VLAs for debug info purposes. */
2685 static tree nonlocal_vla_vars;
2687 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
2688 DECL_VALUE_EXPR, and it's worth re-examining things. */
2690 static enum gimplify_status
2691 gimplify_var_or_parm_decl (tree *expr_p)
2693 tree decl = *expr_p;
2695 /* ??? If this is a local variable, and it has not been seen in any
2696 outer BIND_EXPR, then it's probably the result of a duplicate
2697 declaration, for which we've already issued an error. It would
2698 be really nice if the front end wouldn't leak these at all.
2699 Currently the only known culprit is C++ destructors, as seen
2700 in g++.old-deja/g++.jason/binding.C. */
2701 if (VAR_P (decl)
2702 && !DECL_SEEN_IN_BIND_EXPR_P (decl)
2703 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
2704 && decl_function_context (decl) == current_function_decl)
2706 gcc_assert (seen_error ());
2707 return GS_ERROR;
2710 /* When within an OMP context, notice uses of variables. */
2711 if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
2712 return GS_ALL_DONE;
2714 /* If the decl is an alias for another expression, substitute it now. */
2715 if (DECL_HAS_VALUE_EXPR_P (decl))
2717 tree value_expr = DECL_VALUE_EXPR (decl);
2719 /* For referenced nonlocal VLAs add a decl for debugging purposes
2720 to the current function. */
2721 if (VAR_P (decl)
2722 && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
2723 && nonlocal_vlas != NULL
2724 && TREE_CODE (value_expr) == INDIRECT_REF
2725 && TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
2726 && decl_function_context (decl) != current_function_decl)
2728 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
2729 while (ctx
2730 && (ctx->region_type == ORT_WORKSHARE
2731 || ctx->region_type == ORT_SIMD
2732 || ctx->region_type == ORT_ACC))
2733 ctx = ctx->outer_context;
2734 if (!ctx && !nonlocal_vlas->add (decl))
2736 tree copy = copy_node (decl);
2738 lang_hooks.dup_lang_specific_decl (copy);
2739 SET_DECL_RTL (copy, 0);
2740 TREE_USED (copy) = 1;
2741 DECL_CHAIN (copy) = nonlocal_vla_vars;
2742 nonlocal_vla_vars = copy;
2743 SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
2744 DECL_HAS_VALUE_EXPR_P (copy) = 1;
2748 *expr_p = unshare_expr (value_expr);
2749 return GS_OK;
2752 return GS_ALL_DONE;
2755 /* Recalculate the value of the TREE_SIDE_EFFECTS flag for T. */
2757 static void
2758 recalculate_side_effects (tree t)
2760 enum tree_code code = TREE_CODE (t);
2761 int len = TREE_OPERAND_LENGTH (t);
2762 int i;
2764 switch (TREE_CODE_CLASS (code))
2766 case tcc_expression:
2767 switch (code)
2769 case INIT_EXPR:
2770 case MODIFY_EXPR:
2771 case VA_ARG_EXPR:
2772 case PREDECREMENT_EXPR:
2773 case PREINCREMENT_EXPR:
2774 case POSTDECREMENT_EXPR:
2775 case POSTINCREMENT_EXPR:
2776 /* All of these have side-effects, no matter what their
2777 operands are. */
2778 return;
2780 default:
2781 break;
2783 /* Fall through. */
2785 case tcc_comparison: /* a comparison expression */
2786 case tcc_unary: /* a unary arithmetic expression */
2787 case tcc_binary: /* a binary arithmetic expression */
2788 case tcc_reference: /* a reference */
2789 case tcc_vl_exp: /* a function call */
2790 TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
2791 for (i = 0; i < len; ++i)
2793 tree op = TREE_OPERAND (t, i);
2794 if (op && TREE_SIDE_EFFECTS (op))
2795 TREE_SIDE_EFFECTS (t) = 1;
2797 break;
2799 case tcc_constant:
2800 /* No side-effects. */
2801 return;
2803 default:
2804 gcc_unreachable ();
2808 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
2809 node *EXPR_P.
2811 compound_lval
2812 : min_lval '[' val ']'
2813 | min_lval '.' ID
2814 | compound_lval '[' val ']'
2815 | compound_lval '.' ID
2817 This is not part of the original SIMPLE definition, which separates
2818 array and member references, but it seems reasonable to handle them
2819 together. Also, this way we don't run into problems with union
2820 aliasing; gcc requires that for accesses through a union to alias, the
2821 union reference must be explicit, which was not always the case when we
2822 were splitting up array and member refs.
2824 PRE_P points to the sequence where side effects that must happen before
2825 *EXPR_P should be stored.
2827 POST_P points to the sequence where side effects that must happen after
2828 *EXPR_P should be stored. */
2830 static enum gimplify_status
2831 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2832 fallback_t fallback)
2834 tree *p;
2835 enum gimplify_status ret = GS_ALL_DONE, tret;
2836 int i;
2837 location_t loc = EXPR_LOCATION (*expr_p);
2838 tree expr = *expr_p;
2840 /* Create a stack of the subexpressions so later we can walk them in
2841 order from inner to outer. */
2842 auto_vec<tree, 10> expr_stack;
2844 /* We can handle anything that get_inner_reference can deal with. */
2845 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
2847 restart:
2848 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2849 if (TREE_CODE (*p) == INDIRECT_REF)
2850 *p = fold_indirect_ref_loc (loc, *p);
2852 if (handled_component_p (*p))
2854 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2855 additional COMPONENT_REFs. */
2856 else if ((VAR_P (*p) || TREE_CODE (*p) == PARM_DECL)
2857 && gimplify_var_or_parm_decl (p) == GS_OK)
2858 goto restart;
2859 else
2860 break;
2862 expr_stack.safe_push (*p);
2865 gcc_assert (expr_stack.length ());
2867 /* Now EXPR_STACK is a stack of pointers to all the refs we've
2868 walked through and P points to the innermost expression.
2870 Java requires that we elaborated nodes in source order. That
2871 means we must gimplify the inner expression followed by each of
2872 the indices, in order. But we can't gimplify the inner
2873 expression until we deal with any variable bounds, sizes, or
2874 positions in order to deal with PLACEHOLDER_EXPRs.
2876 So we do this in three steps. First we deal with the annotations
2877 for any variables in the components, then we gimplify the base,
2878 then we gimplify any indices, from left to right. */
2879 for (i = expr_stack.length () - 1; i >= 0; i--)
2881 tree t = expr_stack[i];
2883 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2885 /* Gimplify the low bound and element type size and put them into
2886 the ARRAY_REF. If these values are set, they have already been
2887 gimplified. */
2888 if (TREE_OPERAND (t, 2) == NULL_TREE)
2890 tree low = unshare_expr (array_ref_low_bound (t));
2891 if (!is_gimple_min_invariant (low))
2893 TREE_OPERAND (t, 2) = low;
2894 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2895 post_p, is_gimple_reg,
2896 fb_rvalue);
2897 ret = MIN (ret, tret);
2900 else
2902 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2903 is_gimple_reg, fb_rvalue);
2904 ret = MIN (ret, tret);
2907 if (TREE_OPERAND (t, 3) == NULL_TREE)
2909 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
2910 tree elmt_size = unshare_expr (array_ref_element_size (t));
2911 tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
2913 /* Divide the element size by the alignment of the element
2914 type (above). */
2915 elmt_size
2916 = size_binop_loc (loc, EXACT_DIV_EXPR, elmt_size, factor);
2918 if (!is_gimple_min_invariant (elmt_size))
2920 TREE_OPERAND (t, 3) = elmt_size;
2921 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
2922 post_p, is_gimple_reg,
2923 fb_rvalue);
2924 ret = MIN (ret, tret);
2927 else
2929 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
2930 is_gimple_reg, fb_rvalue);
2931 ret = MIN (ret, tret);
2934 else if (TREE_CODE (t) == COMPONENT_REF)
2936 /* Set the field offset into T and gimplify it. */
2937 if (TREE_OPERAND (t, 2) == NULL_TREE)
2939 tree offset = unshare_expr (component_ref_field_offset (t));
2940 tree field = TREE_OPERAND (t, 1);
2941 tree factor
2942 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
2944 /* Divide the offset by its alignment. */
2945 offset = size_binop_loc (loc, EXACT_DIV_EXPR, offset, factor);
2947 if (!is_gimple_min_invariant (offset))
2949 TREE_OPERAND (t, 2) = offset;
2950 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2951 post_p, is_gimple_reg,
2952 fb_rvalue);
2953 ret = MIN (ret, tret);
2956 else
2958 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2959 is_gimple_reg, fb_rvalue);
2960 ret = MIN (ret, tret);
2965 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2966 so as to match the min_lval predicate. Failure to do so may result
2967 in the creation of large aggregate temporaries. */
2968 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
2969 fallback | fb_lvalue);
2970 ret = MIN (ret, tret);
2972 /* And finally, the indices and operands of ARRAY_REF. During this
2973 loop we also remove any useless conversions. */
2974 for (; expr_stack.length () > 0; )
2976 tree t = expr_stack.pop ();
2978 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2980 /* Gimplify the dimension. */
2981 if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
2983 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2984 is_gimple_val, fb_rvalue);
2985 ret = MIN (ret, tret);
2989 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
2991 /* The innermost expression P may have originally had
2992 TREE_SIDE_EFFECTS set which would have caused all the outer
2993 expressions in *EXPR_P leading to P to also have had
2994 TREE_SIDE_EFFECTS set. */
2995 recalculate_side_effects (t);
2998 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2999 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
3001 canonicalize_component_ref (expr_p);
3004 expr_stack.release ();
3006 gcc_assert (*expr_p == expr || ret != GS_ALL_DONE);
3008 return ret;
3011 /* Gimplify the self modifying expression pointed to by EXPR_P
3012 (++, --, +=, -=).
3014 PRE_P points to the list where side effects that must happen before
3015 *EXPR_P should be stored.
3017 POST_P points to the list where side effects that must happen after
3018 *EXPR_P should be stored.
3020 WANT_VALUE is nonzero iff we want to use the value of this expression
3021 in another expression.
3023 ARITH_TYPE is the type the computation should be performed in. */
3025 enum gimplify_status
3026 gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3027 bool want_value, tree arith_type)
3029 enum tree_code code;
3030 tree lhs, lvalue, rhs, t1;
3031 gimple_seq post = NULL, *orig_post_p = post_p;
3032 bool postfix;
3033 enum tree_code arith_code;
3034 enum gimplify_status ret;
3035 location_t loc = EXPR_LOCATION (*expr_p);
3037 code = TREE_CODE (*expr_p);
3039 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
3040 || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
3042 /* Prefix or postfix? */
3043 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3044 /* Faster to treat as prefix if result is not used. */
3045 postfix = want_value;
3046 else
3047 postfix = false;
3049 /* For postfix, make sure the inner expression's post side effects
3050 are executed after side effects from this expression. */
3051 if (postfix)
3052 post_p = &post;
3054 /* Add or subtract? */
3055 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3056 arith_code = PLUS_EXPR;
3057 else
3058 arith_code = MINUS_EXPR;
3060 /* Gimplify the LHS into a GIMPLE lvalue. */
3061 lvalue = TREE_OPERAND (*expr_p, 0);
3062 ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
3063 if (ret == GS_ERROR)
3064 return ret;
3066 /* Extract the operands to the arithmetic operation. */
3067 lhs = lvalue;
3068 rhs = TREE_OPERAND (*expr_p, 1);
3070 /* For postfix operator, we evaluate the LHS to an rvalue and then use
3071 that as the result value and in the postqueue operation. */
3072 if (postfix)
3074 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
3075 if (ret == GS_ERROR)
3076 return ret;
3078 lhs = get_initialized_tmp_var (lhs, pre_p, NULL);
3081 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
3082 if (POINTER_TYPE_P (TREE_TYPE (lhs)))
3084 rhs = convert_to_ptrofftype_loc (loc, rhs);
3085 if (arith_code == MINUS_EXPR)
3086 rhs = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (rhs), rhs);
3087 t1 = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (*expr_p), lhs, rhs);
3089 else
3090 t1 = fold_convert (TREE_TYPE (*expr_p),
3091 fold_build2 (arith_code, arith_type,
3092 fold_convert (arith_type, lhs),
3093 fold_convert (arith_type, rhs)));
3095 if (postfix)
3097 gimplify_assign (lvalue, t1, pre_p);
3098 gimplify_seq_add_seq (orig_post_p, post);
3099 *expr_p = lhs;
3100 return GS_ALL_DONE;
3102 else
3104 *expr_p = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
3105 return GS_OK;
3109 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
3111 static void
3112 maybe_with_size_expr (tree *expr_p)
3114 tree expr = *expr_p;
3115 tree type = TREE_TYPE (expr);
3116 tree size;
3118 /* If we've already wrapped this or the type is error_mark_node, we can't do
3119 anything. */
3120 if (TREE_CODE (expr) == WITH_SIZE_EXPR
3121 || type == error_mark_node)
3122 return;
3124 /* If the size isn't known or is a constant, we have nothing to do. */
3125 size = TYPE_SIZE_UNIT (type);
3126 if (!size || poly_int_tree_p (size))
3127 return;
3129 /* Otherwise, make a WITH_SIZE_EXPR. */
3130 size = unshare_expr (size);
3131 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
3132 *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
3135 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
3136 Store any side-effects in PRE_P. CALL_LOCATION is the location of
3137 the CALL_EXPR. If ALLOW_SSA is set the actual parameter may be
3138 gimplified to an SSA name. */
3140 enum gimplify_status
3141 gimplify_arg (tree *arg_p, gimple_seq *pre_p, location_t call_location,
3142 bool allow_ssa)
3144 bool (*test) (tree);
3145 fallback_t fb;
3147 /* In general, we allow lvalues for function arguments to avoid
3148 extra overhead of copying large aggregates out of even larger
3149 aggregates into temporaries only to copy the temporaries to
3150 the argument list. Make optimizers happy by pulling out to
3151 temporaries those types that fit in registers. */
3152 if (is_gimple_reg_type (TREE_TYPE (*arg_p)))
3153 test = is_gimple_val, fb = fb_rvalue;
3154 else
3156 test = is_gimple_lvalue, fb = fb_either;
3157 /* Also strip a TARGET_EXPR that would force an extra copy. */
3158 if (TREE_CODE (*arg_p) == TARGET_EXPR)
3160 tree init = TARGET_EXPR_INITIAL (*arg_p);
3161 if (init
3162 && !VOID_TYPE_P (TREE_TYPE (init)))
3163 *arg_p = init;
3167 /* If this is a variable sized type, we must remember the size. */
3168 maybe_with_size_expr (arg_p);
3170 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
3171 /* Make sure arguments have the same location as the function call
3172 itself. */
3173 protected_set_expr_location (*arg_p, call_location);
3175 /* There is a sequence point before a function call. Side effects in
3176 the argument list must occur before the actual call. So, when
3177 gimplifying arguments, force gimplify_expr to use an internal
3178 post queue which is then appended to the end of PRE_P. */
3179 return gimplify_expr (arg_p, pre_p, NULL, test, fb, allow_ssa);
3182 /* Don't fold inside offloading or taskreg regions: it can break code by
3183 adding decl references that weren't in the source. We'll do it during
3184 omplower pass instead. */
3186 static bool
3187 maybe_fold_stmt (gimple_stmt_iterator *gsi)
3189 struct gimplify_omp_ctx *ctx;
3190 for (ctx = gimplify_omp_ctxp; ctx; ctx = ctx->outer_context)
3191 if ((ctx->region_type & (ORT_TARGET | ORT_PARALLEL | ORT_TASK)) != 0)
3192 return false;
3193 return fold_stmt (gsi);
3196 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
3197 WANT_VALUE is true if the result of the call is desired. */
3199 static enum gimplify_status
3200 gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
3202 tree fndecl, parms, p, fnptrtype;
3203 enum gimplify_status ret;
3204 int i, nargs;
3205 gcall *call;
3206 bool builtin_va_start_p = false;
3207 location_t loc = EXPR_LOCATION (*expr_p);
3209 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
3211 /* For reliable diagnostics during inlining, it is necessary that
3212 every call_expr be annotated with file and line. */
3213 if (! EXPR_HAS_LOCATION (*expr_p))
3214 SET_EXPR_LOCATION (*expr_p, input_location);
3216 /* Gimplify internal functions created in the FEs. */
3217 if (CALL_EXPR_FN (*expr_p) == NULL_TREE)
3219 if (want_value)
3220 return GS_ALL_DONE;
3222 nargs = call_expr_nargs (*expr_p);
3223 enum internal_fn ifn = CALL_EXPR_IFN (*expr_p);
3224 auto_vec<tree> vargs (nargs);
3226 for (i = 0; i < nargs; i++)
3228 gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
3229 EXPR_LOCATION (*expr_p));
3230 vargs.quick_push (CALL_EXPR_ARG (*expr_p, i));
3233 gcall *call = gimple_build_call_internal_vec (ifn, vargs);
3234 gimple_call_set_nothrow (call, TREE_NOTHROW (*expr_p));
3235 gimplify_seq_add_stmt (pre_p, call);
3236 return GS_ALL_DONE;
3239 /* This may be a call to a builtin function.
3241 Builtin function calls may be transformed into different
3242 (and more efficient) builtin function calls under certain
3243 circumstances. Unfortunately, gimplification can muck things
3244 up enough that the builtin expanders are not aware that certain
3245 transformations are still valid.
3247 So we attempt transformation/gimplification of the call before
3248 we gimplify the CALL_EXPR. At this time we do not manage to
3249 transform all calls in the same manner as the expanders do, but
3250 we do transform most of them. */
3251 fndecl = get_callee_fndecl (*expr_p);
3252 if (fndecl
3253 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
3254 switch (DECL_FUNCTION_CODE (fndecl))
3256 CASE_BUILT_IN_ALLOCA:
3257 /* If the call has been built for a variable-sized object, then we
3258 want to restore the stack level when the enclosing BIND_EXPR is
3259 exited to reclaim the allocated space; otherwise, we precisely
3260 need to do the opposite and preserve the latest stack level. */
3261 if (CALL_ALLOCA_FOR_VAR_P (*expr_p))
3262 gimplify_ctxp->save_stack = true;
3263 else
3264 gimplify_ctxp->keep_stack = true;
3265 break;
3267 case BUILT_IN_VA_START:
3269 builtin_va_start_p = TRUE;
3270 if (call_expr_nargs (*expr_p) < 2)
3272 error ("too few arguments to function %<va_start%>");
3273 *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
3274 return GS_OK;
3277 if (fold_builtin_next_arg (*expr_p, true))
3279 *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
3280 return GS_OK;
3282 break;
3285 default:
3288 if (fndecl && DECL_BUILT_IN (fndecl))
3290 tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
3291 if (new_tree && new_tree != *expr_p)
3293 /* There was a transformation of this call which computes the
3294 same value, but in a more efficient way. Return and try
3295 again. */
3296 *expr_p = new_tree;
3297 return GS_OK;
3301 /* Remember the original function pointer type. */
3302 fnptrtype = TREE_TYPE (CALL_EXPR_FN (*expr_p));
3304 /* There is a sequence point before the call, so any side effects in
3305 the calling expression must occur before the actual call. Force
3306 gimplify_expr to use an internal post queue. */
3307 ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
3308 is_gimple_call_addr, fb_rvalue);
3310 nargs = call_expr_nargs (*expr_p);
3312 /* Get argument types for verification. */
3313 fndecl = get_callee_fndecl (*expr_p);
3314 parms = NULL_TREE;
3315 if (fndecl)
3316 parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
3317 else
3318 parms = TYPE_ARG_TYPES (TREE_TYPE (fnptrtype));
3320 if (fndecl && DECL_ARGUMENTS (fndecl))
3321 p = DECL_ARGUMENTS (fndecl);
3322 else if (parms)
3323 p = parms;
3324 else
3325 p = NULL_TREE;
3326 for (i = 0; i < nargs && p; i++, p = TREE_CHAIN (p))
3329 /* If the last argument is __builtin_va_arg_pack () and it is not
3330 passed as a named argument, decrease the number of CALL_EXPR
3331 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
3332 if (!p
3333 && i < nargs
3334 && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
3336 tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
3337 tree last_arg_fndecl = get_callee_fndecl (last_arg);
3339 if (last_arg_fndecl
3340 && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
3341 && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
3342 && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
3344 tree call = *expr_p;
3346 --nargs;
3347 *expr_p = build_call_array_loc (loc, TREE_TYPE (call),
3348 CALL_EXPR_FN (call),
3349 nargs, CALL_EXPR_ARGP (call));
3351 /* Copy all CALL_EXPR flags, location and block, except
3352 CALL_EXPR_VA_ARG_PACK flag. */
3353 CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
3354 CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
3355 CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
3356 = CALL_EXPR_RETURN_SLOT_OPT (call);
3357 CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
3358 SET_EXPR_LOCATION (*expr_p, EXPR_LOCATION (call));
3360 /* Set CALL_EXPR_VA_ARG_PACK. */
3361 CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
3365 /* If the call returns twice then after building the CFG the call
3366 argument computations will no longer dominate the call because
3367 we add an abnormal incoming edge to the call. So do not use SSA
3368 vars there. */
3369 bool returns_twice = call_expr_flags (*expr_p) & ECF_RETURNS_TWICE;
3371 /* Gimplify the function arguments. */
3372 if (nargs > 0)
3374 for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
3375 PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
3376 PUSH_ARGS_REVERSED ? i-- : i++)
3378 enum gimplify_status t;
3380 /* Avoid gimplifying the second argument to va_start, which needs to
3381 be the plain PARM_DECL. */
3382 if ((i != 1) || !builtin_va_start_p)
3384 t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
3385 EXPR_LOCATION (*expr_p), ! returns_twice);
3387 if (t == GS_ERROR)
3388 ret = GS_ERROR;
3393 /* Gimplify the static chain. */
3394 if (CALL_EXPR_STATIC_CHAIN (*expr_p))
3396 if (fndecl && !DECL_STATIC_CHAIN (fndecl))
3397 CALL_EXPR_STATIC_CHAIN (*expr_p) = NULL;
3398 else
3400 enum gimplify_status t;
3401 t = gimplify_arg (&CALL_EXPR_STATIC_CHAIN (*expr_p), pre_p,
3402 EXPR_LOCATION (*expr_p), ! returns_twice);
3403 if (t == GS_ERROR)
3404 ret = GS_ERROR;
3408 /* Verify the function result. */
3409 if (want_value && fndecl
3410 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype))))
3412 error_at (loc, "using result of function returning %<void%>");
3413 ret = GS_ERROR;
3416 /* Try this again in case gimplification exposed something. */
3417 if (ret != GS_ERROR)
3419 tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
3421 if (new_tree && new_tree != *expr_p)
3423 /* There was a transformation of this call which computes the
3424 same value, but in a more efficient way. Return and try
3425 again. */
3426 *expr_p = new_tree;
3427 return GS_OK;
3430 else
3432 *expr_p = error_mark_node;
3433 return GS_ERROR;
3436 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
3437 decl. This allows us to eliminate redundant or useless
3438 calls to "const" functions. */
3439 if (TREE_CODE (*expr_p) == CALL_EXPR)
3441 int flags = call_expr_flags (*expr_p);
3442 if (flags & (ECF_CONST | ECF_PURE)
3443 /* An infinite loop is considered a side effect. */
3444 && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
3445 TREE_SIDE_EFFECTS (*expr_p) = 0;
3448 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
3449 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
3450 form and delegate the creation of a GIMPLE_CALL to
3451 gimplify_modify_expr. This is always possible because when
3452 WANT_VALUE is true, the caller wants the result of this call into
3453 a temporary, which means that we will emit an INIT_EXPR in
3454 internal_get_tmp_var which will then be handled by
3455 gimplify_modify_expr. */
3456 if (!want_value)
3458 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
3459 have to do is replicate it as a GIMPLE_CALL tuple. */
3460 gimple_stmt_iterator gsi;
3461 call = gimple_build_call_from_tree (*expr_p, fnptrtype);
3462 notice_special_calls (call);
3463 gimplify_seq_add_stmt (pre_p, call);
3464 gsi = gsi_last (*pre_p);
3465 maybe_fold_stmt (&gsi);
3466 *expr_p = NULL_TREE;
3468 else
3469 /* Remember the original function type. */
3470 CALL_EXPR_FN (*expr_p) = build1 (NOP_EXPR, fnptrtype,
3471 CALL_EXPR_FN (*expr_p));
3473 return ret;
3476 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
3477 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
3479 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
3480 condition is true or false, respectively. If null, we should generate
3481 our own to skip over the evaluation of this specific expression.
3483 LOCUS is the source location of the COND_EXPR.
3485 This function is the tree equivalent of do_jump.
3487 shortcut_cond_r should only be called by shortcut_cond_expr. */
3489 static tree
3490 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p,
3491 location_t locus)
3493 tree local_label = NULL_TREE;
3494 tree t, expr = NULL;
3496 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
3497 retain the shortcut semantics. Just insert the gotos here;
3498 shortcut_cond_expr will append the real blocks later. */
3499 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
3501 location_t new_locus;
3503 /* Turn if (a && b) into
3505 if (a); else goto no;
3506 if (b) goto yes; else goto no;
3507 (no:) */
3509 if (false_label_p == NULL)
3510 false_label_p = &local_label;
3512 /* Keep the original source location on the first 'if'. */
3513 t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p, locus);
3514 append_to_statement_list (t, &expr);
3516 /* Set the source location of the && on the second 'if'. */
3517 new_locus = rexpr_location (pred, locus);
3518 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
3519 new_locus);
3520 append_to_statement_list (t, &expr);
3522 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
3524 location_t new_locus;
3526 /* Turn if (a || b) into
3528 if (a) goto yes;
3529 if (b) goto yes; else goto no;
3530 (yes:) */
3532 if (true_label_p == NULL)
3533 true_label_p = &local_label;
3535 /* Keep the original source location on the first 'if'. */
3536 t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL, locus);
3537 append_to_statement_list (t, &expr);
3539 /* Set the source location of the || on the second 'if'. */
3540 new_locus = rexpr_location (pred, locus);
3541 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
3542 new_locus);
3543 append_to_statement_list (t, &expr);
3545 else if (TREE_CODE (pred) == COND_EXPR
3546 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 1)))
3547 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 2))))
3549 location_t new_locus;
3551 /* As long as we're messing with gotos, turn if (a ? b : c) into
3552 if (a)
3553 if (b) goto yes; else goto no;
3554 else
3555 if (c) goto yes; else goto no;
3557 Don't do this if one of the arms has void type, which can happen
3558 in C++ when the arm is throw. */
3560 /* Keep the original source location on the first 'if'. Set the source
3561 location of the ? on the second 'if'. */
3562 new_locus = rexpr_location (pred, locus);
3563 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
3564 shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
3565 false_label_p, locus),
3566 shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
3567 false_label_p, new_locus));
3569 else
3571 expr = build3 (COND_EXPR, void_type_node, pred,
3572 build_and_jump (true_label_p),
3573 build_and_jump (false_label_p));
3574 SET_EXPR_LOCATION (expr, locus);
3577 if (local_label)
3579 t = build1 (LABEL_EXPR, void_type_node, local_label);
3580 append_to_statement_list (t, &expr);
3583 return expr;
3586 /* If EXPR is a GOTO_EXPR, return it. If it is a STATEMENT_LIST, skip
3587 any of its leading DEBUG_BEGIN_STMTS and recurse on the subsequent
3588 statement, if it is the last one. Otherwise, return NULL. */
3590 static tree
3591 find_goto (tree expr)
3593 if (!expr)
3594 return NULL_TREE;
3596 if (TREE_CODE (expr) == GOTO_EXPR)
3597 return expr;
3599 if (TREE_CODE (expr) != STATEMENT_LIST)
3600 return NULL_TREE;
3602 tree_stmt_iterator i = tsi_start (expr);
3604 while (!tsi_end_p (i) && TREE_CODE (tsi_stmt (i)) == DEBUG_BEGIN_STMT)
3605 tsi_next (&i);
3607 if (!tsi_one_before_end_p (i))
3608 return NULL_TREE;
3610 return find_goto (tsi_stmt (i));
3613 /* Same as find_goto, except that it returns NULL if the destination
3614 is not a LABEL_DECL. */
3616 static inline tree
3617 find_goto_label (tree expr)
3619 tree dest = find_goto (expr);
3620 if (dest && TREE_CODE (GOTO_DESTINATION (dest)) == LABEL_DECL)
3621 return dest;
3622 return NULL_TREE;
3625 /* Given a conditional expression EXPR with short-circuit boolean
3626 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
3627 predicate apart into the equivalent sequence of conditionals. */
3629 static tree
3630 shortcut_cond_expr (tree expr)
3632 tree pred = TREE_OPERAND (expr, 0);
3633 tree then_ = TREE_OPERAND (expr, 1);
3634 tree else_ = TREE_OPERAND (expr, 2);
3635 tree true_label, false_label, end_label, t;
3636 tree *true_label_p;
3637 tree *false_label_p;
3638 bool emit_end, emit_false, jump_over_else;
3639 bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
3640 bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
3642 /* First do simple transformations. */
3643 if (!else_se)
3645 /* If there is no 'else', turn
3646 if (a && b) then c
3647 into
3648 if (a) if (b) then c. */
3649 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
3651 /* Keep the original source location on the first 'if'. */
3652 location_t locus = EXPR_LOC_OR_LOC (expr, input_location);
3653 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
3654 /* Set the source location of the && on the second 'if'. */
3655 if (rexpr_has_location (pred))
3656 SET_EXPR_LOCATION (expr, rexpr_location (pred));
3657 then_ = shortcut_cond_expr (expr);
3658 then_se = then_ && TREE_SIDE_EFFECTS (then_);
3659 pred = TREE_OPERAND (pred, 0);
3660 expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
3661 SET_EXPR_LOCATION (expr, locus);
3665 if (!then_se)
3667 /* If there is no 'then', turn
3668 if (a || b); else d
3669 into
3670 if (a); else if (b); else d. */
3671 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
3673 /* Keep the original source location on the first 'if'. */
3674 location_t locus = EXPR_LOC_OR_LOC (expr, input_location);
3675 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
3676 /* Set the source location of the || on the second 'if'. */
3677 if (rexpr_has_location (pred))
3678 SET_EXPR_LOCATION (expr, rexpr_location (pred));
3679 else_ = shortcut_cond_expr (expr);
3680 else_se = else_ && TREE_SIDE_EFFECTS (else_);
3681 pred = TREE_OPERAND (pred, 0);
3682 expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
3683 SET_EXPR_LOCATION (expr, locus);
3687 /* If we're done, great. */
3688 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
3689 && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
3690 return expr;
3692 /* Otherwise we need to mess with gotos. Change
3693 if (a) c; else d;
3695 if (a); else goto no;
3696 c; goto end;
3697 no: d; end:
3698 and recursively gimplify the condition. */
3700 true_label = false_label = end_label = NULL_TREE;
3702 /* If our arms just jump somewhere, hijack those labels so we don't
3703 generate jumps to jumps. */
3705 if (tree then_goto = find_goto_label (then_))
3707 true_label = GOTO_DESTINATION (then_goto);
3708 then_ = NULL;
3709 then_se = false;
3712 if (tree else_goto = find_goto_label (else_))
3714 false_label = GOTO_DESTINATION (else_goto);
3715 else_ = NULL;
3716 else_se = false;
3719 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
3720 if (true_label)
3721 true_label_p = &true_label;
3722 else
3723 true_label_p = NULL;
3725 /* The 'else' branch also needs a label if it contains interesting code. */
3726 if (false_label || else_se)
3727 false_label_p = &false_label;
3728 else
3729 false_label_p = NULL;
3731 /* If there was nothing else in our arms, just forward the label(s). */
3732 if (!then_se && !else_se)
3733 return shortcut_cond_r (pred, true_label_p, false_label_p,
3734 EXPR_LOC_OR_LOC (expr, input_location));
3736 /* If our last subexpression already has a terminal label, reuse it. */
3737 if (else_se)
3738 t = expr_last (else_);
3739 else if (then_se)
3740 t = expr_last (then_);
3741 else
3742 t = NULL;
3743 if (t && TREE_CODE (t) == LABEL_EXPR)
3744 end_label = LABEL_EXPR_LABEL (t);
3746 /* If we don't care about jumping to the 'else' branch, jump to the end
3747 if the condition is false. */
3748 if (!false_label_p)
3749 false_label_p = &end_label;
3751 /* We only want to emit these labels if we aren't hijacking them. */
3752 emit_end = (end_label == NULL_TREE);
3753 emit_false = (false_label == NULL_TREE);
3755 /* We only emit the jump over the else clause if we have to--if the
3756 then clause may fall through. Otherwise we can wind up with a
3757 useless jump and a useless label at the end of gimplified code,
3758 which will cause us to think that this conditional as a whole
3759 falls through even if it doesn't. If we then inline a function
3760 which ends with such a condition, that can cause us to issue an
3761 inappropriate warning about control reaching the end of a
3762 non-void function. */
3763 jump_over_else = block_may_fallthru (then_);
3765 pred = shortcut_cond_r (pred, true_label_p, false_label_p,
3766 EXPR_LOC_OR_LOC (expr, input_location));
3768 expr = NULL;
3769 append_to_statement_list (pred, &expr);
3771 append_to_statement_list (then_, &expr);
3772 if (else_se)
3774 if (jump_over_else)
3776 tree last = expr_last (expr);
3777 t = build_and_jump (&end_label);
3778 if (rexpr_has_location (last))
3779 SET_EXPR_LOCATION (t, rexpr_location (last));
3780 append_to_statement_list (t, &expr);
3782 if (emit_false)
3784 t = build1 (LABEL_EXPR, void_type_node, false_label);
3785 append_to_statement_list (t, &expr);
3787 append_to_statement_list (else_, &expr);
3789 if (emit_end && end_label)
3791 t = build1 (LABEL_EXPR, void_type_node, end_label);
3792 append_to_statement_list (t, &expr);
3795 return expr;
3798 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
3800 tree
3801 gimple_boolify (tree expr)
3803 tree type = TREE_TYPE (expr);
3804 location_t loc = EXPR_LOCATION (expr);
3806 if (TREE_CODE (expr) == NE_EXPR
3807 && TREE_CODE (TREE_OPERAND (expr, 0)) == CALL_EXPR
3808 && integer_zerop (TREE_OPERAND (expr, 1)))
3810 tree call = TREE_OPERAND (expr, 0);
3811 tree fn = get_callee_fndecl (call);
3813 /* For __builtin_expect ((long) (x), y) recurse into x as well
3814 if x is truth_value_p. */
3815 if (fn
3816 && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
3817 && DECL_FUNCTION_CODE (fn) == BUILT_IN_EXPECT
3818 && call_expr_nargs (call) == 2)
3820 tree arg = CALL_EXPR_ARG (call, 0);
3821 if (arg)
3823 if (TREE_CODE (arg) == NOP_EXPR
3824 && TREE_TYPE (arg) == TREE_TYPE (call))
3825 arg = TREE_OPERAND (arg, 0);
3826 if (truth_value_p (TREE_CODE (arg)))
3828 arg = gimple_boolify (arg);
3829 CALL_EXPR_ARG (call, 0)
3830 = fold_convert_loc (loc, TREE_TYPE (call), arg);
3836 switch (TREE_CODE (expr))
3838 case TRUTH_AND_EXPR:
3839 case TRUTH_OR_EXPR:
3840 case TRUTH_XOR_EXPR:
3841 case TRUTH_ANDIF_EXPR:
3842 case TRUTH_ORIF_EXPR:
3843 /* Also boolify the arguments of truth exprs. */
3844 TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
3845 /* FALLTHRU */
3847 case TRUTH_NOT_EXPR:
3848 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
3850 /* These expressions always produce boolean results. */
3851 if (TREE_CODE (type) != BOOLEAN_TYPE)
3852 TREE_TYPE (expr) = boolean_type_node;
3853 return expr;
3855 case ANNOTATE_EXPR:
3856 switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)))
3858 case annot_expr_ivdep_kind:
3859 case annot_expr_unroll_kind:
3860 case annot_expr_no_vector_kind:
3861 case annot_expr_vector_kind:
3862 case annot_expr_parallel_kind:
3863 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
3864 if (TREE_CODE (type) != BOOLEAN_TYPE)
3865 TREE_TYPE (expr) = boolean_type_node;
3866 return expr;
3867 default:
3868 gcc_unreachable ();
3871 default:
3872 if (COMPARISON_CLASS_P (expr))
3874 /* There expressions always prduce boolean results. */
3875 if (TREE_CODE (type) != BOOLEAN_TYPE)
3876 TREE_TYPE (expr) = boolean_type_node;
3877 return expr;
3879 /* Other expressions that get here must have boolean values, but
3880 might need to be converted to the appropriate mode. */
3881 if (TREE_CODE (type) == BOOLEAN_TYPE)
3882 return expr;
3883 return fold_convert_loc (loc, boolean_type_node, expr);
3887 /* Given a conditional expression *EXPR_P without side effects, gimplify
3888 its operands. New statements are inserted to PRE_P. */
3890 static enum gimplify_status
3891 gimplify_pure_cond_expr (tree *expr_p, gimple_seq *pre_p)
3893 tree expr = *expr_p, cond;
3894 enum gimplify_status ret, tret;
3895 enum tree_code code;
3897 cond = gimple_boolify (COND_EXPR_COND (expr));
3899 /* We need to handle && and || specially, as their gimplification
3900 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
3901 code = TREE_CODE (cond);
3902 if (code == TRUTH_ANDIF_EXPR)
3903 TREE_SET_CODE (cond, TRUTH_AND_EXPR);
3904 else if (code == TRUTH_ORIF_EXPR)
3905 TREE_SET_CODE (cond, TRUTH_OR_EXPR);
3906 ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
3907 COND_EXPR_COND (*expr_p) = cond;
3909 tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
3910 is_gimple_val, fb_rvalue);
3911 ret = MIN (ret, tret);
3912 tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
3913 is_gimple_val, fb_rvalue);
3915 return MIN (ret, tret);
3918 /* Return true if evaluating EXPR could trap.
3919 EXPR is GENERIC, while tree_could_trap_p can be called
3920 only on GIMPLE. */
3922 static bool
3923 generic_expr_could_trap_p (tree expr)
3925 unsigned i, n;
3927 if (!expr || is_gimple_val (expr))
3928 return false;
3930 if (!EXPR_P (expr) || tree_could_trap_p (expr))
3931 return true;
3933 n = TREE_OPERAND_LENGTH (expr);
3934 for (i = 0; i < n; i++)
3935 if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
3936 return true;
3938 return false;
3941 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3942 into
3944 if (p) if (p)
3945 t1 = a; a;
3946 else or else
3947 t1 = b; b;
3950 The second form is used when *EXPR_P is of type void.
3952 PRE_P points to the list where side effects that must happen before
3953 *EXPR_P should be stored. */
3955 static enum gimplify_status
3956 gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
3958 tree expr = *expr_p;
3959 tree type = TREE_TYPE (expr);
3960 location_t loc = EXPR_LOCATION (expr);
3961 tree tmp, arm1, arm2;
3962 enum gimplify_status ret;
3963 tree label_true, label_false, label_cont;
3964 bool have_then_clause_p, have_else_clause_p;
3965 gcond *cond_stmt;
3966 enum tree_code pred_code;
3967 gimple_seq seq = NULL;
3969 /* If this COND_EXPR has a value, copy the values into a temporary within
3970 the arms. */
3971 if (!VOID_TYPE_P (type))
3973 tree then_ = TREE_OPERAND (expr, 1), else_ = TREE_OPERAND (expr, 2);
3974 tree result;
3976 /* If either an rvalue is ok or we do not require an lvalue, create the
3977 temporary. But we cannot do that if the type is addressable. */
3978 if (((fallback & fb_rvalue) || !(fallback & fb_lvalue))
3979 && !TREE_ADDRESSABLE (type))
3981 if (gimplify_ctxp->allow_rhs_cond_expr
3982 /* If either branch has side effects or could trap, it can't be
3983 evaluated unconditionally. */
3984 && !TREE_SIDE_EFFECTS (then_)
3985 && !generic_expr_could_trap_p (then_)
3986 && !TREE_SIDE_EFFECTS (else_)
3987 && !generic_expr_could_trap_p (else_))
3988 return gimplify_pure_cond_expr (expr_p, pre_p);
3990 tmp = create_tmp_var (type, "iftmp");
3991 result = tmp;
3994 /* Otherwise, only create and copy references to the values. */
3995 else
3997 type = build_pointer_type (type);
3999 if (!VOID_TYPE_P (TREE_TYPE (then_)))
4000 then_ = build_fold_addr_expr_loc (loc, then_);
4002 if (!VOID_TYPE_P (TREE_TYPE (else_)))
4003 else_ = build_fold_addr_expr_loc (loc, else_);
4005 expr
4006 = build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), then_, else_);
4008 tmp = create_tmp_var (type, "iftmp");
4009 result = build_simple_mem_ref_loc (loc, tmp);
4012 /* Build the new then clause, `tmp = then_;'. But don't build the
4013 assignment if the value is void; in C++ it can be if it's a throw. */
4014 if (!VOID_TYPE_P (TREE_TYPE (then_)))
4015 TREE_OPERAND (expr, 1) = build2 (MODIFY_EXPR, type, tmp, then_);
4017 /* Similarly, build the new else clause, `tmp = else_;'. */
4018 if (!VOID_TYPE_P (TREE_TYPE (else_)))
4019 TREE_OPERAND (expr, 2) = build2 (MODIFY_EXPR, type, tmp, else_);
4021 TREE_TYPE (expr) = void_type_node;
4022 recalculate_side_effects (expr);
4024 /* Move the COND_EXPR to the prequeue. */
4025 gimplify_stmt (&expr, pre_p);
4027 *expr_p = result;
4028 return GS_ALL_DONE;
4031 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
4032 STRIP_TYPE_NOPS (TREE_OPERAND (expr, 0));
4033 if (TREE_CODE (TREE_OPERAND (expr, 0)) == COMPOUND_EXPR)
4034 gimplify_compound_expr (&TREE_OPERAND (expr, 0), pre_p, true);
4036 /* Make sure the condition has BOOLEAN_TYPE. */
4037 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
4039 /* Break apart && and || conditions. */
4040 if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
4041 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
4043 expr = shortcut_cond_expr (expr);
4045 if (expr != *expr_p)
4047 *expr_p = expr;
4049 /* We can't rely on gimplify_expr to re-gimplify the expanded
4050 form properly, as cleanups might cause the target labels to be
4051 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
4052 set up a conditional context. */
4053 gimple_push_condition ();
4054 gimplify_stmt (expr_p, &seq);
4055 gimple_pop_condition (pre_p);
4056 gimple_seq_add_seq (pre_p, seq);
4058 return GS_ALL_DONE;
4062 /* Now do the normal gimplification. */
4064 /* Gimplify condition. */
4065 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, is_gimple_condexpr,
4066 fb_rvalue);
4067 if (ret == GS_ERROR)
4068 return GS_ERROR;
4069 gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
4071 gimple_push_condition ();
4073 have_then_clause_p = have_else_clause_p = false;
4074 label_true = find_goto_label (TREE_OPERAND (expr, 1));
4075 if (label_true
4076 && DECL_CONTEXT (GOTO_DESTINATION (label_true)) == current_function_decl
4077 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
4078 have different locations, otherwise we end up with incorrect
4079 location information on the branches. */
4080 && (optimize
4081 || !EXPR_HAS_LOCATION (expr)
4082 || !rexpr_has_location (label_true)
4083 || EXPR_LOCATION (expr) == rexpr_location (label_true)))
4085 have_then_clause_p = true;
4086 label_true = GOTO_DESTINATION (label_true);
4088 else
4089 label_true = create_artificial_label (UNKNOWN_LOCATION);
4090 label_false = find_goto_label (TREE_OPERAND (expr, 2));
4091 if (label_false
4092 && DECL_CONTEXT (GOTO_DESTINATION (label_false)) == current_function_decl
4093 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
4094 have different locations, otherwise we end up with incorrect
4095 location information on the branches. */
4096 && (optimize
4097 || !EXPR_HAS_LOCATION (expr)
4098 || !rexpr_has_location (label_false)
4099 || EXPR_LOCATION (expr) == rexpr_location (label_false)))
4101 have_else_clause_p = true;
4102 label_false = GOTO_DESTINATION (label_false);
4104 else
4105 label_false = create_artificial_label (UNKNOWN_LOCATION);
4107 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
4108 &arm2);
4109 cond_stmt = gimple_build_cond (pred_code, arm1, arm2, label_true,
4110 label_false);
4111 gimple_set_no_warning (cond_stmt, TREE_NO_WARNING (COND_EXPR_COND (expr)));
4112 gimplify_seq_add_stmt (&seq, cond_stmt);
4113 gimple_stmt_iterator gsi = gsi_last (seq);
4114 maybe_fold_stmt (&gsi);
4116 label_cont = NULL_TREE;
4117 if (!have_then_clause_p)
4119 /* For if (...) {} else { code; } put label_true after
4120 the else block. */
4121 if (TREE_OPERAND (expr, 1) == NULL_TREE
4122 && !have_else_clause_p
4123 && TREE_OPERAND (expr, 2) != NULL_TREE)
4124 label_cont = label_true;
4125 else
4127 gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
4128 have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
4129 /* For if (...) { code; } else {} or
4130 if (...) { code; } else goto label; or
4131 if (...) { code; return; } else { ... }
4132 label_cont isn't needed. */
4133 if (!have_else_clause_p
4134 && TREE_OPERAND (expr, 2) != NULL_TREE
4135 && gimple_seq_may_fallthru (seq))
4137 gimple *g;
4138 label_cont = create_artificial_label (UNKNOWN_LOCATION);
4140 g = gimple_build_goto (label_cont);
4142 /* GIMPLE_COND's are very low level; they have embedded
4143 gotos. This particular embedded goto should not be marked
4144 with the location of the original COND_EXPR, as it would
4145 correspond to the COND_EXPR's condition, not the ELSE or the
4146 THEN arms. To avoid marking it with the wrong location, flag
4147 it as "no location". */
4148 gimple_set_do_not_emit_location (g);
4150 gimplify_seq_add_stmt (&seq, g);
4154 if (!have_else_clause_p)
4156 gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
4157 have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
4159 if (label_cont)
4160 gimplify_seq_add_stmt (&seq, gimple_build_label (label_cont));
4162 gimple_pop_condition (pre_p);
4163 gimple_seq_add_seq (pre_p, seq);
4165 if (ret == GS_ERROR)
4166 ; /* Do nothing. */
4167 else if (have_then_clause_p || have_else_clause_p)
4168 ret = GS_ALL_DONE;
4169 else
4171 /* Both arms are empty; replace the COND_EXPR with its predicate. */
4172 expr = TREE_OPERAND (expr, 0);
4173 gimplify_stmt (&expr, pre_p);
4176 *expr_p = NULL;
4177 return ret;
4180 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
4181 to be marked addressable.
4183 We cannot rely on such an expression being directly markable if a temporary
4184 has been created by the gimplification. In this case, we create another
4185 temporary and initialize it with a copy, which will become a store after we
4186 mark it addressable. This can happen if the front-end passed us something
4187 that it could not mark addressable yet, like a Fortran pass-by-reference
4188 parameter (int) floatvar. */
4190 static void
4191 prepare_gimple_addressable (tree *expr_p, gimple_seq *seq_p)
4193 while (handled_component_p (*expr_p))
4194 expr_p = &TREE_OPERAND (*expr_p, 0);
4195 if (is_gimple_reg (*expr_p))
4197 /* Do not allow an SSA name as the temporary. */
4198 tree var = get_initialized_tmp_var (*expr_p, seq_p, NULL, false);
4199 DECL_GIMPLE_REG_P (var) = 0;
4200 *expr_p = var;
4204 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
4205 a call to __builtin_memcpy. */
4207 static enum gimplify_status
4208 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
4209 gimple_seq *seq_p)
4211 tree t, to, to_ptr, from, from_ptr;
4212 gcall *gs;
4213 location_t loc = EXPR_LOCATION (*expr_p);
4215 to = TREE_OPERAND (*expr_p, 0);
4216 from = TREE_OPERAND (*expr_p, 1);
4218 /* Mark the RHS addressable. Beware that it may not be possible to do so
4219 directly if a temporary has been created by the gimplification. */
4220 prepare_gimple_addressable (&from, seq_p);
4222 mark_addressable (from);
4223 from_ptr = build_fold_addr_expr_loc (loc, from);
4224 gimplify_arg (&from_ptr, seq_p, loc);
4226 mark_addressable (to);
4227 to_ptr = build_fold_addr_expr_loc (loc, to);
4228 gimplify_arg (&to_ptr, seq_p, loc);
4230 t = builtin_decl_implicit (BUILT_IN_MEMCPY);
4232 gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
4234 if (want_value)
4236 /* tmp = memcpy() */
4237 t = create_tmp_var (TREE_TYPE (to_ptr));
4238 gimple_call_set_lhs (gs, t);
4239 gimplify_seq_add_stmt (seq_p, gs);
4241 *expr_p = build_simple_mem_ref (t);
4242 return GS_ALL_DONE;
4245 gimplify_seq_add_stmt (seq_p, gs);
4246 *expr_p = NULL;
4247 return GS_ALL_DONE;
4250 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
4251 a call to __builtin_memset. In this case we know that the RHS is
4252 a CONSTRUCTOR with an empty element list. */
4254 static enum gimplify_status
4255 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
4256 gimple_seq *seq_p)
4258 tree t, from, to, to_ptr;
4259 gcall *gs;
4260 location_t loc = EXPR_LOCATION (*expr_p);
4262 /* Assert our assumptions, to abort instead of producing wrong code
4263 silently if they are not met. Beware that the RHS CONSTRUCTOR might
4264 not be immediately exposed. */
4265 from = TREE_OPERAND (*expr_p, 1);
4266 if (TREE_CODE (from) == WITH_SIZE_EXPR)
4267 from = TREE_OPERAND (from, 0);
4269 gcc_assert (TREE_CODE (from) == CONSTRUCTOR
4270 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from)));
4272 /* Now proceed. */
4273 to = TREE_OPERAND (*expr_p, 0);
4275 to_ptr = build_fold_addr_expr_loc (loc, to);
4276 gimplify_arg (&to_ptr, seq_p, loc);
4277 t = builtin_decl_implicit (BUILT_IN_MEMSET);
4279 gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
4281 if (want_value)
4283 /* tmp = memset() */
4284 t = create_tmp_var (TREE_TYPE (to_ptr));
4285 gimple_call_set_lhs (gs, t);
4286 gimplify_seq_add_stmt (seq_p, gs);
4288 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
4289 return GS_ALL_DONE;
4292 gimplify_seq_add_stmt (seq_p, gs);
4293 *expr_p = NULL;
4294 return GS_ALL_DONE;
4297 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
4298 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
4299 assignment. Return non-null if we detect a potential overlap. */
4301 struct gimplify_init_ctor_preeval_data
4303 /* The base decl of the lhs object. May be NULL, in which case we
4304 have to assume the lhs is indirect. */
4305 tree lhs_base_decl;
4307 /* The alias set of the lhs object. */
4308 alias_set_type lhs_alias_set;
4311 static tree
4312 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
4314 struct gimplify_init_ctor_preeval_data *data
4315 = (struct gimplify_init_ctor_preeval_data *) xdata;
4316 tree t = *tp;
4318 /* If we find the base object, obviously we have overlap. */
4319 if (data->lhs_base_decl == t)
4320 return t;
4322 /* If the constructor component is indirect, determine if we have a
4323 potential overlap with the lhs. The only bits of information we
4324 have to go on at this point are addressability and alias sets. */
4325 if ((INDIRECT_REF_P (t)
4326 || TREE_CODE (t) == MEM_REF)
4327 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
4328 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
4329 return t;
4331 /* If the constructor component is a call, determine if it can hide a
4332 potential overlap with the lhs through an INDIRECT_REF like above.
4333 ??? Ugh - this is completely broken. In fact this whole analysis
4334 doesn't look conservative. */
4335 if (TREE_CODE (t) == CALL_EXPR)
4337 tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
4339 for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
4340 if (POINTER_TYPE_P (TREE_VALUE (type))
4341 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
4342 && alias_sets_conflict_p (data->lhs_alias_set,
4343 get_alias_set
4344 (TREE_TYPE (TREE_VALUE (type)))))
4345 return t;
4348 if (IS_TYPE_OR_DECL_P (t))
4349 *walk_subtrees = 0;
4350 return NULL;
4353 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
4354 force values that overlap with the lhs (as described by *DATA)
4355 into temporaries. */
4357 static void
4358 gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
4359 struct gimplify_init_ctor_preeval_data *data)
4361 enum gimplify_status one;
4363 /* If the value is constant, then there's nothing to pre-evaluate. */
4364 if (TREE_CONSTANT (*expr_p))
4366 /* Ensure it does not have side effects, it might contain a reference to
4367 the object we're initializing. */
4368 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
4369 return;
4372 /* If the type has non-trivial constructors, we can't pre-evaluate. */
4373 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
4374 return;
4376 /* Recurse for nested constructors. */
4377 if (TREE_CODE (*expr_p) == CONSTRUCTOR)
4379 unsigned HOST_WIDE_INT ix;
4380 constructor_elt *ce;
4381 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (*expr_p);
4383 FOR_EACH_VEC_SAFE_ELT (v, ix, ce)
4384 gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
4386 return;
4389 /* If this is a variable sized type, we must remember the size. */
4390 maybe_with_size_expr (expr_p);
4392 /* Gimplify the constructor element to something appropriate for the rhs
4393 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
4394 the gimplifier will consider this a store to memory. Doing this
4395 gimplification now means that we won't have to deal with complicated
4396 language-specific trees, nor trees like SAVE_EXPR that can induce
4397 exponential search behavior. */
4398 one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
4399 if (one == GS_ERROR)
4401 *expr_p = NULL;
4402 return;
4405 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
4406 with the lhs, since "a = { .x=a }" doesn't make sense. This will
4407 always be true for all scalars, since is_gimple_mem_rhs insists on a
4408 temporary variable for them. */
4409 if (DECL_P (*expr_p))
4410 return;
4412 /* If this is of variable size, we have no choice but to assume it doesn't
4413 overlap since we can't make a temporary for it. */
4414 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
4415 return;
4417 /* Otherwise, we must search for overlap ... */
4418 if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
4419 return;
4421 /* ... and if found, force the value into a temporary. */
4422 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
4425 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
4426 a RANGE_EXPR in a CONSTRUCTOR for an array.
4428 var = lower;
4429 loop_entry:
4430 object[var] = value;
4431 if (var == upper)
4432 goto loop_exit;
4433 var = var + 1;
4434 goto loop_entry;
4435 loop_exit:
4437 We increment var _after_ the loop exit check because we might otherwise
4438 fail if upper == TYPE_MAX_VALUE (type for upper).
4440 Note that we never have to deal with SAVE_EXPRs here, because this has
4441 already been taken care of for us, in gimplify_init_ctor_preeval(). */
4443 static void gimplify_init_ctor_eval (tree, vec<constructor_elt, va_gc> *,
4444 gimple_seq *, bool);
4446 static void
4447 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
4448 tree value, tree array_elt_type,
4449 gimple_seq *pre_p, bool cleared)
4451 tree loop_entry_label, loop_exit_label, fall_thru_label;
4452 tree var, var_type, cref, tmp;
4454 loop_entry_label = create_artificial_label (UNKNOWN_LOCATION);
4455 loop_exit_label = create_artificial_label (UNKNOWN_LOCATION);
4456 fall_thru_label = create_artificial_label (UNKNOWN_LOCATION);
4458 /* Create and initialize the index variable. */
4459 var_type = TREE_TYPE (upper);
4460 var = create_tmp_var (var_type);
4461 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
4463 /* Add the loop entry label. */
4464 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
4466 /* Build the reference. */
4467 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
4468 var, NULL_TREE, NULL_TREE);
4470 /* If we are a constructor, just call gimplify_init_ctor_eval to do
4471 the store. Otherwise just assign value to the reference. */
4473 if (TREE_CODE (value) == CONSTRUCTOR)
4474 /* NB we might have to call ourself recursively through
4475 gimplify_init_ctor_eval if the value is a constructor. */
4476 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
4477 pre_p, cleared);
4478 else
4479 gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
4481 /* We exit the loop when the index var is equal to the upper bound. */
4482 gimplify_seq_add_stmt (pre_p,
4483 gimple_build_cond (EQ_EXPR, var, upper,
4484 loop_exit_label, fall_thru_label));
4486 gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
4488 /* Otherwise, increment the index var... */
4489 tmp = build2 (PLUS_EXPR, var_type, var,
4490 fold_convert (var_type, integer_one_node));
4491 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
4493 /* ...and jump back to the loop entry. */
4494 gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
4496 /* Add the loop exit label. */
4497 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
4500 /* Return true if FDECL is accessing a field that is zero sized. */
4502 static bool
4503 zero_sized_field_decl (const_tree fdecl)
4505 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
4506 && integer_zerop (DECL_SIZE (fdecl)))
4507 return true;
4508 return false;
4511 /* Return true if TYPE is zero sized. */
4513 static bool
4514 zero_sized_type (const_tree type)
4516 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
4517 && integer_zerop (TYPE_SIZE (type)))
4518 return true;
4519 return false;
4522 /* A subroutine of gimplify_init_constructor. Generate individual
4523 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
4524 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
4525 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
4526 zeroed first. */
4528 static void
4529 gimplify_init_ctor_eval (tree object, vec<constructor_elt, va_gc> *elts,
4530 gimple_seq *pre_p, bool cleared)
4532 tree array_elt_type = NULL;
4533 unsigned HOST_WIDE_INT ix;
4534 tree purpose, value;
4536 if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
4537 array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
4539 FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
4541 tree cref;
4543 /* NULL values are created above for gimplification errors. */
4544 if (value == NULL)
4545 continue;
4547 if (cleared && initializer_zerop (value))
4548 continue;
4550 /* ??? Here's to hoping the front end fills in all of the indices,
4551 so we don't have to figure out what's missing ourselves. */
4552 gcc_assert (purpose);
4554 /* Skip zero-sized fields, unless value has side-effects. This can
4555 happen with calls to functions returning a zero-sized type, which
4556 we shouldn't discard. As a number of downstream passes don't
4557 expect sets of zero-sized fields, we rely on the gimplification of
4558 the MODIFY_EXPR we make below to drop the assignment statement. */
4559 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
4560 continue;
4562 /* If we have a RANGE_EXPR, we have to build a loop to assign the
4563 whole range. */
4564 if (TREE_CODE (purpose) == RANGE_EXPR)
4566 tree lower = TREE_OPERAND (purpose, 0);
4567 tree upper = TREE_OPERAND (purpose, 1);
4569 /* If the lower bound is equal to upper, just treat it as if
4570 upper was the index. */
4571 if (simple_cst_equal (lower, upper))
4572 purpose = upper;
4573 else
4575 gimplify_init_ctor_eval_range (object, lower, upper, value,
4576 array_elt_type, pre_p, cleared);
4577 continue;
4581 if (array_elt_type)
4583 /* Do not use bitsizetype for ARRAY_REF indices. */
4584 if (TYPE_DOMAIN (TREE_TYPE (object)))
4585 purpose
4586 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
4587 purpose);
4588 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
4589 purpose, NULL_TREE, NULL_TREE);
4591 else
4593 gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
4594 cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
4595 unshare_expr (object), purpose, NULL_TREE);
4598 if (TREE_CODE (value) == CONSTRUCTOR
4599 && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
4600 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
4601 pre_p, cleared);
4602 else
4604 tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
4605 gimplify_and_add (init, pre_p);
4606 ggc_free (init);
4611 /* Return the appropriate RHS predicate for this LHS. */
4613 gimple_predicate
4614 rhs_predicate_for (tree lhs)
4616 if (is_gimple_reg (lhs))
4617 return is_gimple_reg_rhs_or_call;
4618 else
4619 return is_gimple_mem_rhs_or_call;
4622 /* Return the initial guess for an appropriate RHS predicate for this LHS,
4623 before the LHS has been gimplified. */
4625 static gimple_predicate
4626 initial_rhs_predicate_for (tree lhs)
4628 if (is_gimple_reg_type (TREE_TYPE (lhs)))
4629 return is_gimple_reg_rhs_or_call;
4630 else
4631 return is_gimple_mem_rhs_or_call;
4634 /* Gimplify a C99 compound literal expression. This just means adding
4635 the DECL_EXPR before the current statement and using its anonymous
4636 decl instead. */
4638 static enum gimplify_status
4639 gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p,
4640 bool (*gimple_test_f) (tree),
4641 fallback_t fallback)
4643 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
4644 tree decl = DECL_EXPR_DECL (decl_s);
4645 tree init = DECL_INITIAL (decl);
4646 /* Mark the decl as addressable if the compound literal
4647 expression is addressable now, otherwise it is marked too late
4648 after we gimplify the initialization expression. */
4649 if (TREE_ADDRESSABLE (*expr_p))
4650 TREE_ADDRESSABLE (decl) = 1;
4651 /* Otherwise, if we don't need an lvalue and have a literal directly
4652 substitute it. Check if it matches the gimple predicate, as
4653 otherwise we'd generate a new temporary, and we can as well just
4654 use the decl we already have. */
4655 else if (!TREE_ADDRESSABLE (decl)
4656 && init
4657 && (fallback & fb_lvalue) == 0
4658 && gimple_test_f (init))
4660 *expr_p = init;
4661 return GS_OK;
4664 /* Preliminarily mark non-addressed complex variables as eligible
4665 for promotion to gimple registers. We'll transform their uses
4666 as we find them. */
4667 if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
4668 || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
4669 && !TREE_THIS_VOLATILE (decl)
4670 && !needs_to_live_in_memory (decl))
4671 DECL_GIMPLE_REG_P (decl) = 1;
4673 /* If the decl is not addressable, then it is being used in some
4674 expression or on the right hand side of a statement, and it can
4675 be put into a readonly data section. */
4676 if (!TREE_ADDRESSABLE (decl) && (fallback & fb_lvalue) == 0)
4677 TREE_READONLY (decl) = 1;
4679 /* This decl isn't mentioned in the enclosing block, so add it to the
4680 list of temps. FIXME it seems a bit of a kludge to say that
4681 anonymous artificial vars aren't pushed, but everything else is. */
4682 if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
4683 gimple_add_tmp_var (decl);
4685 gimplify_and_add (decl_s, pre_p);
4686 *expr_p = decl;
4687 return GS_OK;
4690 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
4691 return a new CONSTRUCTOR if something changed. */
4693 static tree
4694 optimize_compound_literals_in_ctor (tree orig_ctor)
4696 tree ctor = orig_ctor;
4697 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ctor);
4698 unsigned int idx, num = vec_safe_length (elts);
4700 for (idx = 0; idx < num; idx++)
4702 tree value = (*elts)[idx].value;
4703 tree newval = value;
4704 if (TREE_CODE (value) == CONSTRUCTOR)
4705 newval = optimize_compound_literals_in_ctor (value);
4706 else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
4708 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (value);
4709 tree decl = DECL_EXPR_DECL (decl_s);
4710 tree init = DECL_INITIAL (decl);
4712 if (!TREE_ADDRESSABLE (value)
4713 && !TREE_ADDRESSABLE (decl)
4714 && init
4715 && TREE_CODE (init) == CONSTRUCTOR)
4716 newval = optimize_compound_literals_in_ctor (init);
4718 if (newval == value)
4719 continue;
4721 if (ctor == orig_ctor)
4723 ctor = copy_node (orig_ctor);
4724 CONSTRUCTOR_ELTS (ctor) = vec_safe_copy (elts);
4725 elts = CONSTRUCTOR_ELTS (ctor);
4727 (*elts)[idx].value = newval;
4729 return ctor;
4732 /* A subroutine of gimplify_modify_expr. Break out elements of a
4733 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
4735 Note that we still need to clear any elements that don't have explicit
4736 initializers, so if not all elements are initialized we keep the
4737 original MODIFY_EXPR, we just remove all of the constructor elements.
4739 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
4740 GS_ERROR if we would have to create a temporary when gimplifying
4741 this constructor. Otherwise, return GS_OK.
4743 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
4745 static enum gimplify_status
4746 gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
4747 bool want_value, bool notify_temp_creation)
4749 tree object, ctor, type;
4750 enum gimplify_status ret;
4751 vec<constructor_elt, va_gc> *elts;
4753 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR);
4755 if (!notify_temp_creation)
4757 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
4758 is_gimple_lvalue, fb_lvalue);
4759 if (ret == GS_ERROR)
4760 return ret;
4763 object = TREE_OPERAND (*expr_p, 0);
4764 ctor = TREE_OPERAND (*expr_p, 1)
4765 = optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p, 1));
4766 type = TREE_TYPE (ctor);
4767 elts = CONSTRUCTOR_ELTS (ctor);
4768 ret = GS_ALL_DONE;
4770 switch (TREE_CODE (type))
4772 case RECORD_TYPE:
4773 case UNION_TYPE:
4774 case QUAL_UNION_TYPE:
4775 case ARRAY_TYPE:
4777 struct gimplify_init_ctor_preeval_data preeval_data;
4778 HOST_WIDE_INT num_ctor_elements, num_nonzero_elements;
4779 bool cleared, complete_p, valid_const_initializer;
4781 /* Aggregate types must lower constructors to initialization of
4782 individual elements. The exception is that a CONSTRUCTOR node
4783 with no elements indicates zero-initialization of the whole. */
4784 if (vec_safe_is_empty (elts))
4786 if (notify_temp_creation)
4787 return GS_OK;
4788 break;
4791 /* Fetch information about the constructor to direct later processing.
4792 We might want to make static versions of it in various cases, and
4793 can only do so if it known to be a valid constant initializer. */
4794 valid_const_initializer
4795 = categorize_ctor_elements (ctor, &num_nonzero_elements,
4796 &num_ctor_elements, &complete_p);
4798 /* If a const aggregate variable is being initialized, then it
4799 should never be a lose to promote the variable to be static. */
4800 if (valid_const_initializer
4801 && num_nonzero_elements > 1
4802 && TREE_READONLY (object)
4803 && VAR_P (object)
4804 && (flag_merge_constants >= 2 || !TREE_ADDRESSABLE (object)))
4806 if (notify_temp_creation)
4807 return GS_ERROR;
4808 DECL_INITIAL (object) = ctor;
4809 TREE_STATIC (object) = 1;
4810 if (!DECL_NAME (object))
4811 DECL_NAME (object) = create_tmp_var_name ("C");
4812 walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
4814 /* ??? C++ doesn't automatically append a .<number> to the
4815 assembler name, and even when it does, it looks at FE private
4816 data structures to figure out what that number should be,
4817 which are not set for this variable. I suppose this is
4818 important for local statics for inline functions, which aren't
4819 "local" in the object file sense. So in order to get a unique
4820 TU-local symbol, we must invoke the lhd version now. */
4821 lhd_set_decl_assembler_name (object);
4823 *expr_p = NULL_TREE;
4824 break;
4827 /* If there are "lots" of initialized elements, even discounting
4828 those that are not address constants (and thus *must* be
4829 computed at runtime), then partition the constructor into
4830 constant and non-constant parts. Block copy the constant
4831 parts in, then generate code for the non-constant parts. */
4832 /* TODO. There's code in cp/typeck.c to do this. */
4834 if (int_size_in_bytes (TREE_TYPE (ctor)) < 0)
4835 /* store_constructor will ignore the clearing of variable-sized
4836 objects. Initializers for such objects must explicitly set
4837 every field that needs to be set. */
4838 cleared = false;
4839 else if (!complete_p && !CONSTRUCTOR_NO_CLEARING (ctor))
4840 /* If the constructor isn't complete, clear the whole object
4841 beforehand, unless CONSTRUCTOR_NO_CLEARING is set on it.
4843 ??? This ought not to be needed. For any element not present
4844 in the initializer, we should simply set them to zero. Except
4845 we'd need to *find* the elements that are not present, and that
4846 requires trickery to avoid quadratic compile-time behavior in
4847 large cases or excessive memory use in small cases. */
4848 cleared = true;
4849 else if (num_ctor_elements - num_nonzero_elements
4850 > CLEAR_RATIO (optimize_function_for_speed_p (cfun))
4851 && num_nonzero_elements < num_ctor_elements / 4)
4852 /* If there are "lots" of zeros, it's more efficient to clear
4853 the memory and then set the nonzero elements. */
4854 cleared = true;
4855 else
4856 cleared = false;
4858 /* If there are "lots" of initialized elements, and all of them
4859 are valid address constants, then the entire initializer can
4860 be dropped to memory, and then memcpy'd out. Don't do this
4861 for sparse arrays, though, as it's more efficient to follow
4862 the standard CONSTRUCTOR behavior of memset followed by
4863 individual element initialization. Also don't do this for small
4864 all-zero initializers (which aren't big enough to merit
4865 clearing), and don't try to make bitwise copies of
4866 TREE_ADDRESSABLE types.
4868 We cannot apply such transformation when compiling chkp static
4869 initializer because creation of initializer image in the memory
4870 will require static initialization of bounds for it. It should
4871 result in another gimplification of similar initializer and we
4872 may fall into infinite loop. */
4873 if (valid_const_initializer
4874 && !(cleared || num_nonzero_elements == 0)
4875 && !TREE_ADDRESSABLE (type)
4876 && (!current_function_decl
4877 || !lookup_attribute ("chkp ctor",
4878 DECL_ATTRIBUTES (current_function_decl))))
4880 HOST_WIDE_INT size = int_size_in_bytes (type);
4881 unsigned int align;
4883 /* ??? We can still get unbounded array types, at least
4884 from the C++ front end. This seems wrong, but attempt
4885 to work around it for now. */
4886 if (size < 0)
4888 size = int_size_in_bytes (TREE_TYPE (object));
4889 if (size >= 0)
4890 TREE_TYPE (ctor) = type = TREE_TYPE (object);
4893 /* Find the maximum alignment we can assume for the object. */
4894 /* ??? Make use of DECL_OFFSET_ALIGN. */
4895 if (DECL_P (object))
4896 align = DECL_ALIGN (object);
4897 else
4898 align = TYPE_ALIGN (type);
4900 /* Do a block move either if the size is so small as to make
4901 each individual move a sub-unit move on average, or if it
4902 is so large as to make individual moves inefficient. */
4903 if (size > 0
4904 && num_nonzero_elements > 1
4905 && (size < num_nonzero_elements
4906 || !can_move_by_pieces (size, align)))
4908 if (notify_temp_creation)
4909 return GS_ERROR;
4911 walk_tree (&ctor, force_labels_r, NULL, NULL);
4912 ctor = tree_output_constant_def (ctor);
4913 if (!useless_type_conversion_p (type, TREE_TYPE (ctor)))
4914 ctor = build1 (VIEW_CONVERT_EXPR, type, ctor);
4915 TREE_OPERAND (*expr_p, 1) = ctor;
4917 /* This is no longer an assignment of a CONSTRUCTOR, but
4918 we still may have processing to do on the LHS. So
4919 pretend we didn't do anything here to let that happen. */
4920 return GS_UNHANDLED;
4924 /* If the target is volatile, we have non-zero elements and more than
4925 one field to assign, initialize the target from a temporary. */
4926 if (TREE_THIS_VOLATILE (object)
4927 && !TREE_ADDRESSABLE (type)
4928 && num_nonzero_elements > 0
4929 && vec_safe_length (elts) > 1)
4931 tree temp = create_tmp_var (TYPE_MAIN_VARIANT (type));
4932 TREE_OPERAND (*expr_p, 0) = temp;
4933 *expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
4934 *expr_p,
4935 build2 (MODIFY_EXPR, void_type_node,
4936 object, temp));
4937 return GS_OK;
4940 if (notify_temp_creation)
4941 return GS_OK;
4943 /* If there are nonzero elements and if needed, pre-evaluate to capture
4944 elements overlapping with the lhs into temporaries. We must do this
4945 before clearing to fetch the values before they are zeroed-out. */
4946 if (num_nonzero_elements > 0 && TREE_CODE (*expr_p) != INIT_EXPR)
4948 preeval_data.lhs_base_decl = get_base_address (object);
4949 if (!DECL_P (preeval_data.lhs_base_decl))
4950 preeval_data.lhs_base_decl = NULL;
4951 preeval_data.lhs_alias_set = get_alias_set (object);
4953 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
4954 pre_p, post_p, &preeval_data);
4957 bool ctor_has_side_effects_p
4958 = TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1));
4960 if (cleared)
4962 /* Zap the CONSTRUCTOR element list, which simplifies this case.
4963 Note that we still have to gimplify, in order to handle the
4964 case of variable sized types. Avoid shared tree structures. */
4965 CONSTRUCTOR_ELTS (ctor) = NULL;
4966 TREE_SIDE_EFFECTS (ctor) = 0;
4967 object = unshare_expr (object);
4968 gimplify_stmt (expr_p, pre_p);
4971 /* If we have not block cleared the object, or if there are nonzero
4972 elements in the constructor, or if the constructor has side effects,
4973 add assignments to the individual scalar fields of the object. */
4974 if (!cleared
4975 || num_nonzero_elements > 0
4976 || ctor_has_side_effects_p)
4977 gimplify_init_ctor_eval (object, elts, pre_p, cleared);
4979 *expr_p = NULL_TREE;
4981 break;
4983 case COMPLEX_TYPE:
4985 tree r, i;
4987 if (notify_temp_creation)
4988 return GS_OK;
4990 /* Extract the real and imaginary parts out of the ctor. */
4991 gcc_assert (elts->length () == 2);
4992 r = (*elts)[0].value;
4993 i = (*elts)[1].value;
4994 if (r == NULL || i == NULL)
4996 tree zero = build_zero_cst (TREE_TYPE (type));
4997 if (r == NULL)
4998 r = zero;
4999 if (i == NULL)
5000 i = zero;
5003 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
5004 represent creation of a complex value. */
5005 if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
5007 ctor = build_complex (type, r, i);
5008 TREE_OPERAND (*expr_p, 1) = ctor;
5010 else
5012 ctor = build2 (COMPLEX_EXPR, type, r, i);
5013 TREE_OPERAND (*expr_p, 1) = ctor;
5014 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1),
5015 pre_p,
5016 post_p,
5017 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
5018 fb_rvalue);
5021 break;
5023 case VECTOR_TYPE:
5025 unsigned HOST_WIDE_INT ix;
5026 constructor_elt *ce;
5028 if (notify_temp_creation)
5029 return GS_OK;
5031 /* Go ahead and simplify constant constructors to VECTOR_CST. */
5032 if (TREE_CONSTANT (ctor))
5034 bool constant_p = true;
5035 tree value;
5037 /* Even when ctor is constant, it might contain non-*_CST
5038 elements, such as addresses or trapping values like
5039 1.0/0.0 - 1.0/0.0. Such expressions don't belong
5040 in VECTOR_CST nodes. */
5041 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
5042 if (!CONSTANT_CLASS_P (value))
5044 constant_p = false;
5045 break;
5048 if (constant_p)
5050 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
5051 break;
5054 TREE_CONSTANT (ctor) = 0;
5057 /* Vector types use CONSTRUCTOR all the way through gimple
5058 compilation as a general initializer. */
5059 FOR_EACH_VEC_SAFE_ELT (elts, ix, ce)
5061 enum gimplify_status tret;
5062 tret = gimplify_expr (&ce->value, pre_p, post_p, is_gimple_val,
5063 fb_rvalue);
5064 if (tret == GS_ERROR)
5065 ret = GS_ERROR;
5066 else if (TREE_STATIC (ctor)
5067 && !initializer_constant_valid_p (ce->value,
5068 TREE_TYPE (ce->value)))
5069 TREE_STATIC (ctor) = 0;
5071 if (!is_gimple_reg (TREE_OPERAND (*expr_p, 0)))
5072 TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
5074 break;
5076 default:
5077 /* So how did we get a CONSTRUCTOR for a scalar type? */
5078 gcc_unreachable ();
5081 if (ret == GS_ERROR)
5082 return GS_ERROR;
5083 /* If we have gimplified both sides of the initializer but have
5084 not emitted an assignment, do so now. */
5085 if (*expr_p)
5087 tree lhs = TREE_OPERAND (*expr_p, 0);
5088 tree rhs = TREE_OPERAND (*expr_p, 1);
5089 if (want_value && object == lhs)
5090 lhs = unshare_expr (lhs);
5091 gassign *init = gimple_build_assign (lhs, rhs);
5092 gimplify_seq_add_stmt (pre_p, init);
5094 if (want_value)
5096 *expr_p = object;
5097 return GS_OK;
5099 else
5101 *expr_p = NULL;
5102 return GS_ALL_DONE;
5106 /* Given a pointer value OP0, return a simplified version of an
5107 indirection through OP0, or NULL_TREE if no simplification is
5108 possible. This may only be applied to a rhs of an expression.
5109 Note that the resulting type may be different from the type pointed
5110 to in the sense that it is still compatible from the langhooks
5111 point of view. */
5113 static tree
5114 gimple_fold_indirect_ref_rhs (tree t)
5116 return gimple_fold_indirect_ref (t);
5119 /* Subroutine of gimplify_modify_expr to do simplifications of
5120 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
5121 something changes. */
5123 static enum gimplify_status
5124 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p,
5125 gimple_seq *pre_p, gimple_seq *post_p,
5126 bool want_value)
5128 enum gimplify_status ret = GS_UNHANDLED;
5129 bool changed;
5133 changed = false;
5134 switch (TREE_CODE (*from_p))
5136 case VAR_DECL:
5137 /* If we're assigning from a read-only variable initialized with
5138 a constructor, do the direct assignment from the constructor,
5139 but only if neither source nor target are volatile since this
5140 latter assignment might end up being done on a per-field basis. */
5141 if (DECL_INITIAL (*from_p)
5142 && TREE_READONLY (*from_p)
5143 && !TREE_THIS_VOLATILE (*from_p)
5144 && !TREE_THIS_VOLATILE (*to_p)
5145 && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
5147 tree old_from = *from_p;
5148 enum gimplify_status subret;
5150 /* Move the constructor into the RHS. */
5151 *from_p = unshare_expr (DECL_INITIAL (*from_p));
5153 /* Let's see if gimplify_init_constructor will need to put
5154 it in memory. */
5155 subret = gimplify_init_constructor (expr_p, NULL, NULL,
5156 false, true);
5157 if (subret == GS_ERROR)
5159 /* If so, revert the change. */
5160 *from_p = old_from;
5162 else
5164 ret = GS_OK;
5165 changed = true;
5168 break;
5169 case INDIRECT_REF:
5171 /* If we have code like
5173 *(const A*)(A*)&x
5175 where the type of "x" is a (possibly cv-qualified variant
5176 of "A"), treat the entire expression as identical to "x".
5177 This kind of code arises in C++ when an object is bound
5178 to a const reference, and if "x" is a TARGET_EXPR we want
5179 to take advantage of the optimization below. */
5180 bool volatile_p = TREE_THIS_VOLATILE (*from_p);
5181 tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
5182 if (t)
5184 if (TREE_THIS_VOLATILE (t) != volatile_p)
5186 if (DECL_P (t))
5187 t = build_simple_mem_ref_loc (EXPR_LOCATION (*from_p),
5188 build_fold_addr_expr (t));
5189 if (REFERENCE_CLASS_P (t))
5190 TREE_THIS_VOLATILE (t) = volatile_p;
5192 *from_p = t;
5193 ret = GS_OK;
5194 changed = true;
5196 break;
5199 case TARGET_EXPR:
5201 /* If we are initializing something from a TARGET_EXPR, strip the
5202 TARGET_EXPR and initialize it directly, if possible. This can't
5203 be done if the initializer is void, since that implies that the
5204 temporary is set in some non-trivial way.
5206 ??? What about code that pulls out the temp and uses it
5207 elsewhere? I think that such code never uses the TARGET_EXPR as
5208 an initializer. If I'm wrong, we'll die because the temp won't
5209 have any RTL. In that case, I guess we'll need to replace
5210 references somehow. */
5211 tree init = TARGET_EXPR_INITIAL (*from_p);
5213 if (init
5214 && !VOID_TYPE_P (TREE_TYPE (init)))
5216 *from_p = init;
5217 ret = GS_OK;
5218 changed = true;
5221 break;
5223 case COMPOUND_EXPR:
5224 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
5225 caught. */
5226 gimplify_compound_expr (from_p, pre_p, true);
5227 ret = GS_OK;
5228 changed = true;
5229 break;
5231 case CONSTRUCTOR:
5232 /* If we already made some changes, let the front end have a
5233 crack at this before we break it down. */
5234 if (ret != GS_UNHANDLED)
5235 break;
5236 /* If we're initializing from a CONSTRUCTOR, break this into
5237 individual MODIFY_EXPRs. */
5238 return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
5239 false);
5241 case COND_EXPR:
5242 /* If we're assigning to a non-register type, push the assignment
5243 down into the branches. This is mandatory for ADDRESSABLE types,
5244 since we cannot generate temporaries for such, but it saves a
5245 copy in other cases as well. */
5246 if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
5248 /* This code should mirror the code in gimplify_cond_expr. */
5249 enum tree_code code = TREE_CODE (*expr_p);
5250 tree cond = *from_p;
5251 tree result = *to_p;
5253 ret = gimplify_expr (&result, pre_p, post_p,
5254 is_gimple_lvalue, fb_lvalue);
5255 if (ret != GS_ERROR)
5256 ret = GS_OK;
5258 /* If we are going to write RESULT more than once, clear
5259 TREE_READONLY flag, otherwise we might incorrectly promote
5260 the variable to static const and initialize it at compile
5261 time in one of the branches. */
5262 if (VAR_P (result)
5263 && TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node
5264 && TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
5265 TREE_READONLY (result) = 0;
5266 if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
5267 TREE_OPERAND (cond, 1)
5268 = build2 (code, void_type_node, result,
5269 TREE_OPERAND (cond, 1));
5270 if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
5271 TREE_OPERAND (cond, 2)
5272 = build2 (code, void_type_node, unshare_expr (result),
5273 TREE_OPERAND (cond, 2));
5275 TREE_TYPE (cond) = void_type_node;
5276 recalculate_side_effects (cond);
5278 if (want_value)
5280 gimplify_and_add (cond, pre_p);
5281 *expr_p = unshare_expr (result);
5283 else
5284 *expr_p = cond;
5285 return ret;
5287 break;
5289 case CALL_EXPR:
5290 /* For calls that return in memory, give *to_p as the CALL_EXPR's
5291 return slot so that we don't generate a temporary. */
5292 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
5293 && aggregate_value_p (*from_p, *from_p))
5295 bool use_target;
5297 if (!(rhs_predicate_for (*to_p))(*from_p))
5298 /* If we need a temporary, *to_p isn't accurate. */
5299 use_target = false;
5300 /* It's OK to use the return slot directly unless it's an NRV. */
5301 else if (TREE_CODE (*to_p) == RESULT_DECL
5302 && DECL_NAME (*to_p) == NULL_TREE
5303 && needs_to_live_in_memory (*to_p))
5304 use_target = true;
5305 else if (is_gimple_reg_type (TREE_TYPE (*to_p))
5306 || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
5307 /* Don't force regs into memory. */
5308 use_target = false;
5309 else if (TREE_CODE (*expr_p) == INIT_EXPR)
5310 /* It's OK to use the target directly if it's being
5311 initialized. */
5312 use_target = true;
5313 else if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (*to_p)))
5314 != INTEGER_CST)
5315 /* Always use the target and thus RSO for variable-sized types.
5316 GIMPLE cannot deal with a variable-sized assignment
5317 embedded in a call statement. */
5318 use_target = true;
5319 else if (TREE_CODE (*to_p) != SSA_NAME
5320 && (!is_gimple_variable (*to_p)
5321 || needs_to_live_in_memory (*to_p)))
5322 /* Don't use the original target if it's already addressable;
5323 if its address escapes, and the called function uses the
5324 NRV optimization, a conforming program could see *to_p
5325 change before the called function returns; see c++/19317.
5326 When optimizing, the return_slot pass marks more functions
5327 as safe after we have escape info. */
5328 use_target = false;
5329 else
5330 use_target = true;
5332 if (use_target)
5334 CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
5335 mark_addressable (*to_p);
5338 break;
5340 case WITH_SIZE_EXPR:
5341 /* Likewise for calls that return an aggregate of non-constant size,
5342 since we would not be able to generate a temporary at all. */
5343 if (TREE_CODE (TREE_OPERAND (*from_p, 0)) == CALL_EXPR)
5345 *from_p = TREE_OPERAND (*from_p, 0);
5346 /* We don't change ret in this case because the
5347 WITH_SIZE_EXPR might have been added in
5348 gimplify_modify_expr, so returning GS_OK would lead to an
5349 infinite loop. */
5350 changed = true;
5352 break;
5354 /* If we're initializing from a container, push the initialization
5355 inside it. */
5356 case CLEANUP_POINT_EXPR:
5357 case BIND_EXPR:
5358 case STATEMENT_LIST:
5360 tree wrap = *from_p;
5361 tree t;
5363 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
5364 fb_lvalue);
5365 if (ret != GS_ERROR)
5366 ret = GS_OK;
5368 t = voidify_wrapper_expr (wrap, *expr_p);
5369 gcc_assert (t == *expr_p);
5371 if (want_value)
5373 gimplify_and_add (wrap, pre_p);
5374 *expr_p = unshare_expr (*to_p);
5376 else
5377 *expr_p = wrap;
5378 return GS_OK;
5381 case COMPOUND_LITERAL_EXPR:
5383 tree complit = TREE_OPERAND (*expr_p, 1);
5384 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (complit);
5385 tree decl = DECL_EXPR_DECL (decl_s);
5386 tree init = DECL_INITIAL (decl);
5388 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
5389 into struct T x = { 0, 1, 2 } if the address of the
5390 compound literal has never been taken. */
5391 if (!TREE_ADDRESSABLE (complit)
5392 && !TREE_ADDRESSABLE (decl)
5393 && init)
5395 *expr_p = copy_node (*expr_p);
5396 TREE_OPERAND (*expr_p, 1) = init;
5397 return GS_OK;
5401 default:
5402 break;
5405 while (changed);
5407 return ret;
5411 /* Return true if T looks like a valid GIMPLE statement. */
5413 static bool
5414 is_gimple_stmt (tree t)
5416 const enum tree_code code = TREE_CODE (t);
5418 switch (code)
5420 case NOP_EXPR:
5421 /* The only valid NOP_EXPR is the empty statement. */
5422 return IS_EMPTY_STMT (t);
5424 case BIND_EXPR:
5425 case COND_EXPR:
5426 /* These are only valid if they're void. */
5427 return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
5429 case SWITCH_EXPR:
5430 case GOTO_EXPR:
5431 case RETURN_EXPR:
5432 case LABEL_EXPR:
5433 case CASE_LABEL_EXPR:
5434 case TRY_CATCH_EXPR:
5435 case TRY_FINALLY_EXPR:
5436 case EH_FILTER_EXPR:
5437 case CATCH_EXPR:
5438 case ASM_EXPR:
5439 case STATEMENT_LIST:
5440 case OACC_PARALLEL:
5441 case OACC_KERNELS:
5442 case OACC_DATA:
5443 case OACC_HOST_DATA:
5444 case OACC_DECLARE:
5445 case OACC_UPDATE:
5446 case OACC_ENTER_DATA:
5447 case OACC_EXIT_DATA:
5448 case OACC_CACHE:
5449 case OMP_PARALLEL:
5450 case OMP_FOR:
5451 case OMP_SIMD:
5452 case OMP_DISTRIBUTE:
5453 case OACC_LOOP:
5454 case OMP_SECTIONS:
5455 case OMP_SECTION:
5456 case OMP_SINGLE:
5457 case OMP_MASTER:
5458 case OMP_TASKGROUP:
5459 case OMP_ORDERED:
5460 case OMP_CRITICAL:
5461 case OMP_TASK:
5462 case OMP_TARGET:
5463 case OMP_TARGET_DATA:
5464 case OMP_TARGET_UPDATE:
5465 case OMP_TARGET_ENTER_DATA:
5466 case OMP_TARGET_EXIT_DATA:
5467 case OMP_TASKLOOP:
5468 case OMP_TEAMS:
5469 /* These are always void. */
5470 return true;
5472 case CALL_EXPR:
5473 case MODIFY_EXPR:
5474 case PREDICT_EXPR:
5475 /* These are valid regardless of their type. */
5476 return true;
5478 default:
5479 return false;
5484 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
5485 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
5486 DECL_GIMPLE_REG_P set.
5488 IMPORTANT NOTE: This promotion is performed by introducing a load of the
5489 other, unmodified part of the complex object just before the total store.
5490 As a consequence, if the object is still uninitialized, an undefined value
5491 will be loaded into a register, which may result in a spurious exception
5492 if the register is floating-point and the value happens to be a signaling
5493 NaN for example. Then the fully-fledged complex operations lowering pass
5494 followed by a DCE pass are necessary in order to fix things up. */
5496 static enum gimplify_status
5497 gimplify_modify_expr_complex_part (tree *expr_p, gimple_seq *pre_p,
5498 bool want_value)
5500 enum tree_code code, ocode;
5501 tree lhs, rhs, new_rhs, other, realpart, imagpart;
5503 lhs = TREE_OPERAND (*expr_p, 0);
5504 rhs = TREE_OPERAND (*expr_p, 1);
5505 code = TREE_CODE (lhs);
5506 lhs = TREE_OPERAND (lhs, 0);
5508 ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR;
5509 other = build1 (ocode, TREE_TYPE (rhs), lhs);
5510 TREE_NO_WARNING (other) = 1;
5511 other = get_formal_tmp_var (other, pre_p);
5513 realpart = code == REALPART_EXPR ? rhs : other;
5514 imagpart = code == REALPART_EXPR ? other : rhs;
5516 if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart))
5517 new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart);
5518 else
5519 new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
5521 gimplify_seq_add_stmt (pre_p, gimple_build_assign (lhs, new_rhs));
5522 *expr_p = (want_value) ? rhs : NULL_TREE;
5524 return GS_ALL_DONE;
5527 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
5529 modify_expr
5530 : varname '=' rhs
5531 | '*' ID '=' rhs
5533 PRE_P points to the list where side effects that must happen before
5534 *EXPR_P should be stored.
5536 POST_P points to the list where side effects that must happen after
5537 *EXPR_P should be stored.
5539 WANT_VALUE is nonzero iff we want to use the value of this expression
5540 in another expression. */
5542 static enum gimplify_status
5543 gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
5544 bool want_value)
5546 tree *from_p = &TREE_OPERAND (*expr_p, 1);
5547 tree *to_p = &TREE_OPERAND (*expr_p, 0);
5548 enum gimplify_status ret = GS_UNHANDLED;
5549 gimple *assign;
5550 location_t loc = EXPR_LOCATION (*expr_p);
5551 gimple_stmt_iterator gsi;
5553 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
5554 || TREE_CODE (*expr_p) == INIT_EXPR);
5556 /* Trying to simplify a clobber using normal logic doesn't work,
5557 so handle it here. */
5558 if (TREE_CLOBBER_P (*from_p))
5560 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
5561 if (ret == GS_ERROR)
5562 return ret;
5563 gcc_assert (!want_value
5564 && (VAR_P (*to_p) || TREE_CODE (*to_p) == MEM_REF));
5565 gimplify_seq_add_stmt (pre_p, gimple_build_assign (*to_p, *from_p));
5566 *expr_p = NULL;
5567 return GS_ALL_DONE;
5570 /* Insert pointer conversions required by the middle-end that are not
5571 required by the frontend. This fixes middle-end type checking for
5572 for example gcc.dg/redecl-6.c. */
5573 if (POINTER_TYPE_P (TREE_TYPE (*to_p)))
5575 STRIP_USELESS_TYPE_CONVERSION (*from_p);
5576 if (!useless_type_conversion_p (TREE_TYPE (*to_p), TREE_TYPE (*from_p)))
5577 *from_p = fold_convert_loc (loc, TREE_TYPE (*to_p), *from_p);
5580 /* See if any simplifications can be done based on what the RHS is. */
5581 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
5582 want_value);
5583 if (ret != GS_UNHANDLED)
5584 return ret;
5586 /* For zero sized types only gimplify the left hand side and right hand
5587 side as statements and throw away the assignment. Do this after
5588 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
5589 types properly. */
5590 if (zero_sized_type (TREE_TYPE (*from_p))
5591 && !want_value
5592 /* Don't do this for calls that return addressable types, expand_call
5593 relies on those having a lhs. */
5594 && !(TREE_ADDRESSABLE (TREE_TYPE (*from_p))
5595 && TREE_CODE (*from_p) == CALL_EXPR))
5597 gimplify_stmt (from_p, pre_p);
5598 gimplify_stmt (to_p, pre_p);
5599 *expr_p = NULL_TREE;
5600 return GS_ALL_DONE;
5603 /* If the value being copied is of variable width, compute the length
5604 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
5605 before gimplifying any of the operands so that we can resolve any
5606 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
5607 the size of the expression to be copied, not of the destination, so
5608 that is what we must do here. */
5609 maybe_with_size_expr (from_p);
5611 /* As a special case, we have to temporarily allow for assignments
5612 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
5613 a toplevel statement, when gimplifying the GENERIC expression
5614 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
5615 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
5617 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
5618 prevent gimplify_expr from trying to create a new temporary for
5619 foo's LHS, we tell it that it should only gimplify until it
5620 reaches the CALL_EXPR. On return from gimplify_expr, the newly
5621 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
5622 and all we need to do here is set 'a' to be its LHS. */
5624 /* Gimplify the RHS first for C++17 and bug 71104. */
5625 gimple_predicate initial_pred = initial_rhs_predicate_for (*to_p);
5626 ret = gimplify_expr (from_p, pre_p, post_p, initial_pred, fb_rvalue);
5627 if (ret == GS_ERROR)
5628 return ret;
5630 /* Then gimplify the LHS. */
5631 /* If we gimplified the RHS to a CALL_EXPR and that call may return
5632 twice we have to make sure to gimplify into non-SSA as otherwise
5633 the abnormal edge added later will make those defs not dominate
5634 their uses.
5635 ??? Technically this applies only to the registers used in the
5636 resulting non-register *TO_P. */
5637 bool saved_into_ssa = gimplify_ctxp->into_ssa;
5638 if (saved_into_ssa
5639 && TREE_CODE (*from_p) == CALL_EXPR
5640 && call_expr_flags (*from_p) & ECF_RETURNS_TWICE)
5641 gimplify_ctxp->into_ssa = false;
5642 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
5643 gimplify_ctxp->into_ssa = saved_into_ssa;
5644 if (ret == GS_ERROR)
5645 return ret;
5647 /* Now that the LHS is gimplified, re-gimplify the RHS if our initial
5648 guess for the predicate was wrong. */
5649 gimple_predicate final_pred = rhs_predicate_for (*to_p);
5650 if (final_pred != initial_pred)
5652 ret = gimplify_expr (from_p, pre_p, post_p, final_pred, fb_rvalue);
5653 if (ret == GS_ERROR)
5654 return ret;
5657 /* In case of va_arg internal fn wrappped in a WITH_SIZE_EXPR, add the type
5658 size as argument to the call. */
5659 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
5661 tree call = TREE_OPERAND (*from_p, 0);
5662 tree vlasize = TREE_OPERAND (*from_p, 1);
5664 if (TREE_CODE (call) == CALL_EXPR
5665 && CALL_EXPR_IFN (call) == IFN_VA_ARG)
5667 int nargs = call_expr_nargs (call);
5668 tree type = TREE_TYPE (call);
5669 tree ap = CALL_EXPR_ARG (call, 0);
5670 tree tag = CALL_EXPR_ARG (call, 1);
5671 tree aptag = CALL_EXPR_ARG (call, 2);
5672 tree newcall = build_call_expr_internal_loc (EXPR_LOCATION (call),
5673 IFN_VA_ARG, type,
5674 nargs + 1, ap, tag,
5675 aptag, vlasize);
5676 TREE_OPERAND (*from_p, 0) = newcall;
5680 /* Now see if the above changed *from_p to something we handle specially. */
5681 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
5682 want_value);
5683 if (ret != GS_UNHANDLED)
5684 return ret;
5686 /* If we've got a variable sized assignment between two lvalues (i.e. does
5687 not involve a call), then we can make things a bit more straightforward
5688 by converting the assignment to memcpy or memset. */
5689 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
5691 tree from = TREE_OPERAND (*from_p, 0);
5692 tree size = TREE_OPERAND (*from_p, 1);
5694 if (TREE_CODE (from) == CONSTRUCTOR)
5695 return gimplify_modify_expr_to_memset (expr_p, size, want_value, pre_p);
5697 if (is_gimple_addressable (from))
5699 *from_p = from;
5700 return gimplify_modify_expr_to_memcpy (expr_p, size, want_value,
5701 pre_p);
5705 /* Transform partial stores to non-addressable complex variables into
5706 total stores. This allows us to use real instead of virtual operands
5707 for these variables, which improves optimization. */
5708 if ((TREE_CODE (*to_p) == REALPART_EXPR
5709 || TREE_CODE (*to_p) == IMAGPART_EXPR)
5710 && is_gimple_reg (TREE_OPERAND (*to_p, 0)))
5711 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
5713 /* Try to alleviate the effects of the gimplification creating artificial
5714 temporaries (see for example is_gimple_reg_rhs) on the debug info, but
5715 make sure not to create DECL_DEBUG_EXPR links across functions. */
5716 if (!gimplify_ctxp->into_ssa
5717 && VAR_P (*from_p)
5718 && DECL_IGNORED_P (*from_p)
5719 && DECL_P (*to_p)
5720 && !DECL_IGNORED_P (*to_p)
5721 && decl_function_context (*to_p) == current_function_decl
5722 && decl_function_context (*from_p) == current_function_decl)
5724 if (!DECL_NAME (*from_p) && DECL_NAME (*to_p))
5725 DECL_NAME (*from_p)
5726 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p)));
5727 DECL_HAS_DEBUG_EXPR_P (*from_p) = 1;
5728 SET_DECL_DEBUG_EXPR (*from_p, *to_p);
5731 if (want_value && TREE_THIS_VOLATILE (*to_p))
5732 *from_p = get_initialized_tmp_var (*from_p, pre_p, post_p);
5734 if (TREE_CODE (*from_p) == CALL_EXPR)
5736 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
5737 instead of a GIMPLE_ASSIGN. */
5738 gcall *call_stmt;
5739 if (CALL_EXPR_FN (*from_p) == NULL_TREE)
5741 /* Gimplify internal functions created in the FEs. */
5742 int nargs = call_expr_nargs (*from_p), i;
5743 enum internal_fn ifn = CALL_EXPR_IFN (*from_p);
5744 auto_vec<tree> vargs (nargs);
5746 for (i = 0; i < nargs; i++)
5748 gimplify_arg (&CALL_EXPR_ARG (*from_p, i), pre_p,
5749 EXPR_LOCATION (*from_p));
5750 vargs.quick_push (CALL_EXPR_ARG (*from_p, i));
5752 call_stmt = gimple_build_call_internal_vec (ifn, vargs);
5753 gimple_call_set_nothrow (call_stmt, TREE_NOTHROW (*from_p));
5754 gimple_set_location (call_stmt, EXPR_LOCATION (*expr_p));
5756 else
5758 tree fnptrtype = TREE_TYPE (CALL_EXPR_FN (*from_p));
5759 CALL_EXPR_FN (*from_p) = TREE_OPERAND (CALL_EXPR_FN (*from_p), 0);
5760 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p));
5761 tree fndecl = get_callee_fndecl (*from_p);
5762 if (fndecl
5763 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
5764 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT
5765 && call_expr_nargs (*from_p) == 3)
5766 call_stmt = gimple_build_call_internal (IFN_BUILTIN_EXPECT, 3,
5767 CALL_EXPR_ARG (*from_p, 0),
5768 CALL_EXPR_ARG (*from_p, 1),
5769 CALL_EXPR_ARG (*from_p, 2));
5770 else
5772 call_stmt = gimple_build_call_from_tree (*from_p, fnptrtype);
5775 notice_special_calls (call_stmt);
5776 if (!gimple_call_noreturn_p (call_stmt) || !should_remove_lhs_p (*to_p))
5777 gimple_call_set_lhs (call_stmt, *to_p);
5778 else if (TREE_CODE (*to_p) == SSA_NAME)
5779 /* The above is somewhat premature, avoid ICEing later for a
5780 SSA name w/o a definition. We may have uses in the GIMPLE IL.
5781 ??? This doesn't make it a default-def. */
5782 SSA_NAME_DEF_STMT (*to_p) = gimple_build_nop ();
5784 assign = call_stmt;
5786 else
5788 assign = gimple_build_assign (*to_p, *from_p);
5789 gimple_set_location (assign, EXPR_LOCATION (*expr_p));
5790 if (COMPARISON_CLASS_P (*from_p))
5791 gimple_set_no_warning (assign, TREE_NO_WARNING (*from_p));
5794 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
5796 /* We should have got an SSA name from the start. */
5797 gcc_assert (TREE_CODE (*to_p) == SSA_NAME
5798 || ! gimple_in_ssa_p (cfun));
5801 gimplify_seq_add_stmt (pre_p, assign);
5802 gsi = gsi_last (*pre_p);
5803 maybe_fold_stmt (&gsi);
5805 if (want_value)
5807 *expr_p = TREE_THIS_VOLATILE (*to_p) ? *from_p : unshare_expr (*to_p);
5808 return GS_OK;
5810 else
5811 *expr_p = NULL;
5813 return GS_ALL_DONE;
5816 /* Gimplify a comparison between two variable-sized objects. Do this
5817 with a call to BUILT_IN_MEMCMP. */
5819 static enum gimplify_status
5820 gimplify_variable_sized_compare (tree *expr_p)
5822 location_t loc = EXPR_LOCATION (*expr_p);
5823 tree op0 = TREE_OPERAND (*expr_p, 0);
5824 tree op1 = TREE_OPERAND (*expr_p, 1);
5825 tree t, arg, dest, src, expr;
5827 arg = TYPE_SIZE_UNIT (TREE_TYPE (op0));
5828 arg = unshare_expr (arg);
5829 arg = SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg, op0);
5830 src = build_fold_addr_expr_loc (loc, op1);
5831 dest = build_fold_addr_expr_loc (loc, op0);
5832 t = builtin_decl_implicit (BUILT_IN_MEMCMP);
5833 t = build_call_expr_loc (loc, t, 3, dest, src, arg);
5835 expr
5836 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
5837 SET_EXPR_LOCATION (expr, loc);
5838 *expr_p = expr;
5840 return GS_OK;
5843 /* Gimplify a comparison between two aggregate objects of integral scalar
5844 mode as a comparison between the bitwise equivalent scalar values. */
5846 static enum gimplify_status
5847 gimplify_scalar_mode_aggregate_compare (tree *expr_p)
5849 location_t loc = EXPR_LOCATION (*expr_p);
5850 tree op0 = TREE_OPERAND (*expr_p, 0);
5851 tree op1 = TREE_OPERAND (*expr_p, 1);
5853 tree type = TREE_TYPE (op0);
5854 tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1);
5856 op0 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op0);
5857 op1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op1);
5859 *expr_p
5860 = fold_build2_loc (loc, TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
5862 return GS_OK;
5865 /* Gimplify an expression sequence. This function gimplifies each
5866 expression and rewrites the original expression with the last
5867 expression of the sequence in GIMPLE form.
5869 PRE_P points to the list where the side effects for all the
5870 expressions in the sequence will be emitted.
5872 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
5874 static enum gimplify_status
5875 gimplify_compound_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
5877 tree t = *expr_p;
5881 tree *sub_p = &TREE_OPERAND (t, 0);
5883 if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
5884 gimplify_compound_expr (sub_p, pre_p, false);
5885 else
5886 gimplify_stmt (sub_p, pre_p);
5888 t = TREE_OPERAND (t, 1);
5890 while (TREE_CODE (t) == COMPOUND_EXPR);
5892 *expr_p = t;
5893 if (want_value)
5894 return GS_OK;
5895 else
5897 gimplify_stmt (expr_p, pre_p);
5898 return GS_ALL_DONE;
5902 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
5903 gimplify. After gimplification, EXPR_P will point to a new temporary
5904 that holds the original value of the SAVE_EXPR node.
5906 PRE_P points to the list where side effects that must happen before
5907 *EXPR_P should be stored. */
5909 static enum gimplify_status
5910 gimplify_save_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5912 enum gimplify_status ret = GS_ALL_DONE;
5913 tree val;
5915 gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
5916 val = TREE_OPERAND (*expr_p, 0);
5918 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
5919 if (!SAVE_EXPR_RESOLVED_P (*expr_p))
5921 /* The operand may be a void-valued expression. It is
5922 being executed only for its side-effects. */
5923 if (TREE_TYPE (val) == void_type_node)
5925 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5926 is_gimple_stmt, fb_none);
5927 val = NULL;
5929 else
5930 /* The temporary may not be an SSA name as later abnormal and EH
5931 control flow may invalidate use/def domination. */
5932 val = get_initialized_tmp_var (val, pre_p, post_p, false);
5934 TREE_OPERAND (*expr_p, 0) = val;
5935 SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
5938 *expr_p = val;
5940 return ret;
5943 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
5945 unary_expr
5946 : ...
5947 | '&' varname
5950 PRE_P points to the list where side effects that must happen before
5951 *EXPR_P should be stored.
5953 POST_P points to the list where side effects that must happen after
5954 *EXPR_P should be stored. */
5956 static enum gimplify_status
5957 gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5959 tree expr = *expr_p;
5960 tree op0 = TREE_OPERAND (expr, 0);
5961 enum gimplify_status ret;
5962 location_t loc = EXPR_LOCATION (*expr_p);
5964 switch (TREE_CODE (op0))
5966 case INDIRECT_REF:
5967 do_indirect_ref:
5968 /* Check if we are dealing with an expression of the form '&*ptr'.
5969 While the front end folds away '&*ptr' into 'ptr', these
5970 expressions may be generated internally by the compiler (e.g.,
5971 builtins like __builtin_va_end). */
5972 /* Caution: the silent array decomposition semantics we allow for
5973 ADDR_EXPR means we can't always discard the pair. */
5974 /* Gimplification of the ADDR_EXPR operand may drop
5975 cv-qualification conversions, so make sure we add them if
5976 needed. */
5978 tree op00 = TREE_OPERAND (op0, 0);
5979 tree t_expr = TREE_TYPE (expr);
5980 tree t_op00 = TREE_TYPE (op00);
5982 if (!useless_type_conversion_p (t_expr, t_op00))
5983 op00 = fold_convert_loc (loc, TREE_TYPE (expr), op00);
5984 *expr_p = op00;
5985 ret = GS_OK;
5987 break;
5989 case VIEW_CONVERT_EXPR:
5990 /* Take the address of our operand and then convert it to the type of
5991 this ADDR_EXPR.
5993 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
5994 all clear. The impact of this transformation is even less clear. */
5996 /* If the operand is a useless conversion, look through it. Doing so
5997 guarantees that the ADDR_EXPR and its operand will remain of the
5998 same type. */
5999 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
6000 op0 = TREE_OPERAND (op0, 0);
6002 *expr_p = fold_convert_loc (loc, TREE_TYPE (expr),
6003 build_fold_addr_expr_loc (loc,
6004 TREE_OPERAND (op0, 0)));
6005 ret = GS_OK;
6006 break;
6008 case MEM_REF:
6009 if (integer_zerop (TREE_OPERAND (op0, 1)))
6010 goto do_indirect_ref;
6012 /* fall through */
6014 default:
6015 /* If we see a call to a declared builtin or see its address
6016 being taken (we can unify those cases here) then we can mark
6017 the builtin for implicit generation by GCC. */
6018 if (TREE_CODE (op0) == FUNCTION_DECL
6019 && DECL_BUILT_IN_CLASS (op0) == BUILT_IN_NORMAL
6020 && builtin_decl_declared_p (DECL_FUNCTION_CODE (op0)))
6021 set_builtin_decl_implicit_p (DECL_FUNCTION_CODE (op0), true);
6023 /* We use fb_either here because the C frontend sometimes takes
6024 the address of a call that returns a struct; see
6025 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
6026 the implied temporary explicit. */
6028 /* Make the operand addressable. */
6029 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
6030 is_gimple_addressable, fb_either);
6031 if (ret == GS_ERROR)
6032 break;
6034 /* Then mark it. Beware that it may not be possible to do so directly
6035 if a temporary has been created by the gimplification. */
6036 prepare_gimple_addressable (&TREE_OPERAND (expr, 0), pre_p);
6038 op0 = TREE_OPERAND (expr, 0);
6040 /* For various reasons, the gimplification of the expression
6041 may have made a new INDIRECT_REF. */
6042 if (TREE_CODE (op0) == INDIRECT_REF)
6043 goto do_indirect_ref;
6045 mark_addressable (TREE_OPERAND (expr, 0));
6047 /* The FEs may end up building ADDR_EXPRs early on a decl with
6048 an incomplete type. Re-build ADDR_EXPRs in canonical form
6049 here. */
6050 if (!types_compatible_p (TREE_TYPE (op0), TREE_TYPE (TREE_TYPE (expr))))
6051 *expr_p = build_fold_addr_expr (op0);
6053 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
6054 recompute_tree_invariant_for_addr_expr (*expr_p);
6056 /* If we re-built the ADDR_EXPR add a conversion to the original type
6057 if required. */
6058 if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
6059 *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
6061 break;
6064 return ret;
6067 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
6068 value; output operands should be a gimple lvalue. */
6070 static enum gimplify_status
6071 gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
6073 tree expr;
6074 int noutputs;
6075 const char **oconstraints;
6076 int i;
6077 tree link;
6078 const char *constraint;
6079 bool allows_mem, allows_reg, is_inout;
6080 enum gimplify_status ret, tret;
6081 gasm *stmt;
6082 vec<tree, va_gc> *inputs;
6083 vec<tree, va_gc> *outputs;
6084 vec<tree, va_gc> *clobbers;
6085 vec<tree, va_gc> *labels;
6086 tree link_next;
6088 expr = *expr_p;
6089 noutputs = list_length (ASM_OUTPUTS (expr));
6090 oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
6092 inputs = NULL;
6093 outputs = NULL;
6094 clobbers = NULL;
6095 labels = NULL;
6097 ret = GS_ALL_DONE;
6098 link_next = NULL_TREE;
6099 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = link_next)
6101 bool ok;
6102 size_t constraint_len;
6104 link_next = TREE_CHAIN (link);
6106 oconstraints[i]
6107 = constraint
6108 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
6109 constraint_len = strlen (constraint);
6110 if (constraint_len == 0)
6111 continue;
6113 ok = parse_output_constraint (&constraint, i, 0, 0,
6114 &allows_mem, &allows_reg, &is_inout);
6115 if (!ok)
6117 ret = GS_ERROR;
6118 is_inout = false;
6121 if (!allows_reg && allows_mem)
6122 mark_addressable (TREE_VALUE (link));
6124 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
6125 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
6126 fb_lvalue | fb_mayfail);
6127 if (tret == GS_ERROR)
6129 error ("invalid lvalue in asm output %d", i);
6130 ret = tret;
6133 /* If the constraint does not allow memory make sure we gimplify
6134 it to a register if it is not already but its base is. This
6135 happens for complex and vector components. */
6136 if (!allows_mem)
6138 tree op = TREE_VALUE (link);
6139 if (! is_gimple_val (op)
6140 && is_gimple_reg_type (TREE_TYPE (op))
6141 && is_gimple_reg (get_base_address (op)))
6143 tree tem = create_tmp_reg (TREE_TYPE (op));
6144 tree ass;
6145 if (is_inout)
6147 ass = build2 (MODIFY_EXPR, TREE_TYPE (tem),
6148 tem, unshare_expr (op));
6149 gimplify_and_add (ass, pre_p);
6151 ass = build2 (MODIFY_EXPR, TREE_TYPE (tem), op, tem);
6152 gimplify_and_add (ass, post_p);
6154 TREE_VALUE (link) = tem;
6155 tret = GS_OK;
6159 vec_safe_push (outputs, link);
6160 TREE_CHAIN (link) = NULL_TREE;
6162 if (is_inout)
6164 /* An input/output operand. To give the optimizers more
6165 flexibility, split it into separate input and output
6166 operands. */
6167 tree input;
6168 /* Buffer big enough to format a 32-bit UINT_MAX into. */
6169 char buf[11];
6171 /* Turn the in/out constraint into an output constraint. */
6172 char *p = xstrdup (constraint);
6173 p[0] = '=';
6174 TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
6176 /* And add a matching input constraint. */
6177 if (allows_reg)
6179 sprintf (buf, "%u", i);
6181 /* If there are multiple alternatives in the constraint,
6182 handle each of them individually. Those that allow register
6183 will be replaced with operand number, the others will stay
6184 unchanged. */
6185 if (strchr (p, ',') != NULL)
6187 size_t len = 0, buflen = strlen (buf);
6188 char *beg, *end, *str, *dst;
6190 for (beg = p + 1;;)
6192 end = strchr (beg, ',');
6193 if (end == NULL)
6194 end = strchr (beg, '\0');
6195 if ((size_t) (end - beg) < buflen)
6196 len += buflen + 1;
6197 else
6198 len += end - beg + 1;
6199 if (*end)
6200 beg = end + 1;
6201 else
6202 break;
6205 str = (char *) alloca (len);
6206 for (beg = p + 1, dst = str;;)
6208 const char *tem;
6209 bool mem_p, reg_p, inout_p;
6211 end = strchr (beg, ',');
6212 if (end)
6213 *end = '\0';
6214 beg[-1] = '=';
6215 tem = beg - 1;
6216 parse_output_constraint (&tem, i, 0, 0,
6217 &mem_p, &reg_p, &inout_p);
6218 if (dst != str)
6219 *dst++ = ',';
6220 if (reg_p)
6222 memcpy (dst, buf, buflen);
6223 dst += buflen;
6225 else
6227 if (end)
6228 len = end - beg;
6229 else
6230 len = strlen (beg);
6231 memcpy (dst, beg, len);
6232 dst += len;
6234 if (end)
6235 beg = end + 1;
6236 else
6237 break;
6239 *dst = '\0';
6240 input = build_string (dst - str, str);
6242 else
6243 input = build_string (strlen (buf), buf);
6245 else
6246 input = build_string (constraint_len - 1, constraint + 1);
6248 free (p);
6250 input = build_tree_list (build_tree_list (NULL_TREE, input),
6251 unshare_expr (TREE_VALUE (link)));
6252 ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
6256 link_next = NULL_TREE;
6257 for (link = ASM_INPUTS (expr); link; ++i, link = link_next)
6259 link_next = TREE_CHAIN (link);
6260 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
6261 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
6262 oconstraints, &allows_mem, &allows_reg);
6264 /* If we can't make copies, we can only accept memory. */
6265 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link))))
6267 if (allows_mem)
6268 allows_reg = 0;
6269 else
6271 error ("impossible constraint in %<asm%>");
6272 error ("non-memory input %d must stay in memory", i);
6273 return GS_ERROR;
6277 /* If the operand is a memory input, it should be an lvalue. */
6278 if (!allows_reg && allows_mem)
6280 tree inputv = TREE_VALUE (link);
6281 STRIP_NOPS (inputv);
6282 if (TREE_CODE (inputv) == PREDECREMENT_EXPR
6283 || TREE_CODE (inputv) == PREINCREMENT_EXPR
6284 || TREE_CODE (inputv) == POSTDECREMENT_EXPR
6285 || TREE_CODE (inputv) == POSTINCREMENT_EXPR
6286 || TREE_CODE (inputv) == MODIFY_EXPR)
6287 TREE_VALUE (link) = error_mark_node;
6288 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
6289 is_gimple_lvalue, fb_lvalue | fb_mayfail);
6290 if (tret != GS_ERROR)
6292 /* Unlike output operands, memory inputs are not guaranteed
6293 to be lvalues by the FE, and while the expressions are
6294 marked addressable there, if it is e.g. a statement
6295 expression, temporaries in it might not end up being
6296 addressable. They might be already used in the IL and thus
6297 it is too late to make them addressable now though. */
6298 tree x = TREE_VALUE (link);
6299 while (handled_component_p (x))
6300 x = TREE_OPERAND (x, 0);
6301 if (TREE_CODE (x) == MEM_REF
6302 && TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
6303 x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
6304 if ((VAR_P (x)
6305 || TREE_CODE (x) == PARM_DECL
6306 || TREE_CODE (x) == RESULT_DECL)
6307 && !TREE_ADDRESSABLE (x)
6308 && is_gimple_reg (x))
6310 warning_at (EXPR_LOC_OR_LOC (TREE_VALUE (link),
6311 input_location), 0,
6312 "memory input %d is not directly addressable",
6314 prepare_gimple_addressable (&TREE_VALUE (link), pre_p);
6317 mark_addressable (TREE_VALUE (link));
6318 if (tret == GS_ERROR)
6320 error_at (EXPR_LOC_OR_LOC (TREE_VALUE (link), input_location),
6321 "memory input %d is not directly addressable", i);
6322 ret = tret;
6325 else
6327 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
6328 is_gimple_asm_val, fb_rvalue);
6329 if (tret == GS_ERROR)
6330 ret = tret;
6333 TREE_CHAIN (link) = NULL_TREE;
6334 vec_safe_push (inputs, link);
6337 link_next = NULL_TREE;
6338 for (link = ASM_CLOBBERS (expr); link; ++i, link = link_next)
6340 link_next = TREE_CHAIN (link);
6341 TREE_CHAIN (link) = NULL_TREE;
6342 vec_safe_push (clobbers, link);
6345 link_next = NULL_TREE;
6346 for (link = ASM_LABELS (expr); link; ++i, link = link_next)
6348 link_next = TREE_CHAIN (link);
6349 TREE_CHAIN (link) = NULL_TREE;
6350 vec_safe_push (labels, link);
6353 /* Do not add ASMs with errors to the gimple IL stream. */
6354 if (ret != GS_ERROR)
6356 stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
6357 inputs, outputs, clobbers, labels);
6359 gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr) || noutputs == 0);
6360 gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
6362 gimplify_seq_add_stmt (pre_p, stmt);
6365 return ret;
6368 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
6369 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
6370 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
6371 return to this function.
6373 FIXME should we complexify the prequeue handling instead? Or use flags
6374 for all the cleanups and let the optimizer tighten them up? The current
6375 code seems pretty fragile; it will break on a cleanup within any
6376 non-conditional nesting. But any such nesting would be broken, anyway;
6377 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
6378 and continues out of it. We can do that at the RTL level, though, so
6379 having an optimizer to tighten up try/finally regions would be a Good
6380 Thing. */
6382 static enum gimplify_status
6383 gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
6385 gimple_stmt_iterator iter;
6386 gimple_seq body_sequence = NULL;
6388 tree temp = voidify_wrapper_expr (*expr_p, NULL);
6390 /* We only care about the number of conditions between the innermost
6391 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
6392 any cleanups collected outside the CLEANUP_POINT_EXPR. */
6393 int old_conds = gimplify_ctxp->conditions;
6394 gimple_seq old_cleanups = gimplify_ctxp->conditional_cleanups;
6395 bool old_in_cleanup_point_expr = gimplify_ctxp->in_cleanup_point_expr;
6396 gimplify_ctxp->conditions = 0;
6397 gimplify_ctxp->conditional_cleanups = NULL;
6398 gimplify_ctxp->in_cleanup_point_expr = true;
6400 gimplify_stmt (&TREE_OPERAND (*expr_p, 0), &body_sequence);
6402 gimplify_ctxp->conditions = old_conds;
6403 gimplify_ctxp->conditional_cleanups = old_cleanups;
6404 gimplify_ctxp->in_cleanup_point_expr = old_in_cleanup_point_expr;
6406 for (iter = gsi_start (body_sequence); !gsi_end_p (iter); )
6408 gimple *wce = gsi_stmt (iter);
6410 if (gimple_code (wce) == GIMPLE_WITH_CLEANUP_EXPR)
6412 if (gsi_one_before_end_p (iter))
6414 /* Note that gsi_insert_seq_before and gsi_remove do not
6415 scan operands, unlike some other sequence mutators. */
6416 if (!gimple_wce_cleanup_eh_only (wce))
6417 gsi_insert_seq_before_without_update (&iter,
6418 gimple_wce_cleanup (wce),
6419 GSI_SAME_STMT);
6420 gsi_remove (&iter, true);
6421 break;
6423 else
6425 gtry *gtry;
6426 gimple_seq seq;
6427 enum gimple_try_flags kind;
6429 if (gimple_wce_cleanup_eh_only (wce))
6430 kind = GIMPLE_TRY_CATCH;
6431 else
6432 kind = GIMPLE_TRY_FINALLY;
6433 seq = gsi_split_seq_after (iter);
6435 gtry = gimple_build_try (seq, gimple_wce_cleanup (wce), kind);
6436 /* Do not use gsi_replace here, as it may scan operands.
6437 We want to do a simple structural modification only. */
6438 gsi_set_stmt (&iter, gtry);
6439 iter = gsi_start (gtry->eval);
6442 else
6443 gsi_next (&iter);
6446 gimplify_seq_add_seq (pre_p, body_sequence);
6447 if (temp)
6449 *expr_p = temp;
6450 return GS_OK;
6452 else
6454 *expr_p = NULL;
6455 return GS_ALL_DONE;
6459 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
6460 is the cleanup action required. EH_ONLY is true if the cleanup should
6461 only be executed if an exception is thrown, not on normal exit.
6462 If FORCE_UNCOND is true perform the cleanup unconditionally; this is
6463 only valid for clobbers. */
6465 static void
6466 gimple_push_cleanup (tree var, tree cleanup, bool eh_only, gimple_seq *pre_p,
6467 bool force_uncond = false)
6469 gimple *wce;
6470 gimple_seq cleanup_stmts = NULL;
6472 /* Errors can result in improperly nested cleanups. Which results in
6473 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
6474 if (seen_error ())
6475 return;
6477 if (gimple_conditional_context ())
6479 /* If we're in a conditional context, this is more complex. We only
6480 want to run the cleanup if we actually ran the initialization that
6481 necessitates it, but we want to run it after the end of the
6482 conditional context. So we wrap the try/finally around the
6483 condition and use a flag to determine whether or not to actually
6484 run the destructor. Thus
6486 test ? f(A()) : 0
6488 becomes (approximately)
6490 flag = 0;
6491 try {
6492 if (test) { A::A(temp); flag = 1; val = f(temp); }
6493 else { val = 0; }
6494 } finally {
6495 if (flag) A::~A(temp);
6499 if (force_uncond)
6501 gimplify_stmt (&cleanup, &cleanup_stmts);
6502 wce = gimple_build_wce (cleanup_stmts);
6503 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, wce);
6505 else
6507 tree flag = create_tmp_var (boolean_type_node, "cleanup");
6508 gassign *ffalse = gimple_build_assign (flag, boolean_false_node);
6509 gassign *ftrue = gimple_build_assign (flag, boolean_true_node);
6511 cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
6512 gimplify_stmt (&cleanup, &cleanup_stmts);
6513 wce = gimple_build_wce (cleanup_stmts);
6515 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, ffalse);
6516 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, wce);
6517 gimplify_seq_add_stmt (pre_p, ftrue);
6519 /* Because of this manipulation, and the EH edges that jump
6520 threading cannot redirect, the temporary (VAR) will appear
6521 to be used uninitialized. Don't warn. */
6522 TREE_NO_WARNING (var) = 1;
6525 else
6527 gimplify_stmt (&cleanup, &cleanup_stmts);
6528 wce = gimple_build_wce (cleanup_stmts);
6529 gimple_wce_set_cleanup_eh_only (wce, eh_only);
6530 gimplify_seq_add_stmt (pre_p, wce);
6534 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
6536 static enum gimplify_status
6537 gimplify_target_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
6539 tree targ = *expr_p;
6540 tree temp = TARGET_EXPR_SLOT (targ);
6541 tree init = TARGET_EXPR_INITIAL (targ);
6542 enum gimplify_status ret;
6544 bool unpoison_empty_seq = false;
6545 gimple_stmt_iterator unpoison_it;
6547 if (init)
6549 tree cleanup = NULL_TREE;
6551 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
6552 to the temps list. Handle also variable length TARGET_EXPRs. */
6553 if (TREE_CODE (DECL_SIZE (temp)) != INTEGER_CST)
6555 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp)))
6556 gimplify_type_sizes (TREE_TYPE (temp), pre_p);
6557 gimplify_vla_decl (temp, pre_p);
6559 else
6561 /* Save location where we need to place unpoisoning. It's possible
6562 that a variable will be converted to needs_to_live_in_memory. */
6563 unpoison_it = gsi_last (*pre_p);
6564 unpoison_empty_seq = gsi_end_p (unpoison_it);
6566 gimple_add_tmp_var (temp);
6569 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
6570 expression is supposed to initialize the slot. */
6571 if (VOID_TYPE_P (TREE_TYPE (init)))
6572 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
6573 else
6575 tree init_expr = build2 (INIT_EXPR, void_type_node, temp, init);
6576 init = init_expr;
6577 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
6578 init = NULL;
6579 ggc_free (init_expr);
6581 if (ret == GS_ERROR)
6583 /* PR c++/28266 Make sure this is expanded only once. */
6584 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
6585 return GS_ERROR;
6587 if (init)
6588 gimplify_and_add (init, pre_p);
6590 /* If needed, push the cleanup for the temp. */
6591 if (TARGET_EXPR_CLEANUP (targ))
6593 if (CLEANUP_EH_ONLY (targ))
6594 gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
6595 CLEANUP_EH_ONLY (targ), pre_p);
6596 else
6597 cleanup = TARGET_EXPR_CLEANUP (targ);
6600 /* Add a clobber for the temporary going out of scope, like
6601 gimplify_bind_expr. */
6602 if (gimplify_ctxp->in_cleanup_point_expr
6603 && needs_to_live_in_memory (temp))
6605 if (flag_stack_reuse == SR_ALL)
6607 tree clobber = build_constructor (TREE_TYPE (temp),
6608 NULL);
6609 TREE_THIS_VOLATILE (clobber) = true;
6610 clobber = build2 (MODIFY_EXPR, TREE_TYPE (temp), temp, clobber);
6611 gimple_push_cleanup (temp, clobber, false, pre_p, true);
6613 if (asan_poisoned_variables
6614 && DECL_ALIGN (temp) <= MAX_SUPPORTED_STACK_ALIGNMENT
6615 && dbg_cnt (asan_use_after_scope))
6617 tree asan_cleanup = build_asan_poison_call_expr (temp);
6618 if (asan_cleanup)
6620 if (unpoison_empty_seq)
6621 unpoison_it = gsi_start (*pre_p);
6623 asan_poison_variable (temp, false, &unpoison_it,
6624 unpoison_empty_seq);
6625 gimple_push_cleanup (temp, asan_cleanup, false, pre_p);
6629 if (cleanup)
6630 gimple_push_cleanup (temp, cleanup, false, pre_p);
6632 /* Only expand this once. */
6633 TREE_OPERAND (targ, 3) = init;
6634 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
6636 else
6637 /* We should have expanded this before. */
6638 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
6640 *expr_p = temp;
6641 return GS_OK;
6644 /* Gimplification of expression trees. */
6646 /* Gimplify an expression which appears at statement context. The
6647 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
6648 NULL, a new sequence is allocated.
6650 Return true if we actually added a statement to the queue. */
6652 bool
6653 gimplify_stmt (tree *stmt_p, gimple_seq *seq_p)
6655 gimple_seq_node last;
6657 last = gimple_seq_last (*seq_p);
6658 gimplify_expr (stmt_p, seq_p, NULL, is_gimple_stmt, fb_none);
6659 return last != gimple_seq_last (*seq_p);
6662 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
6663 to CTX. If entries already exist, force them to be some flavor of private.
6664 If there is no enclosing parallel, do nothing. */
6666 void
6667 omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl)
6669 splay_tree_node n;
6671 if (decl == NULL || !DECL_P (decl) || ctx->region_type == ORT_NONE)
6672 return;
6676 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
6677 if (n != NULL)
6679 if (n->value & GOVD_SHARED)
6680 n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
6681 else if (n->value & GOVD_MAP)
6682 n->value |= GOVD_MAP_TO_ONLY;
6683 else
6684 return;
6686 else if ((ctx->region_type & ORT_TARGET) != 0)
6688 if (ctx->target_map_scalars_firstprivate)
6689 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
6690 else
6691 omp_add_variable (ctx, decl, GOVD_MAP | GOVD_MAP_TO_ONLY);
6693 else if (ctx->region_type != ORT_WORKSHARE
6694 && ctx->region_type != ORT_SIMD
6695 && ctx->region_type != ORT_ACC
6696 && !(ctx->region_type & ORT_TARGET_DATA))
6697 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
6699 ctx = ctx->outer_context;
6701 while (ctx);
6704 /* Similarly for each of the type sizes of TYPE. */
6706 static void
6707 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type)
6709 if (type == NULL || type == error_mark_node)
6710 return;
6711 type = TYPE_MAIN_VARIANT (type);
6713 if (ctx->privatized_types->add (type))
6714 return;
6716 switch (TREE_CODE (type))
6718 case INTEGER_TYPE:
6719 case ENUMERAL_TYPE:
6720 case BOOLEAN_TYPE:
6721 case REAL_TYPE:
6722 case FIXED_POINT_TYPE:
6723 omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type));
6724 omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type));
6725 break;
6727 case ARRAY_TYPE:
6728 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
6729 omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type));
6730 break;
6732 case RECORD_TYPE:
6733 case UNION_TYPE:
6734 case QUAL_UNION_TYPE:
6736 tree field;
6737 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
6738 if (TREE_CODE (field) == FIELD_DECL)
6740 omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
6741 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
6744 break;
6746 case POINTER_TYPE:
6747 case REFERENCE_TYPE:
6748 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
6749 break;
6751 default:
6752 break;
6755 omp_firstprivatize_variable (ctx, TYPE_SIZE (type));
6756 omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type));
6757 lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type);
6760 /* Add an entry for DECL in the OMP context CTX with FLAGS. */
6762 static void
6763 omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
6765 splay_tree_node n;
6766 unsigned int nflags;
6767 tree t;
6769 if (error_operand_p (decl) || ctx->region_type == ORT_NONE)
6770 return;
6772 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
6773 there are constructors involved somewhere. Exception is a shared clause,
6774 there is nothing privatized in that case. */
6775 if ((flags & GOVD_SHARED) == 0
6776 && (TREE_ADDRESSABLE (TREE_TYPE (decl))
6777 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
6778 flags |= GOVD_SEEN;
6780 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
6781 if (n != NULL && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
6783 /* We shouldn't be re-adding the decl with the same data
6784 sharing class. */
6785 gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
6786 nflags = n->value | flags;
6787 /* The only combination of data sharing classes we should see is
6788 FIRSTPRIVATE and LASTPRIVATE. However, OpenACC permits
6789 reduction variables to be used in data sharing clauses. */
6790 gcc_assert ((ctx->region_type & ORT_ACC) != 0
6791 || ((nflags & GOVD_DATA_SHARE_CLASS)
6792 == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE))
6793 || (flags & GOVD_DATA_SHARE_CLASS) == 0);
6794 n->value = nflags;
6795 return;
6798 /* When adding a variable-sized variable, we have to handle all sorts
6799 of additional bits of data: the pointer replacement variable, and
6800 the parameters of the type. */
6801 if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
6803 /* Add the pointer replacement variable as PRIVATE if the variable
6804 replacement is private, else FIRSTPRIVATE since we'll need the
6805 address of the original variable either for SHARED, or for the
6806 copy into or out of the context. */
6807 if (!(flags & GOVD_LOCAL))
6809 if (flags & GOVD_MAP)
6810 nflags = GOVD_MAP | GOVD_MAP_TO_ONLY | GOVD_EXPLICIT;
6811 else if (flags & GOVD_PRIVATE)
6812 nflags = GOVD_PRIVATE;
6813 else if ((ctx->region_type & (ORT_TARGET | ORT_TARGET_DATA)) != 0
6814 && (flags & GOVD_FIRSTPRIVATE))
6815 nflags = GOVD_PRIVATE | GOVD_EXPLICIT;
6816 else
6817 nflags = GOVD_FIRSTPRIVATE;
6818 nflags |= flags & GOVD_SEEN;
6819 t = DECL_VALUE_EXPR (decl);
6820 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
6821 t = TREE_OPERAND (t, 0);
6822 gcc_assert (DECL_P (t));
6823 omp_add_variable (ctx, t, nflags);
6826 /* Add all of the variable and type parameters (which should have
6827 been gimplified to a formal temporary) as FIRSTPRIVATE. */
6828 omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
6829 omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
6830 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
6832 /* The variable-sized variable itself is never SHARED, only some form
6833 of PRIVATE. The sharing would take place via the pointer variable
6834 which we remapped above. */
6835 if (flags & GOVD_SHARED)
6836 flags = GOVD_SHARED | GOVD_DEBUG_PRIVATE
6837 | (flags & (GOVD_SEEN | GOVD_EXPLICIT));
6839 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
6840 alloca statement we generate for the variable, so make sure it
6841 is available. This isn't automatically needed for the SHARED
6842 case, since we won't be allocating local storage then.
6843 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
6844 in this case omp_notice_variable will be called later
6845 on when it is gimplified. */
6846 else if (! (flags & (GOVD_LOCAL | GOVD_MAP))
6847 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl))))
6848 omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
6850 else if ((flags & (GOVD_MAP | GOVD_LOCAL)) == 0
6851 && lang_hooks.decls.omp_privatize_by_reference (decl))
6853 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
6855 /* Similar to the direct variable sized case above, we'll need the
6856 size of references being privatized. */
6857 if ((flags & GOVD_SHARED) == 0)
6859 t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
6860 if (DECL_P (t))
6861 omp_notice_variable (ctx, t, true);
6865 if (n != NULL)
6866 n->value |= flags;
6867 else
6868 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
6870 /* For reductions clauses in OpenACC loop directives, by default create a
6871 copy clause on the enclosing parallel construct for carrying back the
6872 results. */
6873 if (ctx->region_type == ORT_ACC && (flags & GOVD_REDUCTION))
6875 struct gimplify_omp_ctx *outer_ctx = ctx->outer_context;
6876 while (outer_ctx)
6878 n = splay_tree_lookup (outer_ctx->variables, (splay_tree_key)decl);
6879 if (n != NULL)
6881 /* Ignore local variables and explicitly declared clauses. */
6882 if (n->value & (GOVD_LOCAL | GOVD_EXPLICIT))
6883 break;
6884 else if (outer_ctx->region_type == ORT_ACC_KERNELS)
6886 /* According to the OpenACC spec, such a reduction variable
6887 should already have a copy map on a kernels construct,
6888 verify that here. */
6889 gcc_assert (!(n->value & GOVD_FIRSTPRIVATE)
6890 && (n->value & GOVD_MAP));
6892 else if (outer_ctx->region_type == ORT_ACC_PARALLEL)
6894 /* Remove firstprivate and make it a copy map. */
6895 n->value &= ~GOVD_FIRSTPRIVATE;
6896 n->value |= GOVD_MAP;
6899 else if (outer_ctx->region_type == ORT_ACC_PARALLEL)
6901 splay_tree_insert (outer_ctx->variables, (splay_tree_key)decl,
6902 GOVD_MAP | GOVD_SEEN);
6903 break;
6905 outer_ctx = outer_ctx->outer_context;
6910 /* Notice a threadprivate variable DECL used in OMP context CTX.
6911 This just prints out diagnostics about threadprivate variable uses
6912 in untied tasks. If DECL2 is non-NULL, prevent this warning
6913 on that variable. */
6915 static bool
6916 omp_notice_threadprivate_variable (struct gimplify_omp_ctx *ctx, tree decl,
6917 tree decl2)
6919 splay_tree_node n;
6920 struct gimplify_omp_ctx *octx;
6922 for (octx = ctx; octx; octx = octx->outer_context)
6923 if ((octx->region_type & ORT_TARGET) != 0)
6925 n = splay_tree_lookup (octx->variables, (splay_tree_key)decl);
6926 if (n == NULL)
6928 error ("threadprivate variable %qE used in target region",
6929 DECL_NAME (decl));
6930 error_at (octx->location, "enclosing target region");
6931 splay_tree_insert (octx->variables, (splay_tree_key)decl, 0);
6933 if (decl2)
6934 splay_tree_insert (octx->variables, (splay_tree_key)decl2, 0);
6937 if (ctx->region_type != ORT_UNTIED_TASK)
6938 return false;
6939 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
6940 if (n == NULL)
6942 error ("threadprivate variable %qE used in untied task",
6943 DECL_NAME (decl));
6944 error_at (ctx->location, "enclosing task");
6945 splay_tree_insert (ctx->variables, (splay_tree_key)decl, 0);
6947 if (decl2)
6948 splay_tree_insert (ctx->variables, (splay_tree_key)decl2, 0);
6949 return false;
6952 /* Return true if global var DECL is device resident. */
6954 static bool
6955 device_resident_p (tree decl)
6957 tree attr = lookup_attribute ("oacc declare target", DECL_ATTRIBUTES (decl));
6959 if (!attr)
6960 return false;
6962 for (tree t = TREE_VALUE (attr); t; t = TREE_PURPOSE (t))
6964 tree c = TREE_VALUE (t);
6965 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_DEVICE_RESIDENT)
6966 return true;
6969 return false;
6972 /* Return true if DECL has an ACC DECLARE attribute. */
6974 static bool
6975 is_oacc_declared (tree decl)
6977 tree t = TREE_CODE (decl) == MEM_REF ? TREE_OPERAND (decl, 0) : decl;
6978 tree declared = lookup_attribute ("oacc declare target", DECL_ATTRIBUTES (t));
6979 return declared != NULL_TREE;
6982 /* Determine outer default flags for DECL mentioned in an OMP region
6983 but not declared in an enclosing clause.
6985 ??? Some compiler-generated variables (like SAVE_EXPRs) could be
6986 remapped firstprivate instead of shared. To some extent this is
6987 addressed in omp_firstprivatize_type_sizes, but not
6988 effectively. */
6990 static unsigned
6991 omp_default_clause (struct gimplify_omp_ctx *ctx, tree decl,
6992 bool in_code, unsigned flags)
6994 enum omp_clause_default_kind default_kind = ctx->default_kind;
6995 enum omp_clause_default_kind kind;
6997 kind = lang_hooks.decls.omp_predetermined_sharing (decl);
6998 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
6999 default_kind = kind;
7001 switch (default_kind)
7003 case OMP_CLAUSE_DEFAULT_NONE:
7005 const char *rtype;
7007 if (ctx->region_type & ORT_PARALLEL)
7008 rtype = "parallel";
7009 else if (ctx->region_type & ORT_TASK)
7010 rtype = "task";
7011 else if (ctx->region_type & ORT_TEAMS)
7012 rtype = "teams";
7013 else
7014 gcc_unreachable ();
7016 error ("%qE not specified in enclosing %qs",
7017 DECL_NAME (lang_hooks.decls.omp_report_decl (decl)), rtype);
7018 error_at (ctx->location, "enclosing %qs", rtype);
7020 /* FALLTHRU */
7021 case OMP_CLAUSE_DEFAULT_SHARED:
7022 flags |= GOVD_SHARED;
7023 break;
7024 case OMP_CLAUSE_DEFAULT_PRIVATE:
7025 flags |= GOVD_PRIVATE;
7026 break;
7027 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
7028 flags |= GOVD_FIRSTPRIVATE;
7029 break;
7030 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
7031 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
7032 gcc_assert ((ctx->region_type & ORT_TASK) != 0);
7033 if (struct gimplify_omp_ctx *octx = ctx->outer_context)
7035 omp_notice_variable (octx, decl, in_code);
7036 for (; octx; octx = octx->outer_context)
7038 splay_tree_node n2;
7040 n2 = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
7041 if ((octx->region_type & (ORT_TARGET_DATA | ORT_TARGET)) != 0
7042 && (n2 == NULL || (n2->value & GOVD_DATA_SHARE_CLASS) == 0))
7043 continue;
7044 if (n2 && (n2->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED)
7046 flags |= GOVD_FIRSTPRIVATE;
7047 goto found_outer;
7049 if ((octx->region_type & (ORT_PARALLEL | ORT_TEAMS)) != 0)
7051 flags |= GOVD_SHARED;
7052 goto found_outer;
7057 if (TREE_CODE (decl) == PARM_DECL
7058 || (!is_global_var (decl)
7059 && DECL_CONTEXT (decl) == current_function_decl))
7060 flags |= GOVD_FIRSTPRIVATE;
7061 else
7062 flags |= GOVD_SHARED;
7063 found_outer:
7064 break;
7066 default:
7067 gcc_unreachable ();
7070 return flags;
7074 /* Determine outer default flags for DECL mentioned in an OACC region
7075 but not declared in an enclosing clause. */
7077 static unsigned
7078 oacc_default_clause (struct gimplify_omp_ctx *ctx, tree decl, unsigned flags)
7080 const char *rkind;
7081 bool on_device = false;
7082 bool declared = is_oacc_declared (decl);
7083 tree type = TREE_TYPE (decl);
7085 if (lang_hooks.decls.omp_privatize_by_reference (decl))
7086 type = TREE_TYPE (type);
7088 if ((ctx->region_type & (ORT_ACC_PARALLEL | ORT_ACC_KERNELS)) != 0
7089 && is_global_var (decl)
7090 && device_resident_p (decl))
7092 on_device = true;
7093 flags |= GOVD_MAP_TO_ONLY;
7096 switch (ctx->region_type)
7098 case ORT_ACC_KERNELS:
7099 rkind = "kernels";
7101 if (AGGREGATE_TYPE_P (type))
7103 /* Aggregates default to 'present_or_copy', or 'present'. */
7104 if (ctx->default_kind != OMP_CLAUSE_DEFAULT_PRESENT)
7105 flags |= GOVD_MAP;
7106 else
7107 flags |= GOVD_MAP | GOVD_MAP_FORCE_PRESENT;
7109 else
7110 /* Scalars default to 'copy'. */
7111 flags |= GOVD_MAP | GOVD_MAP_FORCE;
7113 break;
7115 case ORT_ACC_PARALLEL:
7116 rkind = "parallel";
7118 if (on_device || declared)
7119 flags |= GOVD_MAP;
7120 else if (AGGREGATE_TYPE_P (type))
7122 /* Aggregates default to 'present_or_copy', or 'present'. */
7123 if (ctx->default_kind != OMP_CLAUSE_DEFAULT_PRESENT)
7124 flags |= GOVD_MAP;
7125 else
7126 flags |= GOVD_MAP | GOVD_MAP_FORCE_PRESENT;
7128 else
7129 /* Scalars default to 'firstprivate'. */
7130 flags |= GOVD_FIRSTPRIVATE;
7132 break;
7134 default:
7135 gcc_unreachable ();
7138 if (DECL_ARTIFICIAL (decl))
7139 ; /* We can get compiler-generated decls, and should not complain
7140 about them. */
7141 else if (ctx->default_kind == OMP_CLAUSE_DEFAULT_NONE)
7143 error ("%qE not specified in enclosing OpenACC %qs construct",
7144 DECL_NAME (lang_hooks.decls.omp_report_decl (decl)), rkind);
7145 inform (ctx->location, "enclosing OpenACC %qs construct", rkind);
7147 else if (ctx->default_kind == OMP_CLAUSE_DEFAULT_PRESENT)
7148 ; /* Handled above. */
7149 else
7150 gcc_checking_assert (ctx->default_kind == OMP_CLAUSE_DEFAULT_SHARED);
7152 return flags;
7155 /* Record the fact that DECL was used within the OMP context CTX.
7156 IN_CODE is true when real code uses DECL, and false when we should
7157 merely emit default(none) errors. Return true if DECL is going to
7158 be remapped and thus DECL shouldn't be gimplified into its
7159 DECL_VALUE_EXPR (if any). */
7161 static bool
7162 omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
7164 splay_tree_node n;
7165 unsigned flags = in_code ? GOVD_SEEN : 0;
7166 bool ret = false, shared;
7168 if (error_operand_p (decl))
7169 return false;
7171 if (ctx->region_type == ORT_NONE)
7172 return lang_hooks.decls.omp_disregard_value_expr (decl, false);
7174 if (is_global_var (decl))
7176 /* Threadprivate variables are predetermined. */
7177 if (DECL_THREAD_LOCAL_P (decl))
7178 return omp_notice_threadprivate_variable (ctx, decl, NULL_TREE);
7180 if (DECL_HAS_VALUE_EXPR_P (decl))
7182 tree value = get_base_address (DECL_VALUE_EXPR (decl));
7184 if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
7185 return omp_notice_threadprivate_variable (ctx, decl, value);
7188 if (gimplify_omp_ctxp->outer_context == NULL
7189 && VAR_P (decl)
7190 && oacc_get_fn_attrib (current_function_decl))
7192 location_t loc = DECL_SOURCE_LOCATION (decl);
7194 if (lookup_attribute ("omp declare target link",
7195 DECL_ATTRIBUTES (decl)))
7197 error_at (loc,
7198 "%qE with %<link%> clause used in %<routine%> function",
7199 DECL_NAME (decl));
7200 return false;
7202 else if (!lookup_attribute ("omp declare target",
7203 DECL_ATTRIBUTES (decl)))
7205 error_at (loc,
7206 "%qE requires a %<declare%> directive for use "
7207 "in a %<routine%> function", DECL_NAME (decl));
7208 return false;
7213 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
7214 if ((ctx->region_type & ORT_TARGET) != 0)
7216 ret = lang_hooks.decls.omp_disregard_value_expr (decl, true);
7217 if (n == NULL)
7219 unsigned nflags = flags;
7220 if (ctx->target_map_pointers_as_0len_arrays
7221 || ctx->target_map_scalars_firstprivate)
7223 bool is_declare_target = false;
7224 bool is_scalar = false;
7225 if (is_global_var (decl)
7226 && varpool_node::get_create (decl)->offloadable)
7228 struct gimplify_omp_ctx *octx;
7229 for (octx = ctx->outer_context;
7230 octx; octx = octx->outer_context)
7232 n = splay_tree_lookup (octx->variables,
7233 (splay_tree_key)decl);
7234 if (n
7235 && (n->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED
7236 && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
7237 break;
7239 is_declare_target = octx == NULL;
7241 if (!is_declare_target && ctx->target_map_scalars_firstprivate)
7242 is_scalar = lang_hooks.decls.omp_scalar_p (decl);
7243 if (is_declare_target)
7245 else if (ctx->target_map_pointers_as_0len_arrays
7246 && (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
7247 || (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE
7248 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl)))
7249 == POINTER_TYPE)))
7250 nflags |= GOVD_MAP | GOVD_MAP_0LEN_ARRAY;
7251 else if (is_scalar)
7252 nflags |= GOVD_FIRSTPRIVATE;
7255 struct gimplify_omp_ctx *octx = ctx->outer_context;
7256 if ((ctx->region_type & ORT_ACC) && octx)
7258 /* Look in outer OpenACC contexts, to see if there's a
7259 data attribute for this variable. */
7260 omp_notice_variable (octx, decl, in_code);
7262 for (; octx; octx = octx->outer_context)
7264 if (!(octx->region_type & (ORT_TARGET_DATA | ORT_TARGET)))
7265 break;
7266 splay_tree_node n2
7267 = splay_tree_lookup (octx->variables,
7268 (splay_tree_key) decl);
7269 if (n2)
7271 if (octx->region_type == ORT_ACC_HOST_DATA)
7272 error ("variable %qE declared in enclosing "
7273 "%<host_data%> region", DECL_NAME (decl));
7274 nflags |= GOVD_MAP;
7275 if (octx->region_type == ORT_ACC_DATA
7276 && (n2->value & GOVD_MAP_0LEN_ARRAY))
7277 nflags |= GOVD_MAP_0LEN_ARRAY;
7278 goto found_outer;
7284 tree type = TREE_TYPE (decl);
7286 if (nflags == flags
7287 && gimplify_omp_ctxp->target_firstprivatize_array_bases
7288 && lang_hooks.decls.omp_privatize_by_reference (decl))
7289 type = TREE_TYPE (type);
7290 if (nflags == flags
7291 && !lang_hooks.types.omp_mappable_type (type))
7293 error ("%qD referenced in target region does not have "
7294 "a mappable type", decl);
7295 nflags |= GOVD_MAP | GOVD_EXPLICIT;
7297 else if (nflags == flags)
7299 if ((ctx->region_type & ORT_ACC) != 0)
7300 nflags = oacc_default_clause (ctx, decl, flags);
7301 else
7302 nflags |= GOVD_MAP;
7305 found_outer:
7306 omp_add_variable (ctx, decl, nflags);
7308 else
7310 /* If nothing changed, there's nothing left to do. */
7311 if ((n->value & flags) == flags)
7312 return ret;
7313 flags |= n->value;
7314 n->value = flags;
7316 goto do_outer;
7319 if (n == NULL)
7321 if (ctx->region_type == ORT_WORKSHARE
7322 || ctx->region_type == ORT_SIMD
7323 || ctx->region_type == ORT_ACC
7324 || (ctx->region_type & ORT_TARGET_DATA) != 0)
7325 goto do_outer;
7327 flags = omp_default_clause (ctx, decl, in_code, flags);
7329 if ((flags & GOVD_PRIVATE)
7330 && lang_hooks.decls.omp_private_outer_ref (decl))
7331 flags |= GOVD_PRIVATE_OUTER_REF;
7333 omp_add_variable (ctx, decl, flags);
7335 shared = (flags & GOVD_SHARED) != 0;
7336 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
7337 goto do_outer;
7340 if ((n->value & (GOVD_SEEN | GOVD_LOCAL)) == 0
7341 && (flags & (GOVD_SEEN | GOVD_LOCAL)) == GOVD_SEEN
7342 && DECL_SIZE (decl))
7344 if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
7346 splay_tree_node n2;
7347 tree t = DECL_VALUE_EXPR (decl);
7348 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
7349 t = TREE_OPERAND (t, 0);
7350 gcc_assert (DECL_P (t));
7351 n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
7352 n2->value |= GOVD_SEEN;
7354 else if (lang_hooks.decls.omp_privatize_by_reference (decl)
7355 && TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)))
7356 && (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl))))
7357 != INTEGER_CST))
7359 splay_tree_node n2;
7360 tree t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
7361 gcc_assert (DECL_P (t));
7362 n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
7363 if (n2)
7364 omp_notice_variable (ctx, t, true);
7368 shared = ((flags | n->value) & GOVD_SHARED) != 0;
7369 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
7371 /* If nothing changed, there's nothing left to do. */
7372 if ((n->value & flags) == flags)
7373 return ret;
7374 flags |= n->value;
7375 n->value = flags;
7377 do_outer:
7378 /* If the variable is private in the current context, then we don't
7379 need to propagate anything to an outer context. */
7380 if ((flags & GOVD_PRIVATE) && !(flags & GOVD_PRIVATE_OUTER_REF))
7381 return ret;
7382 if ((flags & (GOVD_LINEAR | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
7383 == (GOVD_LINEAR | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
7384 return ret;
7385 if ((flags & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
7386 | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
7387 == (GOVD_LASTPRIVATE | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
7388 return ret;
7389 if (ctx->outer_context
7390 && omp_notice_variable (ctx->outer_context, decl, in_code))
7391 return true;
7392 return ret;
7395 /* Verify that DECL is private within CTX. If there's specific information
7396 to the contrary in the innermost scope, generate an error. */
7398 static bool
7399 omp_is_private (struct gimplify_omp_ctx *ctx, tree decl, int simd)
7401 splay_tree_node n;
7403 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
7404 if (n != NULL)
7406 if (n->value & GOVD_SHARED)
7408 if (ctx == gimplify_omp_ctxp)
7410 if (simd)
7411 error ("iteration variable %qE is predetermined linear",
7412 DECL_NAME (decl));
7413 else
7414 error ("iteration variable %qE should be private",
7415 DECL_NAME (decl));
7416 n->value = GOVD_PRIVATE;
7417 return true;
7419 else
7420 return false;
7422 else if ((n->value & GOVD_EXPLICIT) != 0
7423 && (ctx == gimplify_omp_ctxp
7424 || (ctx->region_type == ORT_COMBINED_PARALLEL
7425 && gimplify_omp_ctxp->outer_context == ctx)))
7427 if ((n->value & GOVD_FIRSTPRIVATE) != 0)
7428 error ("iteration variable %qE should not be firstprivate",
7429 DECL_NAME (decl));
7430 else if ((n->value & GOVD_REDUCTION) != 0)
7431 error ("iteration variable %qE should not be reduction",
7432 DECL_NAME (decl));
7433 else if (simd == 0 && (n->value & GOVD_LINEAR) != 0)
7434 error ("iteration variable %qE should not be linear",
7435 DECL_NAME (decl));
7436 else if (simd == 1 && (n->value & GOVD_LASTPRIVATE) != 0)
7437 error ("iteration variable %qE should not be lastprivate",
7438 DECL_NAME (decl));
7439 else if (simd && (n->value & GOVD_PRIVATE) != 0)
7440 error ("iteration variable %qE should not be private",
7441 DECL_NAME (decl));
7442 else if (simd == 2 && (n->value & GOVD_LINEAR) != 0)
7443 error ("iteration variable %qE is predetermined linear",
7444 DECL_NAME (decl));
7446 return (ctx == gimplify_omp_ctxp
7447 || (ctx->region_type == ORT_COMBINED_PARALLEL
7448 && gimplify_omp_ctxp->outer_context == ctx));
7451 if (ctx->region_type != ORT_WORKSHARE
7452 && ctx->region_type != ORT_SIMD
7453 && ctx->region_type != ORT_ACC)
7454 return false;
7455 else if (ctx->outer_context)
7456 return omp_is_private (ctx->outer_context, decl, simd);
7457 return false;
7460 /* Return true if DECL is private within a parallel region
7461 that binds to the current construct's context or in parallel
7462 region's REDUCTION clause. */
7464 static bool
7465 omp_check_private (struct gimplify_omp_ctx *ctx, tree decl, bool copyprivate)
7467 splay_tree_node n;
7471 ctx = ctx->outer_context;
7472 if (ctx == NULL)
7474 if (is_global_var (decl))
7475 return false;
7477 /* References might be private, but might be shared too,
7478 when checking for copyprivate, assume they might be
7479 private, otherwise assume they might be shared. */
7480 if (copyprivate)
7481 return true;
7483 if (lang_hooks.decls.omp_privatize_by_reference (decl))
7484 return false;
7486 /* Treat C++ privatized non-static data members outside
7487 of the privatization the same. */
7488 if (omp_member_access_dummy_var (decl))
7489 return false;
7491 return true;
7494 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
7496 if ((ctx->region_type & (ORT_TARGET | ORT_TARGET_DATA)) != 0
7497 && (n == NULL || (n->value & GOVD_DATA_SHARE_CLASS) == 0))
7498 continue;
7500 if (n != NULL)
7502 if ((n->value & GOVD_LOCAL) != 0
7503 && omp_member_access_dummy_var (decl))
7504 return false;
7505 return (n->value & GOVD_SHARED) == 0;
7508 while (ctx->region_type == ORT_WORKSHARE
7509 || ctx->region_type == ORT_SIMD
7510 || ctx->region_type == ORT_ACC);
7511 return false;
7514 /* Callback for walk_tree to find a DECL_EXPR for the given DECL. */
7516 static tree
7517 find_decl_expr (tree *tp, int *walk_subtrees, void *data)
7519 tree t = *tp;
7521 /* If this node has been visited, unmark it and keep looking. */
7522 if (TREE_CODE (t) == DECL_EXPR && DECL_EXPR_DECL (t) == (tree) data)
7523 return t;
7525 if (IS_TYPE_OR_DECL_P (t))
7526 *walk_subtrees = 0;
7527 return NULL_TREE;
7530 /* Scan the OMP clauses in *LIST_P, installing mappings into a new
7531 and previous omp contexts. */
7533 static void
7534 gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
7535 enum omp_region_type region_type,
7536 enum tree_code code)
7538 struct gimplify_omp_ctx *ctx, *outer_ctx;
7539 tree c;
7540 hash_map<tree, tree> *struct_map_to_clause = NULL;
7541 tree *prev_list_p = NULL;
7543 ctx = new_omp_context (region_type);
7544 outer_ctx = ctx->outer_context;
7545 if (code == OMP_TARGET)
7547 if (!lang_GNU_Fortran ())
7548 ctx->target_map_pointers_as_0len_arrays = true;
7549 ctx->target_map_scalars_firstprivate = true;
7551 if (!lang_GNU_Fortran ())
7552 switch (code)
7554 case OMP_TARGET:
7555 case OMP_TARGET_DATA:
7556 case OMP_TARGET_ENTER_DATA:
7557 case OMP_TARGET_EXIT_DATA:
7558 case OACC_DECLARE:
7559 case OACC_HOST_DATA:
7560 ctx->target_firstprivatize_array_bases = true;
7561 default:
7562 break;
7565 while ((c = *list_p) != NULL)
7567 bool remove = false;
7568 bool notice_outer = true;
7569 const char *check_non_private = NULL;
7570 unsigned int flags;
7571 tree decl;
7573 switch (OMP_CLAUSE_CODE (c))
7575 case OMP_CLAUSE_PRIVATE:
7576 flags = GOVD_PRIVATE | GOVD_EXPLICIT;
7577 if (lang_hooks.decls.omp_private_outer_ref (OMP_CLAUSE_DECL (c)))
7579 flags |= GOVD_PRIVATE_OUTER_REF;
7580 OMP_CLAUSE_PRIVATE_OUTER_REF (c) = 1;
7582 else
7583 notice_outer = false;
7584 goto do_add;
7585 case OMP_CLAUSE_SHARED:
7586 flags = GOVD_SHARED | GOVD_EXPLICIT;
7587 goto do_add;
7588 case OMP_CLAUSE_FIRSTPRIVATE:
7589 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
7590 check_non_private = "firstprivate";
7591 goto do_add;
7592 case OMP_CLAUSE_LASTPRIVATE:
7593 flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
7594 check_non_private = "lastprivate";
7595 decl = OMP_CLAUSE_DECL (c);
7596 if (error_operand_p (decl))
7597 goto do_add;
7598 else if (outer_ctx
7599 && (outer_ctx->region_type == ORT_COMBINED_PARALLEL
7600 || outer_ctx->region_type == ORT_COMBINED_TEAMS)
7601 && splay_tree_lookup (outer_ctx->variables,
7602 (splay_tree_key) decl) == NULL)
7604 omp_add_variable (outer_ctx, decl, GOVD_SHARED | GOVD_SEEN);
7605 if (outer_ctx->outer_context)
7606 omp_notice_variable (outer_ctx->outer_context, decl, true);
7608 else if (outer_ctx
7609 && (outer_ctx->region_type & ORT_TASK) != 0
7610 && outer_ctx->combined_loop
7611 && splay_tree_lookup (outer_ctx->variables,
7612 (splay_tree_key) decl) == NULL)
7614 omp_add_variable (outer_ctx, decl, GOVD_LASTPRIVATE | GOVD_SEEN);
7615 if (outer_ctx->outer_context)
7616 omp_notice_variable (outer_ctx->outer_context, decl, true);
7618 else if (outer_ctx
7619 && (outer_ctx->region_type == ORT_WORKSHARE
7620 || outer_ctx->region_type == ORT_ACC)
7621 && outer_ctx->combined_loop
7622 && splay_tree_lookup (outer_ctx->variables,
7623 (splay_tree_key) decl) == NULL
7624 && !omp_check_private (outer_ctx, decl, false))
7626 omp_add_variable (outer_ctx, decl, GOVD_LASTPRIVATE | GOVD_SEEN);
7627 if (outer_ctx->outer_context
7628 && (outer_ctx->outer_context->region_type
7629 == ORT_COMBINED_PARALLEL)
7630 && splay_tree_lookup (outer_ctx->outer_context->variables,
7631 (splay_tree_key) decl) == NULL)
7633 struct gimplify_omp_ctx *octx = outer_ctx->outer_context;
7634 omp_add_variable (octx, decl, GOVD_SHARED | GOVD_SEEN);
7635 if (octx->outer_context)
7637 octx = octx->outer_context;
7638 if (octx->region_type == ORT_WORKSHARE
7639 && octx->combined_loop
7640 && splay_tree_lookup (octx->variables,
7641 (splay_tree_key) decl) == NULL
7642 && !omp_check_private (octx, decl, false))
7644 omp_add_variable (octx, decl,
7645 GOVD_LASTPRIVATE | GOVD_SEEN);
7646 octx = octx->outer_context;
7647 if (octx
7648 && octx->region_type == ORT_COMBINED_TEAMS
7649 && (splay_tree_lookup (octx->variables,
7650 (splay_tree_key) decl)
7651 == NULL))
7653 omp_add_variable (octx, decl,
7654 GOVD_SHARED | GOVD_SEEN);
7655 octx = octx->outer_context;
7658 if (octx)
7659 omp_notice_variable (octx, decl, true);
7662 else if (outer_ctx->outer_context)
7663 omp_notice_variable (outer_ctx->outer_context, decl, true);
7665 goto do_add;
7666 case OMP_CLAUSE_REDUCTION:
7667 flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
7668 /* OpenACC permits reductions on private variables. */
7669 if (!(region_type & ORT_ACC))
7670 check_non_private = "reduction";
7671 decl = OMP_CLAUSE_DECL (c);
7672 if (TREE_CODE (decl) == MEM_REF)
7674 tree type = TREE_TYPE (decl);
7675 if (gimplify_expr (&TYPE_MAX_VALUE (TYPE_DOMAIN (type)), pre_p,
7676 NULL, is_gimple_val, fb_rvalue, false)
7677 == GS_ERROR)
7679 remove = true;
7680 break;
7682 tree v = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
7683 if (DECL_P (v))
7685 omp_firstprivatize_variable (ctx, v);
7686 omp_notice_variable (ctx, v, true);
7688 decl = TREE_OPERAND (decl, 0);
7689 if (TREE_CODE (decl) == POINTER_PLUS_EXPR)
7691 if (gimplify_expr (&TREE_OPERAND (decl, 1), pre_p,
7692 NULL, is_gimple_val, fb_rvalue, false)
7693 == GS_ERROR)
7695 remove = true;
7696 break;
7698 v = TREE_OPERAND (decl, 1);
7699 if (DECL_P (v))
7701 omp_firstprivatize_variable (ctx, v);
7702 omp_notice_variable (ctx, v, true);
7704 decl = TREE_OPERAND (decl, 0);
7706 if (TREE_CODE (decl) == ADDR_EXPR
7707 || TREE_CODE (decl) == INDIRECT_REF)
7708 decl = TREE_OPERAND (decl, 0);
7710 goto do_add_decl;
7711 case OMP_CLAUSE_LINEAR:
7712 if (gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c), pre_p, NULL,
7713 is_gimple_val, fb_rvalue) == GS_ERROR)
7715 remove = true;
7716 break;
7718 else
7720 if (code == OMP_SIMD
7721 && !OMP_CLAUSE_LINEAR_NO_COPYIN (c))
7723 struct gimplify_omp_ctx *octx = outer_ctx;
7724 if (octx
7725 && octx->region_type == ORT_WORKSHARE
7726 && octx->combined_loop
7727 && !octx->distribute)
7729 if (octx->outer_context
7730 && (octx->outer_context->region_type
7731 == ORT_COMBINED_PARALLEL))
7732 octx = octx->outer_context->outer_context;
7733 else
7734 octx = octx->outer_context;
7736 if (octx
7737 && octx->region_type == ORT_WORKSHARE
7738 && octx->combined_loop
7739 && octx->distribute)
7741 error_at (OMP_CLAUSE_LOCATION (c),
7742 "%<linear%> clause for variable other than "
7743 "loop iterator specified on construct "
7744 "combined with %<distribute%>");
7745 remove = true;
7746 break;
7749 /* For combined #pragma omp parallel for simd, need to put
7750 lastprivate and perhaps firstprivate too on the
7751 parallel. Similarly for #pragma omp for simd. */
7752 struct gimplify_omp_ctx *octx = outer_ctx;
7753 decl = NULL_TREE;
7756 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c)
7757 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
7758 break;
7759 decl = OMP_CLAUSE_DECL (c);
7760 if (error_operand_p (decl))
7762 decl = NULL_TREE;
7763 break;
7765 flags = GOVD_SEEN;
7766 if (!OMP_CLAUSE_LINEAR_NO_COPYIN (c))
7767 flags |= GOVD_FIRSTPRIVATE;
7768 if (!OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
7769 flags |= GOVD_LASTPRIVATE;
7770 if (octx
7771 && octx->region_type == ORT_WORKSHARE
7772 && octx->combined_loop)
7774 if (octx->outer_context
7775 && (octx->outer_context->region_type
7776 == ORT_COMBINED_PARALLEL))
7777 octx = octx->outer_context;
7778 else if (omp_check_private (octx, decl, false))
7779 break;
7781 else if (octx
7782 && (octx->region_type & ORT_TASK) != 0
7783 && octx->combined_loop)
7785 else if (octx
7786 && octx->region_type == ORT_COMBINED_PARALLEL
7787 && ctx->region_type == ORT_WORKSHARE
7788 && octx == outer_ctx)
7789 flags = GOVD_SEEN | GOVD_SHARED;
7790 else if (octx
7791 && octx->region_type == ORT_COMBINED_TEAMS)
7792 flags = GOVD_SEEN | GOVD_SHARED;
7793 else if (octx
7794 && octx->region_type == ORT_COMBINED_TARGET)
7796 flags &= ~GOVD_LASTPRIVATE;
7797 if (flags == GOVD_SEEN)
7798 break;
7800 else
7801 break;
7802 splay_tree_node on
7803 = splay_tree_lookup (octx->variables,
7804 (splay_tree_key) decl);
7805 if (on && (on->value & GOVD_DATA_SHARE_CLASS) != 0)
7807 octx = NULL;
7808 break;
7810 omp_add_variable (octx, decl, flags);
7811 if (octx->outer_context == NULL)
7812 break;
7813 octx = octx->outer_context;
7815 while (1);
7816 if (octx
7817 && decl
7818 && (!OMP_CLAUSE_LINEAR_NO_COPYIN (c)
7819 || !OMP_CLAUSE_LINEAR_NO_COPYOUT (c)))
7820 omp_notice_variable (octx, decl, true);
7822 flags = GOVD_LINEAR | GOVD_EXPLICIT;
7823 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c)
7824 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
7826 notice_outer = false;
7827 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
7829 goto do_add;
7831 case OMP_CLAUSE_MAP:
7832 decl = OMP_CLAUSE_DECL (c);
7833 if (error_operand_p (decl))
7834 remove = true;
7835 switch (code)
7837 case OMP_TARGET:
7838 break;
7839 case OACC_DATA:
7840 if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
7841 break;
7842 /* FALLTHRU */
7843 case OMP_TARGET_DATA:
7844 case OMP_TARGET_ENTER_DATA:
7845 case OMP_TARGET_EXIT_DATA:
7846 case OACC_ENTER_DATA:
7847 case OACC_EXIT_DATA:
7848 case OACC_HOST_DATA:
7849 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER
7850 || (OMP_CLAUSE_MAP_KIND (c)
7851 == GOMP_MAP_FIRSTPRIVATE_REFERENCE))
7852 /* For target {,enter ,exit }data only the array slice is
7853 mapped, but not the pointer to it. */
7854 remove = true;
7855 break;
7856 default:
7857 break;
7859 if (remove)
7860 break;
7861 if (DECL_P (decl) && outer_ctx && (region_type & ORT_ACC))
7863 struct gimplify_omp_ctx *octx;
7864 for (octx = outer_ctx; octx; octx = octx->outer_context)
7866 if (octx->region_type != ORT_ACC_HOST_DATA)
7867 break;
7868 splay_tree_node n2
7869 = splay_tree_lookup (octx->variables,
7870 (splay_tree_key) decl);
7871 if (n2)
7872 error_at (OMP_CLAUSE_LOCATION (c), "variable %qE "
7873 "declared in enclosing %<host_data%> region",
7874 DECL_NAME (decl));
7877 if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
7878 OMP_CLAUSE_SIZE (c) = DECL_P (decl) ? DECL_SIZE_UNIT (decl)
7879 : TYPE_SIZE_UNIT (TREE_TYPE (decl));
7880 if (gimplify_expr (&OMP_CLAUSE_SIZE (c), pre_p,
7881 NULL, is_gimple_val, fb_rvalue) == GS_ERROR)
7883 remove = true;
7884 break;
7886 else if ((OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER
7887 || (OMP_CLAUSE_MAP_KIND (c)
7888 == GOMP_MAP_FIRSTPRIVATE_REFERENCE))
7889 && TREE_CODE (OMP_CLAUSE_SIZE (c)) != INTEGER_CST)
7891 OMP_CLAUSE_SIZE (c)
7892 = get_initialized_tmp_var (OMP_CLAUSE_SIZE (c), pre_p, NULL,
7893 false);
7894 omp_add_variable (ctx, OMP_CLAUSE_SIZE (c),
7895 GOVD_FIRSTPRIVATE | GOVD_SEEN);
7897 if (!DECL_P (decl))
7899 tree d = decl, *pd;
7900 if (TREE_CODE (d) == ARRAY_REF)
7902 while (TREE_CODE (d) == ARRAY_REF)
7903 d = TREE_OPERAND (d, 0);
7904 if (TREE_CODE (d) == COMPONENT_REF
7905 && TREE_CODE (TREE_TYPE (d)) == ARRAY_TYPE)
7906 decl = d;
7908 pd = &OMP_CLAUSE_DECL (c);
7909 if (d == decl
7910 && TREE_CODE (decl) == INDIRECT_REF
7911 && TREE_CODE (TREE_OPERAND (decl, 0)) == COMPONENT_REF
7912 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl, 0)))
7913 == REFERENCE_TYPE))
7915 pd = &TREE_OPERAND (decl, 0);
7916 decl = TREE_OPERAND (decl, 0);
7918 if (TREE_CODE (decl) == COMPONENT_REF)
7920 while (TREE_CODE (decl) == COMPONENT_REF)
7921 decl = TREE_OPERAND (decl, 0);
7922 if (TREE_CODE (decl) == INDIRECT_REF
7923 && DECL_P (TREE_OPERAND (decl, 0))
7924 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl, 0)))
7925 == REFERENCE_TYPE))
7926 decl = TREE_OPERAND (decl, 0);
7928 if (gimplify_expr (pd, pre_p, NULL, is_gimple_lvalue, fb_lvalue)
7929 == GS_ERROR)
7931 remove = true;
7932 break;
7934 if (DECL_P (decl))
7936 if (error_operand_p (decl))
7938 remove = true;
7939 break;
7942 tree stype = TREE_TYPE (decl);
7943 if (TREE_CODE (stype) == REFERENCE_TYPE)
7944 stype = TREE_TYPE (stype);
7945 if (TYPE_SIZE_UNIT (stype) == NULL
7946 || TREE_CODE (TYPE_SIZE_UNIT (stype)) != INTEGER_CST)
7948 error_at (OMP_CLAUSE_LOCATION (c),
7949 "mapping field %qE of variable length "
7950 "structure", OMP_CLAUSE_DECL (c));
7951 remove = true;
7952 break;
7955 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_POINTER)
7957 /* Error recovery. */
7958 if (prev_list_p == NULL)
7960 remove = true;
7961 break;
7963 if (OMP_CLAUSE_CHAIN (*prev_list_p) != c)
7965 tree ch = OMP_CLAUSE_CHAIN (*prev_list_p);
7966 if (ch == NULL_TREE || OMP_CLAUSE_CHAIN (ch) != c)
7968 remove = true;
7969 break;
7974 tree offset;
7975 poly_int64 bitsize, bitpos;
7976 machine_mode mode;
7977 int unsignedp, reversep, volatilep = 0;
7978 tree base = OMP_CLAUSE_DECL (c);
7979 while (TREE_CODE (base) == ARRAY_REF)
7980 base = TREE_OPERAND (base, 0);
7981 if (TREE_CODE (base) == INDIRECT_REF)
7982 base = TREE_OPERAND (base, 0);
7983 base = get_inner_reference (base, &bitsize, &bitpos, &offset,
7984 &mode, &unsignedp, &reversep,
7985 &volatilep);
7986 tree orig_base = base;
7987 if ((TREE_CODE (base) == INDIRECT_REF
7988 || (TREE_CODE (base) == MEM_REF
7989 && integer_zerop (TREE_OPERAND (base, 1))))
7990 && DECL_P (TREE_OPERAND (base, 0))
7991 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0)))
7992 == REFERENCE_TYPE))
7993 base = TREE_OPERAND (base, 0);
7994 gcc_assert (base == decl
7995 && (offset == NULL_TREE
7996 || poly_int_tree_p (offset)));
7998 splay_tree_node n
7999 = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
8000 bool ptr = (OMP_CLAUSE_MAP_KIND (c)
8001 == GOMP_MAP_ALWAYS_POINTER);
8002 if (n == NULL || (n->value & GOVD_MAP) == 0)
8004 tree l = build_omp_clause (OMP_CLAUSE_LOCATION (c),
8005 OMP_CLAUSE_MAP);
8006 OMP_CLAUSE_SET_MAP_KIND (l, GOMP_MAP_STRUCT);
8007 if (orig_base != base)
8008 OMP_CLAUSE_DECL (l) = unshare_expr (orig_base);
8009 else
8010 OMP_CLAUSE_DECL (l) = decl;
8011 OMP_CLAUSE_SIZE (l) = size_int (1);
8012 if (struct_map_to_clause == NULL)
8013 struct_map_to_clause = new hash_map<tree, tree>;
8014 struct_map_to_clause->put (decl, l);
8015 if (ptr)
8017 enum gomp_map_kind mkind
8018 = code == OMP_TARGET_EXIT_DATA
8019 ? GOMP_MAP_RELEASE : GOMP_MAP_ALLOC;
8020 tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
8021 OMP_CLAUSE_MAP);
8022 OMP_CLAUSE_SET_MAP_KIND (c2, mkind);
8023 OMP_CLAUSE_DECL (c2)
8024 = unshare_expr (OMP_CLAUSE_DECL (c));
8025 OMP_CLAUSE_CHAIN (c2) = *prev_list_p;
8026 OMP_CLAUSE_SIZE (c2)
8027 = TYPE_SIZE_UNIT (ptr_type_node);
8028 OMP_CLAUSE_CHAIN (l) = c2;
8029 if (OMP_CLAUSE_CHAIN (*prev_list_p) != c)
8031 tree c4 = OMP_CLAUSE_CHAIN (*prev_list_p);
8032 tree c3
8033 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
8034 OMP_CLAUSE_MAP);
8035 OMP_CLAUSE_SET_MAP_KIND (c3, mkind);
8036 OMP_CLAUSE_DECL (c3)
8037 = unshare_expr (OMP_CLAUSE_DECL (c4));
8038 OMP_CLAUSE_SIZE (c3)
8039 = TYPE_SIZE_UNIT (ptr_type_node);
8040 OMP_CLAUSE_CHAIN (c3) = *prev_list_p;
8041 OMP_CLAUSE_CHAIN (c2) = c3;
8043 *prev_list_p = l;
8044 prev_list_p = NULL;
8046 else
8048 OMP_CLAUSE_CHAIN (l) = c;
8049 *list_p = l;
8050 list_p = &OMP_CLAUSE_CHAIN (l);
8052 if (orig_base != base && code == OMP_TARGET)
8054 tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
8055 OMP_CLAUSE_MAP);
8056 enum gomp_map_kind mkind
8057 = GOMP_MAP_FIRSTPRIVATE_REFERENCE;
8058 OMP_CLAUSE_SET_MAP_KIND (c2, mkind);
8059 OMP_CLAUSE_DECL (c2) = decl;
8060 OMP_CLAUSE_SIZE (c2) = size_zero_node;
8061 OMP_CLAUSE_CHAIN (c2) = OMP_CLAUSE_CHAIN (l);
8062 OMP_CLAUSE_CHAIN (l) = c2;
8064 flags = GOVD_MAP | GOVD_EXPLICIT;
8065 if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c)) || ptr)
8066 flags |= GOVD_SEEN;
8067 goto do_add_decl;
8069 else
8071 tree *osc = struct_map_to_clause->get (decl);
8072 tree *sc = NULL, *scp = NULL;
8073 if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c)) || ptr)
8074 n->value |= GOVD_SEEN;
8075 poly_offset_int o1, o2;
8076 if (offset)
8077 o1 = wi::to_poly_offset (offset);
8078 else
8079 o1 = 0;
8080 if (maybe_ne (bitpos, 0))
8081 o1 += bits_to_bytes_round_down (bitpos);
8082 sc = &OMP_CLAUSE_CHAIN (*osc);
8083 if (*sc != c
8084 && (OMP_CLAUSE_MAP_KIND (*sc)
8085 == GOMP_MAP_FIRSTPRIVATE_REFERENCE))
8086 sc = &OMP_CLAUSE_CHAIN (*sc);
8087 for (; *sc != c; sc = &OMP_CLAUSE_CHAIN (*sc))
8088 if (ptr && sc == prev_list_p)
8089 break;
8090 else if (TREE_CODE (OMP_CLAUSE_DECL (*sc))
8091 != COMPONENT_REF
8092 && (TREE_CODE (OMP_CLAUSE_DECL (*sc))
8093 != INDIRECT_REF)
8094 && (TREE_CODE (OMP_CLAUSE_DECL (*sc))
8095 != ARRAY_REF))
8096 break;
8097 else
8099 tree offset2;
8100 poly_int64 bitsize2, bitpos2;
8101 base = OMP_CLAUSE_DECL (*sc);
8102 if (TREE_CODE (base) == ARRAY_REF)
8104 while (TREE_CODE (base) == ARRAY_REF)
8105 base = TREE_OPERAND (base, 0);
8106 if (TREE_CODE (base) != COMPONENT_REF
8107 || (TREE_CODE (TREE_TYPE (base))
8108 != ARRAY_TYPE))
8109 break;
8111 else if (TREE_CODE (base) == INDIRECT_REF
8112 && (TREE_CODE (TREE_OPERAND (base, 0))
8113 == COMPONENT_REF)
8114 && (TREE_CODE (TREE_TYPE
8115 (TREE_OPERAND (base, 0)))
8116 == REFERENCE_TYPE))
8117 base = TREE_OPERAND (base, 0);
8118 base = get_inner_reference (base, &bitsize2,
8119 &bitpos2, &offset2,
8120 &mode, &unsignedp,
8121 &reversep, &volatilep);
8122 if ((TREE_CODE (base) == INDIRECT_REF
8123 || (TREE_CODE (base) == MEM_REF
8124 && integer_zerop (TREE_OPERAND (base,
8125 1))))
8126 && DECL_P (TREE_OPERAND (base, 0))
8127 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base,
8128 0)))
8129 == REFERENCE_TYPE))
8130 base = TREE_OPERAND (base, 0);
8131 if (base != decl)
8132 break;
8133 if (scp)
8134 continue;
8135 gcc_assert (offset == NULL_TREE
8136 || poly_int_tree_p (offset));
8137 tree d1 = OMP_CLAUSE_DECL (*sc);
8138 tree d2 = OMP_CLAUSE_DECL (c);
8139 while (TREE_CODE (d1) == ARRAY_REF)
8140 d1 = TREE_OPERAND (d1, 0);
8141 while (TREE_CODE (d2) == ARRAY_REF)
8142 d2 = TREE_OPERAND (d2, 0);
8143 if (TREE_CODE (d1) == INDIRECT_REF)
8144 d1 = TREE_OPERAND (d1, 0);
8145 if (TREE_CODE (d2) == INDIRECT_REF)
8146 d2 = TREE_OPERAND (d2, 0);
8147 while (TREE_CODE (d1) == COMPONENT_REF)
8148 if (TREE_CODE (d2) == COMPONENT_REF
8149 && TREE_OPERAND (d1, 1)
8150 == TREE_OPERAND (d2, 1))
8152 d1 = TREE_OPERAND (d1, 0);
8153 d2 = TREE_OPERAND (d2, 0);
8155 else
8156 break;
8157 if (d1 == d2)
8159 error_at (OMP_CLAUSE_LOCATION (c),
8160 "%qE appears more than once in map "
8161 "clauses", OMP_CLAUSE_DECL (c));
8162 remove = true;
8163 break;
8165 if (offset2)
8166 o2 = wi::to_poly_offset (offset2);
8167 else
8168 o2 = 0;
8169 o2 += bits_to_bytes_round_down (bitpos2);
8170 if (maybe_lt (o1, o2)
8171 || (known_eq (o1, 2)
8172 && maybe_lt (bitpos, bitpos2)))
8174 if (ptr)
8175 scp = sc;
8176 else
8177 break;
8180 if (remove)
8181 break;
8182 OMP_CLAUSE_SIZE (*osc)
8183 = size_binop (PLUS_EXPR, OMP_CLAUSE_SIZE (*osc),
8184 size_one_node);
8185 if (ptr)
8187 tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
8188 OMP_CLAUSE_MAP);
8189 tree cl = NULL_TREE;
8190 enum gomp_map_kind mkind
8191 = code == OMP_TARGET_EXIT_DATA
8192 ? GOMP_MAP_RELEASE : GOMP_MAP_ALLOC;
8193 OMP_CLAUSE_SET_MAP_KIND (c2, mkind);
8194 OMP_CLAUSE_DECL (c2)
8195 = unshare_expr (OMP_CLAUSE_DECL (c));
8196 OMP_CLAUSE_CHAIN (c2) = scp ? *scp : *prev_list_p;
8197 OMP_CLAUSE_SIZE (c2)
8198 = TYPE_SIZE_UNIT (ptr_type_node);
8199 cl = scp ? *prev_list_p : c2;
8200 if (OMP_CLAUSE_CHAIN (*prev_list_p) != c)
8202 tree c4 = OMP_CLAUSE_CHAIN (*prev_list_p);
8203 tree c3
8204 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
8205 OMP_CLAUSE_MAP);
8206 OMP_CLAUSE_SET_MAP_KIND (c3, mkind);
8207 OMP_CLAUSE_DECL (c3)
8208 = unshare_expr (OMP_CLAUSE_DECL (c4));
8209 OMP_CLAUSE_SIZE (c3)
8210 = TYPE_SIZE_UNIT (ptr_type_node);
8211 OMP_CLAUSE_CHAIN (c3) = *prev_list_p;
8212 if (!scp)
8213 OMP_CLAUSE_CHAIN (c2) = c3;
8214 else
8215 cl = c3;
8217 if (scp)
8218 *scp = c2;
8219 if (sc == prev_list_p)
8221 *sc = cl;
8222 prev_list_p = NULL;
8224 else
8226 *prev_list_p = OMP_CLAUSE_CHAIN (c);
8227 list_p = prev_list_p;
8228 prev_list_p = NULL;
8229 OMP_CLAUSE_CHAIN (c) = *sc;
8230 *sc = cl;
8231 continue;
8234 else if (*sc != c)
8236 *list_p = OMP_CLAUSE_CHAIN (c);
8237 OMP_CLAUSE_CHAIN (c) = *sc;
8238 *sc = c;
8239 continue;
8243 if (!remove
8244 && OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_ALWAYS_POINTER
8245 && OMP_CLAUSE_CHAIN (c)
8246 && OMP_CLAUSE_CODE (OMP_CLAUSE_CHAIN (c)) == OMP_CLAUSE_MAP
8247 && (OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (c))
8248 == GOMP_MAP_ALWAYS_POINTER))
8249 prev_list_p = list_p;
8250 break;
8252 flags = GOVD_MAP | GOVD_EXPLICIT;
8253 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_TO
8254 || OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_TOFROM)
8255 flags |= GOVD_MAP_ALWAYS_TO;
8256 goto do_add;
8258 case OMP_CLAUSE_DEPEND:
8259 if (OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SINK)
8261 tree deps = OMP_CLAUSE_DECL (c);
8262 while (deps && TREE_CODE (deps) == TREE_LIST)
8264 if (TREE_CODE (TREE_PURPOSE (deps)) == TRUNC_DIV_EXPR
8265 && DECL_P (TREE_OPERAND (TREE_PURPOSE (deps), 1)))
8266 gimplify_expr (&TREE_OPERAND (TREE_PURPOSE (deps), 1),
8267 pre_p, NULL, is_gimple_val, fb_rvalue);
8268 deps = TREE_CHAIN (deps);
8270 break;
8272 else if (OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SOURCE)
8273 break;
8274 if (TREE_CODE (OMP_CLAUSE_DECL (c)) == COMPOUND_EXPR)
8276 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (c), 0), pre_p,
8277 NULL, is_gimple_val, fb_rvalue);
8278 OMP_CLAUSE_DECL (c) = TREE_OPERAND (OMP_CLAUSE_DECL (c), 1);
8280 if (error_operand_p (OMP_CLAUSE_DECL (c)))
8282 remove = true;
8283 break;
8285 OMP_CLAUSE_DECL (c) = build_fold_addr_expr (OMP_CLAUSE_DECL (c));
8286 if (gimplify_expr (&OMP_CLAUSE_DECL (c), pre_p, NULL,
8287 is_gimple_val, fb_rvalue) == GS_ERROR)
8289 remove = true;
8290 break;
8292 break;
8294 case OMP_CLAUSE_TO:
8295 case OMP_CLAUSE_FROM:
8296 case OMP_CLAUSE__CACHE_:
8297 decl = OMP_CLAUSE_DECL (c);
8298 if (error_operand_p (decl))
8300 remove = true;
8301 break;
8303 if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
8304 OMP_CLAUSE_SIZE (c) = DECL_P (decl) ? DECL_SIZE_UNIT (decl)
8305 : TYPE_SIZE_UNIT (TREE_TYPE (decl));
8306 if (gimplify_expr (&OMP_CLAUSE_SIZE (c), pre_p,
8307 NULL, is_gimple_val, fb_rvalue) == GS_ERROR)
8309 remove = true;
8310 break;
8312 if (!DECL_P (decl))
8314 if (gimplify_expr (&OMP_CLAUSE_DECL (c), pre_p,
8315 NULL, is_gimple_lvalue, fb_lvalue)
8316 == GS_ERROR)
8318 remove = true;
8319 break;
8321 break;
8323 goto do_notice;
8325 case OMP_CLAUSE_USE_DEVICE_PTR:
8326 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
8327 goto do_add;
8328 case OMP_CLAUSE_IS_DEVICE_PTR:
8329 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
8330 goto do_add;
8332 do_add:
8333 decl = OMP_CLAUSE_DECL (c);
8334 do_add_decl:
8335 if (error_operand_p (decl))
8337 remove = true;
8338 break;
8340 if (DECL_NAME (decl) == NULL_TREE && (flags & GOVD_SHARED) == 0)
8342 tree t = omp_member_access_dummy_var (decl);
8343 if (t)
8345 tree v = DECL_VALUE_EXPR (decl);
8346 DECL_NAME (decl) = DECL_NAME (TREE_OPERAND (v, 1));
8347 if (outer_ctx)
8348 omp_notice_variable (outer_ctx, t, true);
8351 if (code == OACC_DATA
8352 && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
8353 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
8354 flags |= GOVD_MAP_0LEN_ARRAY;
8355 omp_add_variable (ctx, decl, flags);
8356 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
8357 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
8359 omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
8360 GOVD_LOCAL | GOVD_SEEN);
8361 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c)
8362 && walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c),
8363 find_decl_expr,
8364 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c),
8365 NULL) == NULL_TREE)
8366 omp_add_variable (ctx,
8367 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c),
8368 GOVD_LOCAL | GOVD_SEEN);
8369 gimplify_omp_ctxp = ctx;
8370 push_gimplify_context ();
8372 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = NULL;
8373 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = NULL;
8375 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c),
8376 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
8377 pop_gimplify_context
8378 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c)));
8379 push_gimplify_context ();
8380 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c),
8381 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c));
8382 pop_gimplify_context
8383 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c)));
8384 OMP_CLAUSE_REDUCTION_INIT (c) = NULL_TREE;
8385 OMP_CLAUSE_REDUCTION_MERGE (c) = NULL_TREE;
8387 gimplify_omp_ctxp = outer_ctx;
8389 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
8390 && OMP_CLAUSE_LASTPRIVATE_STMT (c))
8392 gimplify_omp_ctxp = ctx;
8393 push_gimplify_context ();
8394 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c)) != BIND_EXPR)
8396 tree bind = build3 (BIND_EXPR, void_type_node, NULL,
8397 NULL, NULL);
8398 TREE_SIDE_EFFECTS (bind) = 1;
8399 BIND_EXPR_BODY (bind) = OMP_CLAUSE_LASTPRIVATE_STMT (c);
8400 OMP_CLAUSE_LASTPRIVATE_STMT (c) = bind;
8402 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c),
8403 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
8404 pop_gimplify_context
8405 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c)));
8406 OMP_CLAUSE_LASTPRIVATE_STMT (c) = NULL_TREE;
8408 gimplify_omp_ctxp = outer_ctx;
8410 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
8411 && OMP_CLAUSE_LINEAR_STMT (c))
8413 gimplify_omp_ctxp = ctx;
8414 push_gimplify_context ();
8415 if (TREE_CODE (OMP_CLAUSE_LINEAR_STMT (c)) != BIND_EXPR)
8417 tree bind = build3 (BIND_EXPR, void_type_node, NULL,
8418 NULL, NULL);
8419 TREE_SIDE_EFFECTS (bind) = 1;
8420 BIND_EXPR_BODY (bind) = OMP_CLAUSE_LINEAR_STMT (c);
8421 OMP_CLAUSE_LINEAR_STMT (c) = bind;
8423 gimplify_and_add (OMP_CLAUSE_LINEAR_STMT (c),
8424 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c));
8425 pop_gimplify_context
8426 (gimple_seq_first_stmt (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c)));
8427 OMP_CLAUSE_LINEAR_STMT (c) = NULL_TREE;
8429 gimplify_omp_ctxp = outer_ctx;
8431 if (notice_outer)
8432 goto do_notice;
8433 break;
8435 case OMP_CLAUSE_COPYIN:
8436 case OMP_CLAUSE_COPYPRIVATE:
8437 decl = OMP_CLAUSE_DECL (c);
8438 if (error_operand_p (decl))
8440 remove = true;
8441 break;
8443 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_COPYPRIVATE
8444 && !remove
8445 && !omp_check_private (ctx, decl, true))
8447 remove = true;
8448 if (is_global_var (decl))
8450 if (DECL_THREAD_LOCAL_P (decl))
8451 remove = false;
8452 else if (DECL_HAS_VALUE_EXPR_P (decl))
8454 tree value = get_base_address (DECL_VALUE_EXPR (decl));
8456 if (value
8457 && DECL_P (value)
8458 && DECL_THREAD_LOCAL_P (value))
8459 remove = false;
8462 if (remove)
8463 error_at (OMP_CLAUSE_LOCATION (c),
8464 "copyprivate variable %qE is not threadprivate"
8465 " or private in outer context", DECL_NAME (decl));
8467 do_notice:
8468 if (outer_ctx)
8469 omp_notice_variable (outer_ctx, decl, true);
8470 if (check_non_private
8471 && region_type == ORT_WORKSHARE
8472 && (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_REDUCTION
8473 || decl == OMP_CLAUSE_DECL (c)
8474 || (TREE_CODE (OMP_CLAUSE_DECL (c)) == MEM_REF
8475 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c), 0))
8476 == ADDR_EXPR
8477 || (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c), 0))
8478 == POINTER_PLUS_EXPR
8479 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND
8480 (OMP_CLAUSE_DECL (c), 0), 0))
8481 == ADDR_EXPR)))))
8482 && omp_check_private (ctx, decl, false))
8484 error ("%s variable %qE is private in outer context",
8485 check_non_private, DECL_NAME (decl));
8486 remove = true;
8488 break;
8490 case OMP_CLAUSE_IF:
8491 if (OMP_CLAUSE_IF_MODIFIER (c) != ERROR_MARK
8492 && OMP_CLAUSE_IF_MODIFIER (c) != code)
8494 const char *p[2];
8495 for (int i = 0; i < 2; i++)
8496 switch (i ? OMP_CLAUSE_IF_MODIFIER (c) : code)
8498 case OMP_PARALLEL: p[i] = "parallel"; break;
8499 case OMP_TASK: p[i] = "task"; break;
8500 case OMP_TASKLOOP: p[i] = "taskloop"; break;
8501 case OMP_TARGET_DATA: p[i] = "target data"; break;
8502 case OMP_TARGET: p[i] = "target"; break;
8503 case OMP_TARGET_UPDATE: p[i] = "target update"; break;
8504 case OMP_TARGET_ENTER_DATA:
8505 p[i] = "target enter data"; break;
8506 case OMP_TARGET_EXIT_DATA: p[i] = "target exit data"; break;
8507 default: gcc_unreachable ();
8509 error_at (OMP_CLAUSE_LOCATION (c),
8510 "expected %qs %<if%> clause modifier rather than %qs",
8511 p[0], p[1]);
8512 remove = true;
8514 /* Fall through. */
8516 case OMP_CLAUSE_FINAL:
8517 OMP_CLAUSE_OPERAND (c, 0)
8518 = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
8519 /* Fall through. */
8521 case OMP_CLAUSE_SCHEDULE:
8522 case OMP_CLAUSE_NUM_THREADS:
8523 case OMP_CLAUSE_NUM_TEAMS:
8524 case OMP_CLAUSE_THREAD_LIMIT:
8525 case OMP_CLAUSE_DIST_SCHEDULE:
8526 case OMP_CLAUSE_DEVICE:
8527 case OMP_CLAUSE_PRIORITY:
8528 case OMP_CLAUSE_GRAINSIZE:
8529 case OMP_CLAUSE_NUM_TASKS:
8530 case OMP_CLAUSE_HINT:
8531 case OMP_CLAUSE_ASYNC:
8532 case OMP_CLAUSE_WAIT:
8533 case OMP_CLAUSE_NUM_GANGS:
8534 case OMP_CLAUSE_NUM_WORKERS:
8535 case OMP_CLAUSE_VECTOR_LENGTH:
8536 case OMP_CLAUSE_WORKER:
8537 case OMP_CLAUSE_VECTOR:
8538 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
8539 is_gimple_val, fb_rvalue) == GS_ERROR)
8540 remove = true;
8541 break;
8543 case OMP_CLAUSE_GANG:
8544 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
8545 is_gimple_val, fb_rvalue) == GS_ERROR)
8546 remove = true;
8547 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 1), pre_p, NULL,
8548 is_gimple_val, fb_rvalue) == GS_ERROR)
8549 remove = true;
8550 break;
8552 case OMP_CLAUSE_NOWAIT:
8553 case OMP_CLAUSE_ORDERED:
8554 case OMP_CLAUSE_UNTIED:
8555 case OMP_CLAUSE_COLLAPSE:
8556 case OMP_CLAUSE_TILE:
8557 case OMP_CLAUSE_AUTO:
8558 case OMP_CLAUSE_SEQ:
8559 case OMP_CLAUSE_INDEPENDENT:
8560 case OMP_CLAUSE_MERGEABLE:
8561 case OMP_CLAUSE_PROC_BIND:
8562 case OMP_CLAUSE_SAFELEN:
8563 case OMP_CLAUSE_SIMDLEN:
8564 case OMP_CLAUSE_NOGROUP:
8565 case OMP_CLAUSE_THREADS:
8566 case OMP_CLAUSE_SIMD:
8567 break;
8569 case OMP_CLAUSE_DEFAULTMAP:
8570 ctx->target_map_scalars_firstprivate = false;
8571 break;
8573 case OMP_CLAUSE_ALIGNED:
8574 decl = OMP_CLAUSE_DECL (c);
8575 if (error_operand_p (decl))
8577 remove = true;
8578 break;
8580 if (gimplify_expr (&OMP_CLAUSE_ALIGNED_ALIGNMENT (c), pre_p, NULL,
8581 is_gimple_val, fb_rvalue) == GS_ERROR)
8583 remove = true;
8584 break;
8586 if (!is_global_var (decl)
8587 && TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE)
8588 omp_add_variable (ctx, decl, GOVD_ALIGNED);
8589 break;
8591 case OMP_CLAUSE_DEFAULT:
8592 ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
8593 break;
8595 default:
8596 gcc_unreachable ();
8599 if (code == OACC_DATA
8600 && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
8601 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
8602 remove = true;
8603 if (remove)
8604 *list_p = OMP_CLAUSE_CHAIN (c);
8605 else
8606 list_p = &OMP_CLAUSE_CHAIN (c);
8609 gimplify_omp_ctxp = ctx;
8610 if (struct_map_to_clause)
8611 delete struct_map_to_clause;
8614 /* Return true if DECL is a candidate for shared to firstprivate
8615 optimization. We only consider non-addressable scalars, not
8616 too big, and not references. */
8618 static bool
8619 omp_shared_to_firstprivate_optimizable_decl_p (tree decl)
8621 if (TREE_ADDRESSABLE (decl))
8622 return false;
8623 tree type = TREE_TYPE (decl);
8624 if (!is_gimple_reg_type (type)
8625 || TREE_CODE (type) == REFERENCE_TYPE
8626 || TREE_ADDRESSABLE (type))
8627 return false;
8628 /* Don't optimize too large decls, as each thread/task will have
8629 its own. */
8630 HOST_WIDE_INT len = int_size_in_bytes (type);
8631 if (len == -1 || len > 4 * POINTER_SIZE / BITS_PER_UNIT)
8632 return false;
8633 if (lang_hooks.decls.omp_privatize_by_reference (decl))
8634 return false;
8635 return true;
8638 /* Helper function of omp_find_stores_op and gimplify_adjust_omp_clauses*.
8639 For omp_shared_to_firstprivate_optimizable_decl_p decl mark it as
8640 GOVD_WRITTEN in outer contexts. */
8642 static void
8643 omp_mark_stores (struct gimplify_omp_ctx *ctx, tree decl)
8645 for (; ctx; ctx = ctx->outer_context)
8647 splay_tree_node n = splay_tree_lookup (ctx->variables,
8648 (splay_tree_key) decl);
8649 if (n == NULL)
8650 continue;
8651 else if (n->value & GOVD_SHARED)
8653 n->value |= GOVD_WRITTEN;
8654 return;
8656 else if (n->value & GOVD_DATA_SHARE_CLASS)
8657 return;
8661 /* Helper callback for walk_gimple_seq to discover possible stores
8662 to omp_shared_to_firstprivate_optimizable_decl_p decls and set
8663 GOVD_WRITTEN if they are GOVD_SHARED in some outer context
8664 for those. */
8666 static tree
8667 omp_find_stores_op (tree *tp, int *walk_subtrees, void *data)
8669 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
8671 *walk_subtrees = 0;
8672 if (!wi->is_lhs)
8673 return NULL_TREE;
8675 tree op = *tp;
8678 if (handled_component_p (op))
8679 op = TREE_OPERAND (op, 0);
8680 else if ((TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
8681 && TREE_CODE (TREE_OPERAND (op, 0)) == ADDR_EXPR)
8682 op = TREE_OPERAND (TREE_OPERAND (op, 0), 0);
8683 else
8684 break;
8686 while (1);
8687 if (!DECL_P (op) || !omp_shared_to_firstprivate_optimizable_decl_p (op))
8688 return NULL_TREE;
8690 omp_mark_stores (gimplify_omp_ctxp, op);
8691 return NULL_TREE;
8694 /* Helper callback for walk_gimple_seq to discover possible stores
8695 to omp_shared_to_firstprivate_optimizable_decl_p decls and set
8696 GOVD_WRITTEN if they are GOVD_SHARED in some outer context
8697 for those. */
8699 static tree
8700 omp_find_stores_stmt (gimple_stmt_iterator *gsi_p,
8701 bool *handled_ops_p,
8702 struct walk_stmt_info *wi)
8704 gimple *stmt = gsi_stmt (*gsi_p);
8705 switch (gimple_code (stmt))
8707 /* Don't recurse on OpenMP constructs for which
8708 gimplify_adjust_omp_clauses already handled the bodies,
8709 except handle gimple_omp_for_pre_body. */
8710 case GIMPLE_OMP_FOR:
8711 *handled_ops_p = true;
8712 if (gimple_omp_for_pre_body (stmt))
8713 walk_gimple_seq (gimple_omp_for_pre_body (stmt),
8714 omp_find_stores_stmt, omp_find_stores_op, wi);
8715 break;
8716 case GIMPLE_OMP_PARALLEL:
8717 case GIMPLE_OMP_TASK:
8718 case GIMPLE_OMP_SECTIONS:
8719 case GIMPLE_OMP_SINGLE:
8720 case GIMPLE_OMP_TARGET:
8721 case GIMPLE_OMP_TEAMS:
8722 case GIMPLE_OMP_CRITICAL:
8723 *handled_ops_p = true;
8724 break;
8725 default:
8726 break;
8728 return NULL_TREE;
8731 struct gimplify_adjust_omp_clauses_data
8733 tree *list_p;
8734 gimple_seq *pre_p;
8737 /* For all variables that were not actually used within the context,
8738 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
8740 static int
8741 gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data)
8743 tree *list_p = ((struct gimplify_adjust_omp_clauses_data *) data)->list_p;
8744 gimple_seq *pre_p
8745 = ((struct gimplify_adjust_omp_clauses_data *) data)->pre_p;
8746 tree decl = (tree) n->key;
8747 unsigned flags = n->value;
8748 enum omp_clause_code code;
8749 tree clause;
8750 bool private_debug;
8752 if (flags & (GOVD_EXPLICIT | GOVD_LOCAL))
8753 return 0;
8754 if ((flags & GOVD_SEEN) == 0)
8755 return 0;
8756 if (flags & GOVD_DEBUG_PRIVATE)
8758 gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_SHARED);
8759 private_debug = true;
8761 else if (flags & GOVD_MAP)
8762 private_debug = false;
8763 else
8764 private_debug
8765 = lang_hooks.decls.omp_private_debug_clause (decl,
8766 !!(flags & GOVD_SHARED));
8767 if (private_debug)
8768 code = OMP_CLAUSE_PRIVATE;
8769 else if (flags & GOVD_MAP)
8771 code = OMP_CLAUSE_MAP;
8772 if ((gimplify_omp_ctxp->region_type & ORT_ACC) == 0
8773 && TYPE_ATOMIC (strip_array_types (TREE_TYPE (decl))))
8775 error ("%<_Atomic%> %qD in implicit %<map%> clause", decl);
8776 return 0;
8779 else if (flags & GOVD_SHARED)
8781 if (is_global_var (decl))
8783 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
8784 while (ctx != NULL)
8786 splay_tree_node on
8787 = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8788 if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
8789 | GOVD_PRIVATE | GOVD_REDUCTION
8790 | GOVD_LINEAR | GOVD_MAP)) != 0)
8791 break;
8792 ctx = ctx->outer_context;
8794 if (ctx == NULL)
8795 return 0;
8797 code = OMP_CLAUSE_SHARED;
8799 else if (flags & GOVD_PRIVATE)
8800 code = OMP_CLAUSE_PRIVATE;
8801 else if (flags & GOVD_FIRSTPRIVATE)
8803 code = OMP_CLAUSE_FIRSTPRIVATE;
8804 if ((gimplify_omp_ctxp->region_type & ORT_TARGET)
8805 && (gimplify_omp_ctxp->region_type & ORT_ACC) == 0
8806 && TYPE_ATOMIC (strip_array_types (TREE_TYPE (decl))))
8808 error ("%<_Atomic%> %qD in implicit %<firstprivate%> clause on "
8809 "%<target%> construct", decl);
8810 return 0;
8813 else if (flags & GOVD_LASTPRIVATE)
8814 code = OMP_CLAUSE_LASTPRIVATE;
8815 else if (flags & GOVD_ALIGNED)
8816 return 0;
8817 else
8818 gcc_unreachable ();
8820 if (((flags & GOVD_LASTPRIVATE)
8821 || (code == OMP_CLAUSE_SHARED && (flags & GOVD_WRITTEN)))
8822 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
8823 omp_mark_stores (gimplify_omp_ctxp->outer_context, decl);
8825 tree chain = *list_p;
8826 clause = build_omp_clause (input_location, code);
8827 OMP_CLAUSE_DECL (clause) = decl;
8828 OMP_CLAUSE_CHAIN (clause) = chain;
8829 if (private_debug)
8830 OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
8831 else if (code == OMP_CLAUSE_PRIVATE && (flags & GOVD_PRIVATE_OUTER_REF))
8832 OMP_CLAUSE_PRIVATE_OUTER_REF (clause) = 1;
8833 else if (code == OMP_CLAUSE_SHARED
8834 && (flags & GOVD_WRITTEN) == 0
8835 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
8836 OMP_CLAUSE_SHARED_READONLY (clause) = 1;
8837 else if (code == OMP_CLAUSE_FIRSTPRIVATE && (flags & GOVD_EXPLICIT) == 0)
8838 OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT (clause) = 1;
8839 else if (code == OMP_CLAUSE_MAP && (flags & GOVD_MAP_0LEN_ARRAY) != 0)
8841 tree nc = build_omp_clause (input_location, OMP_CLAUSE_MAP);
8842 OMP_CLAUSE_DECL (nc) = decl;
8843 if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE
8844 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == POINTER_TYPE)
8845 OMP_CLAUSE_DECL (clause)
8846 = build_simple_mem_ref_loc (input_location, decl);
8847 OMP_CLAUSE_DECL (clause)
8848 = build2 (MEM_REF, char_type_node, OMP_CLAUSE_DECL (clause),
8849 build_int_cst (build_pointer_type (char_type_node), 0));
8850 OMP_CLAUSE_SIZE (clause) = size_zero_node;
8851 OMP_CLAUSE_SIZE (nc) = size_zero_node;
8852 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_ALLOC);
8853 OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (clause) = 1;
8854 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_FIRSTPRIVATE_POINTER);
8855 OMP_CLAUSE_CHAIN (nc) = chain;
8856 OMP_CLAUSE_CHAIN (clause) = nc;
8857 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8858 gimplify_omp_ctxp = ctx->outer_context;
8859 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (clause), 0),
8860 pre_p, NULL, is_gimple_val, fb_rvalue);
8861 gimplify_omp_ctxp = ctx;
8863 else if (code == OMP_CLAUSE_MAP)
8865 int kind;
8866 /* Not all combinations of these GOVD_MAP flags are actually valid. */
8867 switch (flags & (GOVD_MAP_TO_ONLY
8868 | GOVD_MAP_FORCE
8869 | GOVD_MAP_FORCE_PRESENT))
8871 case 0:
8872 kind = GOMP_MAP_TOFROM;
8873 break;
8874 case GOVD_MAP_FORCE:
8875 kind = GOMP_MAP_TOFROM | GOMP_MAP_FLAG_FORCE;
8876 break;
8877 case GOVD_MAP_TO_ONLY:
8878 kind = GOMP_MAP_TO;
8879 break;
8880 case GOVD_MAP_TO_ONLY | GOVD_MAP_FORCE:
8881 kind = GOMP_MAP_TO | GOMP_MAP_FLAG_FORCE;
8882 break;
8883 case GOVD_MAP_FORCE_PRESENT:
8884 kind = GOMP_MAP_FORCE_PRESENT;
8885 break;
8886 default:
8887 gcc_unreachable ();
8889 OMP_CLAUSE_SET_MAP_KIND (clause, kind);
8890 if (DECL_SIZE (decl)
8891 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
8893 tree decl2 = DECL_VALUE_EXPR (decl);
8894 gcc_assert (TREE_CODE (decl2) == INDIRECT_REF);
8895 decl2 = TREE_OPERAND (decl2, 0);
8896 gcc_assert (DECL_P (decl2));
8897 tree mem = build_simple_mem_ref (decl2);
8898 OMP_CLAUSE_DECL (clause) = mem;
8899 OMP_CLAUSE_SIZE (clause) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
8900 if (gimplify_omp_ctxp->outer_context)
8902 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
8903 omp_notice_variable (ctx, decl2, true);
8904 omp_notice_variable (ctx, OMP_CLAUSE_SIZE (clause), true);
8906 tree nc = build_omp_clause (OMP_CLAUSE_LOCATION (clause),
8907 OMP_CLAUSE_MAP);
8908 OMP_CLAUSE_DECL (nc) = decl;
8909 OMP_CLAUSE_SIZE (nc) = size_zero_node;
8910 if (gimplify_omp_ctxp->target_firstprivatize_array_bases)
8911 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_FIRSTPRIVATE_POINTER);
8912 else
8913 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_POINTER);
8914 OMP_CLAUSE_CHAIN (nc) = OMP_CLAUSE_CHAIN (clause);
8915 OMP_CLAUSE_CHAIN (clause) = nc;
8917 else if (gimplify_omp_ctxp->target_firstprivatize_array_bases
8918 && lang_hooks.decls.omp_privatize_by_reference (decl))
8920 OMP_CLAUSE_DECL (clause) = build_simple_mem_ref (decl);
8921 OMP_CLAUSE_SIZE (clause)
8922 = unshare_expr (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl))));
8923 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8924 gimplify_omp_ctxp = ctx->outer_context;
8925 gimplify_expr (&OMP_CLAUSE_SIZE (clause),
8926 pre_p, NULL, is_gimple_val, fb_rvalue);
8927 gimplify_omp_ctxp = ctx;
8928 tree nc = build_omp_clause (OMP_CLAUSE_LOCATION (clause),
8929 OMP_CLAUSE_MAP);
8930 OMP_CLAUSE_DECL (nc) = decl;
8931 OMP_CLAUSE_SIZE (nc) = size_zero_node;
8932 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_FIRSTPRIVATE_REFERENCE);
8933 OMP_CLAUSE_CHAIN (nc) = OMP_CLAUSE_CHAIN (clause);
8934 OMP_CLAUSE_CHAIN (clause) = nc;
8936 else
8937 OMP_CLAUSE_SIZE (clause) = DECL_SIZE_UNIT (decl);
8939 if (code == OMP_CLAUSE_FIRSTPRIVATE && (flags & GOVD_LASTPRIVATE) != 0)
8941 tree nc = build_omp_clause (input_location, OMP_CLAUSE_LASTPRIVATE);
8942 OMP_CLAUSE_DECL (nc) = decl;
8943 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (nc) = 1;
8944 OMP_CLAUSE_CHAIN (nc) = chain;
8945 OMP_CLAUSE_CHAIN (clause) = nc;
8946 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8947 gimplify_omp_ctxp = ctx->outer_context;
8948 lang_hooks.decls.omp_finish_clause (nc, pre_p);
8949 gimplify_omp_ctxp = ctx;
8951 *list_p = clause;
8952 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8953 gimplify_omp_ctxp = ctx->outer_context;
8954 lang_hooks.decls.omp_finish_clause (clause, pre_p);
8955 if (gimplify_omp_ctxp)
8956 for (; clause != chain; clause = OMP_CLAUSE_CHAIN (clause))
8957 if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
8958 && DECL_P (OMP_CLAUSE_SIZE (clause)))
8959 omp_notice_variable (gimplify_omp_ctxp, OMP_CLAUSE_SIZE (clause),
8960 true);
8961 gimplify_omp_ctxp = ctx;
8962 return 0;
8965 static void
8966 gimplify_adjust_omp_clauses (gimple_seq *pre_p, gimple_seq body, tree *list_p,
8967 enum tree_code code)
8969 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8970 tree c, decl;
8972 if (body)
8974 struct gimplify_omp_ctx *octx;
8975 for (octx = ctx; octx; octx = octx->outer_context)
8976 if ((octx->region_type & (ORT_PARALLEL | ORT_TASK | ORT_TEAMS)) != 0)
8977 break;
8978 if (octx)
8980 struct walk_stmt_info wi;
8981 memset (&wi, 0, sizeof (wi));
8982 walk_gimple_seq (body, omp_find_stores_stmt,
8983 omp_find_stores_op, &wi);
8986 while ((c = *list_p) != NULL)
8988 splay_tree_node n;
8989 bool remove = false;
8991 switch (OMP_CLAUSE_CODE (c))
8993 case OMP_CLAUSE_FIRSTPRIVATE:
8994 if ((ctx->region_type & ORT_TARGET)
8995 && (ctx->region_type & ORT_ACC) == 0
8996 && TYPE_ATOMIC (strip_array_types
8997 (TREE_TYPE (OMP_CLAUSE_DECL (c)))))
8999 error_at (OMP_CLAUSE_LOCATION (c),
9000 "%<_Atomic%> %qD in %<firstprivate%> clause on "
9001 "%<target%> construct", OMP_CLAUSE_DECL (c));
9002 remove = true;
9003 break;
9005 /* FALLTHRU */
9006 case OMP_CLAUSE_PRIVATE:
9007 case OMP_CLAUSE_SHARED:
9008 case OMP_CLAUSE_LINEAR:
9009 decl = OMP_CLAUSE_DECL (c);
9010 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
9011 remove = !(n->value & GOVD_SEEN);
9012 if (! remove)
9014 bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
9015 if ((n->value & GOVD_DEBUG_PRIVATE)
9016 || lang_hooks.decls.omp_private_debug_clause (decl, shared))
9018 gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
9019 || ((n->value & GOVD_DATA_SHARE_CLASS)
9020 == GOVD_SHARED));
9021 OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
9022 OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
9024 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED
9025 && (n->value & GOVD_WRITTEN) == 0
9026 && DECL_P (decl)
9027 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
9028 OMP_CLAUSE_SHARED_READONLY (c) = 1;
9029 else if (DECL_P (decl)
9030 && ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED
9031 && (n->value & GOVD_WRITTEN) != 0)
9032 || (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
9033 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c)))
9034 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
9035 omp_mark_stores (gimplify_omp_ctxp->outer_context, decl);
9037 break;
9039 case OMP_CLAUSE_LASTPRIVATE:
9040 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
9041 accurately reflect the presence of a FIRSTPRIVATE clause. */
9042 decl = OMP_CLAUSE_DECL (c);
9043 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
9044 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
9045 = (n->value & GOVD_FIRSTPRIVATE) != 0;
9046 if (code == OMP_DISTRIBUTE
9047 && OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c))
9049 remove = true;
9050 error_at (OMP_CLAUSE_LOCATION (c),
9051 "same variable used in %<firstprivate%> and "
9052 "%<lastprivate%> clauses on %<distribute%> "
9053 "construct");
9055 if (!remove
9056 && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
9057 && DECL_P (decl)
9058 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
9059 omp_mark_stores (gimplify_omp_ctxp->outer_context, decl);
9060 break;
9062 case OMP_CLAUSE_ALIGNED:
9063 decl = OMP_CLAUSE_DECL (c);
9064 if (!is_global_var (decl))
9066 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
9067 remove = n == NULL || !(n->value & GOVD_SEEN);
9068 if (!remove && TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE)
9070 struct gimplify_omp_ctx *octx;
9071 if (n != NULL
9072 && (n->value & (GOVD_DATA_SHARE_CLASS
9073 & ~GOVD_FIRSTPRIVATE)))
9074 remove = true;
9075 else
9076 for (octx = ctx->outer_context; octx;
9077 octx = octx->outer_context)
9079 n = splay_tree_lookup (octx->variables,
9080 (splay_tree_key) decl);
9081 if (n == NULL)
9082 continue;
9083 if (n->value & GOVD_LOCAL)
9084 break;
9085 /* We have to avoid assigning a shared variable
9086 to itself when trying to add
9087 __builtin_assume_aligned. */
9088 if (n->value & GOVD_SHARED)
9090 remove = true;
9091 break;
9096 else if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
9098 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
9099 if (n != NULL && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
9100 remove = true;
9102 break;
9104 case OMP_CLAUSE_MAP:
9105 if (code == OMP_TARGET_EXIT_DATA
9106 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_POINTER)
9108 remove = true;
9109 break;
9111 decl = OMP_CLAUSE_DECL (c);
9112 /* Data clauses associated with acc parallel reductions must be
9113 compatible with present_or_copy. Warn and adjust the clause
9114 if that is not the case. */
9115 if (ctx->region_type == ORT_ACC_PARALLEL)
9117 tree t = DECL_P (decl) ? decl : TREE_OPERAND (decl, 0);
9118 n = NULL;
9120 if (DECL_P (t))
9121 n = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
9123 if (n && (n->value & GOVD_REDUCTION))
9125 enum gomp_map_kind kind = OMP_CLAUSE_MAP_KIND (c);
9127 OMP_CLAUSE_MAP_IN_REDUCTION (c) = 1;
9128 if ((kind & GOMP_MAP_TOFROM) != GOMP_MAP_TOFROM
9129 && kind != GOMP_MAP_FORCE_PRESENT
9130 && kind != GOMP_MAP_POINTER)
9132 warning_at (OMP_CLAUSE_LOCATION (c), 0,
9133 "incompatible data clause with reduction "
9134 "on %qE; promoting to present_or_copy",
9135 DECL_NAME (t));
9136 OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_TOFROM);
9140 if (!DECL_P (decl))
9142 if ((ctx->region_type & ORT_TARGET) != 0
9143 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
9145 if (TREE_CODE (decl) == INDIRECT_REF
9146 && TREE_CODE (TREE_OPERAND (decl, 0)) == COMPONENT_REF
9147 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl, 0)))
9148 == REFERENCE_TYPE))
9149 decl = TREE_OPERAND (decl, 0);
9150 if (TREE_CODE (decl) == COMPONENT_REF)
9152 while (TREE_CODE (decl) == COMPONENT_REF)
9153 decl = TREE_OPERAND (decl, 0);
9154 if (DECL_P (decl))
9156 n = splay_tree_lookup (ctx->variables,
9157 (splay_tree_key) decl);
9158 if (!(n->value & GOVD_SEEN))
9159 remove = true;
9163 break;
9165 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
9166 if ((ctx->region_type & ORT_TARGET) != 0
9167 && !(n->value & GOVD_SEEN)
9168 && GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c)) == 0
9169 && (!is_global_var (decl)
9170 || !lookup_attribute ("omp declare target link",
9171 DECL_ATTRIBUTES (decl))))
9173 remove = true;
9174 /* For struct element mapping, if struct is never referenced
9175 in target block and none of the mapping has always modifier,
9176 remove all the struct element mappings, which immediately
9177 follow the GOMP_MAP_STRUCT map clause. */
9178 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_STRUCT)
9180 HOST_WIDE_INT cnt = tree_to_shwi (OMP_CLAUSE_SIZE (c));
9181 while (cnt--)
9182 OMP_CLAUSE_CHAIN (c)
9183 = OMP_CLAUSE_CHAIN (OMP_CLAUSE_CHAIN (c));
9186 else if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_STRUCT
9187 && code == OMP_TARGET_EXIT_DATA)
9188 remove = true;
9189 else if (DECL_SIZE (decl)
9190 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST
9191 && OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_POINTER
9192 && OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_FIRSTPRIVATE_POINTER
9193 && (OMP_CLAUSE_MAP_KIND (c)
9194 != GOMP_MAP_FIRSTPRIVATE_REFERENCE))
9196 /* For GOMP_MAP_FORCE_DEVICEPTR, we'll never enter here, because
9197 for these, TREE_CODE (DECL_SIZE (decl)) will always be
9198 INTEGER_CST. */
9199 gcc_assert (OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_FORCE_DEVICEPTR);
9201 tree decl2 = DECL_VALUE_EXPR (decl);
9202 gcc_assert (TREE_CODE (decl2) == INDIRECT_REF);
9203 decl2 = TREE_OPERAND (decl2, 0);
9204 gcc_assert (DECL_P (decl2));
9205 tree mem = build_simple_mem_ref (decl2);
9206 OMP_CLAUSE_DECL (c) = mem;
9207 OMP_CLAUSE_SIZE (c) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
9208 if (ctx->outer_context)
9210 omp_notice_variable (ctx->outer_context, decl2, true);
9211 omp_notice_variable (ctx->outer_context,
9212 OMP_CLAUSE_SIZE (c), true);
9214 if (((ctx->region_type & ORT_TARGET) != 0
9215 || !ctx->target_firstprivatize_array_bases)
9216 && ((n->value & GOVD_SEEN) == 0
9217 || (n->value & (GOVD_PRIVATE | GOVD_FIRSTPRIVATE)) == 0))
9219 tree nc = build_omp_clause (OMP_CLAUSE_LOCATION (c),
9220 OMP_CLAUSE_MAP);
9221 OMP_CLAUSE_DECL (nc) = decl;
9222 OMP_CLAUSE_SIZE (nc) = size_zero_node;
9223 if (ctx->target_firstprivatize_array_bases)
9224 OMP_CLAUSE_SET_MAP_KIND (nc,
9225 GOMP_MAP_FIRSTPRIVATE_POINTER);
9226 else
9227 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_POINTER);
9228 OMP_CLAUSE_CHAIN (nc) = OMP_CLAUSE_CHAIN (c);
9229 OMP_CLAUSE_CHAIN (c) = nc;
9230 c = nc;
9233 else
9235 if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
9236 OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (decl);
9237 gcc_assert ((n->value & GOVD_SEEN) == 0
9238 || ((n->value & (GOVD_PRIVATE | GOVD_FIRSTPRIVATE))
9239 == 0));
9241 break;
9243 case OMP_CLAUSE_TO:
9244 case OMP_CLAUSE_FROM:
9245 case OMP_CLAUSE__CACHE_:
9246 decl = OMP_CLAUSE_DECL (c);
9247 if (!DECL_P (decl))
9248 break;
9249 if (DECL_SIZE (decl)
9250 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
9252 tree decl2 = DECL_VALUE_EXPR (decl);
9253 gcc_assert (TREE_CODE (decl2) == INDIRECT_REF);
9254 decl2 = TREE_OPERAND (decl2, 0);
9255 gcc_assert (DECL_P (decl2));
9256 tree mem = build_simple_mem_ref (decl2);
9257 OMP_CLAUSE_DECL (c) = mem;
9258 OMP_CLAUSE_SIZE (c) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
9259 if (ctx->outer_context)
9261 omp_notice_variable (ctx->outer_context, decl2, true);
9262 omp_notice_variable (ctx->outer_context,
9263 OMP_CLAUSE_SIZE (c), true);
9266 else if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
9267 OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (decl);
9268 break;
9270 case OMP_CLAUSE_REDUCTION:
9271 decl = OMP_CLAUSE_DECL (c);
9272 /* OpenACC reductions need a present_or_copy data clause.
9273 Add one if necessary. Error is the reduction is private. */
9274 if (ctx->region_type == ORT_ACC_PARALLEL)
9276 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
9277 if (n->value & (GOVD_PRIVATE | GOVD_FIRSTPRIVATE))
9278 error_at (OMP_CLAUSE_LOCATION (c), "invalid private "
9279 "reduction on %qE", DECL_NAME (decl));
9280 else if ((n->value & GOVD_MAP) == 0)
9282 tree next = OMP_CLAUSE_CHAIN (c);
9283 tree nc = build_omp_clause (UNKNOWN_LOCATION, OMP_CLAUSE_MAP);
9284 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_TOFROM);
9285 OMP_CLAUSE_DECL (nc) = decl;
9286 OMP_CLAUSE_CHAIN (c) = nc;
9287 lang_hooks.decls.omp_finish_clause (nc, pre_p);
9288 while (1)
9290 OMP_CLAUSE_MAP_IN_REDUCTION (nc) = 1;
9291 if (OMP_CLAUSE_CHAIN (nc) == NULL)
9292 break;
9293 nc = OMP_CLAUSE_CHAIN (nc);
9295 OMP_CLAUSE_CHAIN (nc) = next;
9296 n->value |= GOVD_MAP;
9299 if (DECL_P (decl)
9300 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
9301 omp_mark_stores (gimplify_omp_ctxp->outer_context, decl);
9302 break;
9303 case OMP_CLAUSE_COPYIN:
9304 case OMP_CLAUSE_COPYPRIVATE:
9305 case OMP_CLAUSE_IF:
9306 case OMP_CLAUSE_NUM_THREADS:
9307 case OMP_CLAUSE_NUM_TEAMS:
9308 case OMP_CLAUSE_THREAD_LIMIT:
9309 case OMP_CLAUSE_DIST_SCHEDULE:
9310 case OMP_CLAUSE_DEVICE:
9311 case OMP_CLAUSE_SCHEDULE:
9312 case OMP_CLAUSE_NOWAIT:
9313 case OMP_CLAUSE_ORDERED:
9314 case OMP_CLAUSE_DEFAULT:
9315 case OMP_CLAUSE_UNTIED:
9316 case OMP_CLAUSE_COLLAPSE:
9317 case OMP_CLAUSE_FINAL:
9318 case OMP_CLAUSE_MERGEABLE:
9319 case OMP_CLAUSE_PROC_BIND:
9320 case OMP_CLAUSE_SAFELEN:
9321 case OMP_CLAUSE_SIMDLEN:
9322 case OMP_CLAUSE_DEPEND:
9323 case OMP_CLAUSE_PRIORITY:
9324 case OMP_CLAUSE_GRAINSIZE:
9325 case OMP_CLAUSE_NUM_TASKS:
9326 case OMP_CLAUSE_NOGROUP:
9327 case OMP_CLAUSE_THREADS:
9328 case OMP_CLAUSE_SIMD:
9329 case OMP_CLAUSE_HINT:
9330 case OMP_CLAUSE_DEFAULTMAP:
9331 case OMP_CLAUSE_USE_DEVICE_PTR:
9332 case OMP_CLAUSE_IS_DEVICE_PTR:
9333 case OMP_CLAUSE_ASYNC:
9334 case OMP_CLAUSE_WAIT:
9335 case OMP_CLAUSE_INDEPENDENT:
9336 case OMP_CLAUSE_NUM_GANGS:
9337 case OMP_CLAUSE_NUM_WORKERS:
9338 case OMP_CLAUSE_VECTOR_LENGTH:
9339 case OMP_CLAUSE_GANG:
9340 case OMP_CLAUSE_WORKER:
9341 case OMP_CLAUSE_VECTOR:
9342 case OMP_CLAUSE_AUTO:
9343 case OMP_CLAUSE_SEQ:
9344 case OMP_CLAUSE_TILE:
9345 break;
9347 default:
9348 gcc_unreachable ();
9351 if (remove)
9352 *list_p = OMP_CLAUSE_CHAIN (c);
9353 else
9354 list_p = &OMP_CLAUSE_CHAIN (c);
9357 /* Add in any implicit data sharing. */
9358 struct gimplify_adjust_omp_clauses_data data;
9359 data.list_p = list_p;
9360 data.pre_p = pre_p;
9361 splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, &data);
9363 gimplify_omp_ctxp = ctx->outer_context;
9364 delete_omp_context (ctx);
9367 /* Gimplify OACC_CACHE. */
9369 static void
9370 gimplify_oacc_cache (tree *expr_p, gimple_seq *pre_p)
9372 tree expr = *expr_p;
9374 gimplify_scan_omp_clauses (&OACC_CACHE_CLAUSES (expr), pre_p, ORT_ACC,
9375 OACC_CACHE);
9376 gimplify_adjust_omp_clauses (pre_p, NULL, &OACC_CACHE_CLAUSES (expr),
9377 OACC_CACHE);
9379 /* TODO: Do something sensible with this information. */
9381 *expr_p = NULL_TREE;
9384 /* Helper function of gimplify_oacc_declare. The helper's purpose is to,
9385 if required, translate 'kind' in CLAUSE into an 'entry' kind and 'exit'
9386 kind. The entry kind will replace the one in CLAUSE, while the exit
9387 kind will be used in a new omp_clause and returned to the caller. */
9389 static tree
9390 gimplify_oacc_declare_1 (tree clause)
9392 HOST_WIDE_INT kind, new_op;
9393 bool ret = false;
9394 tree c = NULL;
9396 kind = OMP_CLAUSE_MAP_KIND (clause);
9398 switch (kind)
9400 case GOMP_MAP_ALLOC:
9401 case GOMP_MAP_FORCE_ALLOC:
9402 case GOMP_MAP_FORCE_TO:
9403 new_op = GOMP_MAP_DELETE;
9404 ret = true;
9405 break;
9407 case GOMP_MAP_FORCE_FROM:
9408 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_FORCE_ALLOC);
9409 new_op = GOMP_MAP_FORCE_FROM;
9410 ret = true;
9411 break;
9413 case GOMP_MAP_FORCE_TOFROM:
9414 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_FORCE_TO);
9415 new_op = GOMP_MAP_FORCE_FROM;
9416 ret = true;
9417 break;
9419 case GOMP_MAP_FROM:
9420 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_FORCE_ALLOC);
9421 new_op = GOMP_MAP_FROM;
9422 ret = true;
9423 break;
9425 case GOMP_MAP_TOFROM:
9426 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_TO);
9427 new_op = GOMP_MAP_FROM;
9428 ret = true;
9429 break;
9431 case GOMP_MAP_DEVICE_RESIDENT:
9432 case GOMP_MAP_FORCE_DEVICEPTR:
9433 case GOMP_MAP_FORCE_PRESENT:
9434 case GOMP_MAP_LINK:
9435 case GOMP_MAP_POINTER:
9436 case GOMP_MAP_TO:
9437 break;
9439 default:
9440 gcc_unreachable ();
9441 break;
9444 if (ret)
9446 c = build_omp_clause (OMP_CLAUSE_LOCATION (clause), OMP_CLAUSE_MAP);
9447 OMP_CLAUSE_SET_MAP_KIND (c, new_op);
9448 OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clause);
9451 return c;
9454 /* Gimplify OACC_DECLARE. */
9456 static void
9457 gimplify_oacc_declare (tree *expr_p, gimple_seq *pre_p)
9459 tree expr = *expr_p;
9460 gomp_target *stmt;
9461 tree clauses, t, decl;
9463 clauses = OACC_DECLARE_CLAUSES (expr);
9465 gimplify_scan_omp_clauses (&clauses, pre_p, ORT_TARGET_DATA, OACC_DECLARE);
9466 gimplify_adjust_omp_clauses (pre_p, NULL, &clauses, OACC_DECLARE);
9468 for (t = clauses; t; t = OMP_CLAUSE_CHAIN (t))
9470 decl = OMP_CLAUSE_DECL (t);
9472 if (TREE_CODE (decl) == MEM_REF)
9473 decl = TREE_OPERAND (decl, 0);
9475 if (VAR_P (decl) && !is_oacc_declared (decl))
9477 tree attr = get_identifier ("oacc declare target");
9478 DECL_ATTRIBUTES (decl) = tree_cons (attr, NULL_TREE,
9479 DECL_ATTRIBUTES (decl));
9482 if (VAR_P (decl)
9483 && !is_global_var (decl)
9484 && DECL_CONTEXT (decl) == current_function_decl)
9486 tree c = gimplify_oacc_declare_1 (t);
9487 if (c)
9489 if (oacc_declare_returns == NULL)
9490 oacc_declare_returns = new hash_map<tree, tree>;
9492 oacc_declare_returns->put (decl, c);
9496 if (gimplify_omp_ctxp)
9497 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_SEEN);
9500 stmt = gimple_build_omp_target (NULL, GF_OMP_TARGET_KIND_OACC_DECLARE,
9501 clauses);
9503 gimplify_seq_add_stmt (pre_p, stmt);
9505 *expr_p = NULL_TREE;
9508 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
9509 gimplification of the body, as well as scanning the body for used
9510 variables. We need to do this scan now, because variable-sized
9511 decls will be decomposed during gimplification. */
9513 static void
9514 gimplify_omp_parallel (tree *expr_p, gimple_seq *pre_p)
9516 tree expr = *expr_p;
9517 gimple *g;
9518 gimple_seq body = NULL;
9520 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p,
9521 OMP_PARALLEL_COMBINED (expr)
9522 ? ORT_COMBINED_PARALLEL
9523 : ORT_PARALLEL, OMP_PARALLEL);
9525 push_gimplify_context ();
9527 g = gimplify_and_return_first (OMP_PARALLEL_BODY (expr), &body);
9528 if (gimple_code (g) == GIMPLE_BIND)
9529 pop_gimplify_context (g);
9530 else
9531 pop_gimplify_context (NULL);
9533 gimplify_adjust_omp_clauses (pre_p, body, &OMP_PARALLEL_CLAUSES (expr),
9534 OMP_PARALLEL);
9536 g = gimple_build_omp_parallel (body,
9537 OMP_PARALLEL_CLAUSES (expr),
9538 NULL_TREE, NULL_TREE);
9539 if (OMP_PARALLEL_COMBINED (expr))
9540 gimple_omp_set_subcode (g, GF_OMP_PARALLEL_COMBINED);
9541 gimplify_seq_add_stmt (pre_p, g);
9542 *expr_p = NULL_TREE;
9545 /* Gimplify the contents of an OMP_TASK statement. This involves
9546 gimplification of the body, as well as scanning the body for used
9547 variables. We need to do this scan now, because variable-sized
9548 decls will be decomposed during gimplification. */
9550 static void
9551 gimplify_omp_task (tree *expr_p, gimple_seq *pre_p)
9553 tree expr = *expr_p;
9554 gimple *g;
9555 gimple_seq body = NULL;
9557 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr), pre_p,
9558 omp_find_clause (OMP_TASK_CLAUSES (expr),
9559 OMP_CLAUSE_UNTIED)
9560 ? ORT_UNTIED_TASK : ORT_TASK, OMP_TASK);
9562 push_gimplify_context ();
9564 g = gimplify_and_return_first (OMP_TASK_BODY (expr), &body);
9565 if (gimple_code (g) == GIMPLE_BIND)
9566 pop_gimplify_context (g);
9567 else
9568 pop_gimplify_context (NULL);
9570 gimplify_adjust_omp_clauses (pre_p, body, &OMP_TASK_CLAUSES (expr),
9571 OMP_TASK);
9573 g = gimple_build_omp_task (body,
9574 OMP_TASK_CLAUSES (expr),
9575 NULL_TREE, NULL_TREE,
9576 NULL_TREE, NULL_TREE, NULL_TREE);
9577 gimplify_seq_add_stmt (pre_p, g);
9578 *expr_p = NULL_TREE;
9581 /* Helper function of gimplify_omp_for, find OMP_FOR resp. OMP_SIMD
9582 with non-NULL OMP_FOR_INIT. */
9584 static tree
9585 find_combined_omp_for (tree *tp, int *walk_subtrees, void *)
9587 *walk_subtrees = 0;
9588 switch (TREE_CODE (*tp))
9590 case OMP_FOR:
9591 *walk_subtrees = 1;
9592 /* FALLTHRU */
9593 case OMP_SIMD:
9594 if (OMP_FOR_INIT (*tp) != NULL_TREE)
9595 return *tp;
9596 break;
9597 case BIND_EXPR:
9598 case STATEMENT_LIST:
9599 case OMP_PARALLEL:
9600 *walk_subtrees = 1;
9601 break;
9602 default:
9603 break;
9605 return NULL_TREE;
9608 /* Gimplify the gross structure of an OMP_FOR statement. */
9610 static enum gimplify_status
9611 gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
9613 tree for_stmt, orig_for_stmt, inner_for_stmt = NULL_TREE, decl, var, t;
9614 enum gimplify_status ret = GS_ALL_DONE;
9615 enum gimplify_status tret;
9616 gomp_for *gfor;
9617 gimple_seq for_body, for_pre_body;
9618 int i;
9619 bitmap has_decl_expr = NULL;
9620 enum omp_region_type ort = ORT_WORKSHARE;
9622 orig_for_stmt = for_stmt = *expr_p;
9624 switch (TREE_CODE (for_stmt))
9626 case OMP_FOR:
9627 case OMP_DISTRIBUTE:
9628 break;
9629 case OACC_LOOP:
9630 ort = ORT_ACC;
9631 break;
9632 case OMP_TASKLOOP:
9633 if (omp_find_clause (OMP_FOR_CLAUSES (for_stmt), OMP_CLAUSE_UNTIED))
9634 ort = ORT_UNTIED_TASK;
9635 else
9636 ort = ORT_TASK;
9637 break;
9638 case OMP_SIMD:
9639 ort = ORT_SIMD;
9640 break;
9641 default:
9642 gcc_unreachable ();
9645 /* Set OMP_CLAUSE_LINEAR_NO_COPYIN flag on explicit linear
9646 clause for the IV. */
9647 if (ort == ORT_SIMD && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) == 1)
9649 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), 0);
9650 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
9651 decl = TREE_OPERAND (t, 0);
9652 for (tree c = OMP_FOR_CLAUSES (for_stmt); c; c = OMP_CLAUSE_CHAIN (c))
9653 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
9654 && OMP_CLAUSE_DECL (c) == decl)
9656 OMP_CLAUSE_LINEAR_NO_COPYIN (c) = 1;
9657 break;
9661 if (OMP_FOR_INIT (for_stmt) == NULL_TREE)
9663 gcc_assert (TREE_CODE (for_stmt) != OACC_LOOP);
9664 inner_for_stmt = walk_tree (&OMP_FOR_BODY (for_stmt),
9665 find_combined_omp_for, NULL, NULL);
9666 if (inner_for_stmt == NULL_TREE)
9668 gcc_assert (seen_error ());
9669 *expr_p = NULL_TREE;
9670 return GS_ERROR;
9674 if (TREE_CODE (for_stmt) != OMP_TASKLOOP)
9675 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p, ort,
9676 TREE_CODE (for_stmt));
9678 if (TREE_CODE (for_stmt) == OMP_DISTRIBUTE)
9679 gimplify_omp_ctxp->distribute = true;
9681 /* Handle OMP_FOR_INIT. */
9682 for_pre_body = NULL;
9683 if (ort == ORT_SIMD && OMP_FOR_PRE_BODY (for_stmt))
9685 has_decl_expr = BITMAP_ALLOC (NULL);
9686 if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt)) == DECL_EXPR
9687 && TREE_CODE (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt)))
9688 == VAR_DECL)
9690 t = OMP_FOR_PRE_BODY (for_stmt);
9691 bitmap_set_bit (has_decl_expr, DECL_UID (DECL_EXPR_DECL (t)));
9693 else if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt)) == STATEMENT_LIST)
9695 tree_stmt_iterator si;
9696 for (si = tsi_start (OMP_FOR_PRE_BODY (for_stmt)); !tsi_end_p (si);
9697 tsi_next (&si))
9699 t = tsi_stmt (si);
9700 if (TREE_CODE (t) == DECL_EXPR
9701 && TREE_CODE (DECL_EXPR_DECL (t)) == VAR_DECL)
9702 bitmap_set_bit (has_decl_expr, DECL_UID (DECL_EXPR_DECL (t)));
9706 if (OMP_FOR_PRE_BODY (for_stmt))
9708 if (TREE_CODE (for_stmt) != OMP_TASKLOOP || gimplify_omp_ctxp)
9709 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt), &for_pre_body);
9710 else
9712 struct gimplify_omp_ctx ctx;
9713 memset (&ctx, 0, sizeof (ctx));
9714 ctx.region_type = ORT_NONE;
9715 gimplify_omp_ctxp = &ctx;
9716 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt), &for_pre_body);
9717 gimplify_omp_ctxp = NULL;
9720 OMP_FOR_PRE_BODY (for_stmt) = NULL_TREE;
9722 if (OMP_FOR_INIT (for_stmt) == NULL_TREE)
9723 for_stmt = inner_for_stmt;
9725 /* For taskloop, need to gimplify the start, end and step before the
9726 taskloop, outside of the taskloop omp context. */
9727 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
9729 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
9731 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
9732 if (!is_gimple_constant (TREE_OPERAND (t, 1)))
9734 TREE_OPERAND (t, 1)
9735 = get_initialized_tmp_var (TREE_OPERAND (t, 1),
9736 pre_p, NULL, false);
9737 tree c = build_omp_clause (input_location,
9738 OMP_CLAUSE_FIRSTPRIVATE);
9739 OMP_CLAUSE_DECL (c) = TREE_OPERAND (t, 1);
9740 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (orig_for_stmt);
9741 OMP_FOR_CLAUSES (orig_for_stmt) = c;
9744 /* Handle OMP_FOR_COND. */
9745 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
9746 if (!is_gimple_constant (TREE_OPERAND (t, 1)))
9748 TREE_OPERAND (t, 1)
9749 = get_initialized_tmp_var (TREE_OPERAND (t, 1),
9750 gimple_seq_empty_p (for_pre_body)
9751 ? pre_p : &for_pre_body, NULL,
9752 false);
9753 tree c = build_omp_clause (input_location,
9754 OMP_CLAUSE_FIRSTPRIVATE);
9755 OMP_CLAUSE_DECL (c) = TREE_OPERAND (t, 1);
9756 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (orig_for_stmt);
9757 OMP_FOR_CLAUSES (orig_for_stmt) = c;
9760 /* Handle OMP_FOR_INCR. */
9761 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
9762 if (TREE_CODE (t) == MODIFY_EXPR)
9764 decl = TREE_OPERAND (t, 0);
9765 t = TREE_OPERAND (t, 1);
9766 tree *tp = &TREE_OPERAND (t, 1);
9767 if (TREE_CODE (t) == PLUS_EXPR && *tp == decl)
9768 tp = &TREE_OPERAND (t, 0);
9770 if (!is_gimple_constant (*tp))
9772 gimple_seq *seq = gimple_seq_empty_p (for_pre_body)
9773 ? pre_p : &for_pre_body;
9774 *tp = get_initialized_tmp_var (*tp, seq, NULL, false);
9775 tree c = build_omp_clause (input_location,
9776 OMP_CLAUSE_FIRSTPRIVATE);
9777 OMP_CLAUSE_DECL (c) = *tp;
9778 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (orig_for_stmt);
9779 OMP_FOR_CLAUSES (orig_for_stmt) = c;
9784 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (orig_for_stmt), pre_p, ort,
9785 OMP_TASKLOOP);
9788 if (orig_for_stmt != for_stmt)
9789 gimplify_omp_ctxp->combined_loop = true;
9791 for_body = NULL;
9792 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
9793 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt)));
9794 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
9795 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt)));
9797 tree c = omp_find_clause (OMP_FOR_CLAUSES (for_stmt), OMP_CLAUSE_ORDERED);
9798 bool is_doacross = false;
9799 if (c && OMP_CLAUSE_ORDERED_EXPR (c))
9801 is_doacross = true;
9802 gimplify_omp_ctxp->loop_iter_var.create (TREE_VEC_LENGTH
9803 (OMP_FOR_INIT (for_stmt))
9804 * 2);
9806 int collapse = 1, tile = 0;
9807 c = omp_find_clause (OMP_FOR_CLAUSES (for_stmt), OMP_CLAUSE_COLLAPSE);
9808 if (c)
9809 collapse = tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (c));
9810 c = omp_find_clause (OMP_FOR_CLAUSES (for_stmt), OMP_CLAUSE_TILE);
9811 if (c)
9812 tile = list_length (OMP_CLAUSE_TILE_LIST (c));
9813 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
9815 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
9816 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
9817 decl = TREE_OPERAND (t, 0);
9818 gcc_assert (DECL_P (decl));
9819 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl))
9820 || POINTER_TYPE_P (TREE_TYPE (decl)));
9821 if (is_doacross)
9823 if (TREE_CODE (for_stmt) == OMP_FOR && OMP_FOR_ORIG_DECLS (for_stmt))
9824 gimplify_omp_ctxp->loop_iter_var.quick_push
9825 (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt), i));
9826 else
9827 gimplify_omp_ctxp->loop_iter_var.quick_push (decl);
9828 gimplify_omp_ctxp->loop_iter_var.quick_push (decl);
9831 /* Make sure the iteration variable is private. */
9832 tree c = NULL_TREE;
9833 tree c2 = NULL_TREE;
9834 if (orig_for_stmt != for_stmt)
9835 /* Do this only on innermost construct for combined ones. */;
9836 else if (ort == ORT_SIMD)
9838 splay_tree_node n = splay_tree_lookup (gimplify_omp_ctxp->variables,
9839 (splay_tree_key) decl);
9840 omp_is_private (gimplify_omp_ctxp, decl,
9841 1 + (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
9842 != 1));
9843 if (n != NULL && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
9844 omp_notice_variable (gimplify_omp_ctxp, decl, true);
9845 else if (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) == 1)
9847 c = build_omp_clause (input_location, OMP_CLAUSE_LINEAR);
9848 OMP_CLAUSE_LINEAR_NO_COPYIN (c) = 1;
9849 unsigned int flags = GOVD_LINEAR | GOVD_EXPLICIT | GOVD_SEEN;
9850 if (has_decl_expr
9851 && bitmap_bit_p (has_decl_expr, DECL_UID (decl)))
9853 OMP_CLAUSE_LINEAR_NO_COPYOUT (c) = 1;
9854 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
9856 struct gimplify_omp_ctx *outer
9857 = gimplify_omp_ctxp->outer_context;
9858 if (outer && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
9860 if (outer->region_type == ORT_WORKSHARE
9861 && outer->combined_loop)
9863 n = splay_tree_lookup (outer->variables,
9864 (splay_tree_key)decl);
9865 if (n != NULL && (n->value & GOVD_LOCAL) != 0)
9867 OMP_CLAUSE_LINEAR_NO_COPYOUT (c) = 1;
9868 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
9870 else
9872 struct gimplify_omp_ctx *octx = outer->outer_context;
9873 if (octx
9874 && octx->region_type == ORT_COMBINED_PARALLEL
9875 && octx->outer_context
9876 && (octx->outer_context->region_type
9877 == ORT_WORKSHARE)
9878 && octx->outer_context->combined_loop)
9880 octx = octx->outer_context;
9881 n = splay_tree_lookup (octx->variables,
9882 (splay_tree_key)decl);
9883 if (n != NULL && (n->value & GOVD_LOCAL) != 0)
9885 OMP_CLAUSE_LINEAR_NO_COPYOUT (c) = 1;
9886 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
9893 OMP_CLAUSE_DECL (c) = decl;
9894 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (for_stmt);
9895 OMP_FOR_CLAUSES (for_stmt) = c;
9896 omp_add_variable (gimplify_omp_ctxp, decl, flags);
9897 if (outer && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
9899 if (outer->region_type == ORT_WORKSHARE
9900 && outer->combined_loop)
9902 if (outer->outer_context
9903 && (outer->outer_context->region_type
9904 == ORT_COMBINED_PARALLEL))
9905 outer = outer->outer_context;
9906 else if (omp_check_private (outer, decl, false))
9907 outer = NULL;
9909 else if (((outer->region_type & ORT_TASK) != 0)
9910 && outer->combined_loop
9911 && !omp_check_private (gimplify_omp_ctxp,
9912 decl, false))
9914 else if (outer->region_type != ORT_COMBINED_PARALLEL)
9916 omp_notice_variable (outer, decl, true);
9917 outer = NULL;
9919 if (outer)
9921 n = splay_tree_lookup (outer->variables,
9922 (splay_tree_key)decl);
9923 if (n == NULL || (n->value & GOVD_DATA_SHARE_CLASS) == 0)
9925 omp_add_variable (outer, decl,
9926 GOVD_LASTPRIVATE | GOVD_SEEN);
9927 if (outer->region_type == ORT_COMBINED_PARALLEL
9928 && outer->outer_context
9929 && (outer->outer_context->region_type
9930 == ORT_WORKSHARE)
9931 && outer->outer_context->combined_loop)
9933 outer = outer->outer_context;
9934 n = splay_tree_lookup (outer->variables,
9935 (splay_tree_key)decl);
9936 if (omp_check_private (outer, decl, false))
9937 outer = NULL;
9938 else if (n == NULL
9939 || ((n->value & GOVD_DATA_SHARE_CLASS)
9940 == 0))
9941 omp_add_variable (outer, decl,
9942 GOVD_LASTPRIVATE
9943 | GOVD_SEEN);
9944 else
9945 outer = NULL;
9947 if (outer && outer->outer_context
9948 && (outer->outer_context->region_type
9949 == ORT_COMBINED_TEAMS))
9951 outer = outer->outer_context;
9952 n = splay_tree_lookup (outer->variables,
9953 (splay_tree_key)decl);
9954 if (n == NULL
9955 || (n->value & GOVD_DATA_SHARE_CLASS) == 0)
9956 omp_add_variable (outer, decl,
9957 GOVD_SHARED | GOVD_SEEN);
9958 else
9959 outer = NULL;
9961 if (outer && outer->outer_context)
9962 omp_notice_variable (outer->outer_context, decl,
9963 true);
9968 else
9970 bool lastprivate
9971 = (!has_decl_expr
9972 || !bitmap_bit_p (has_decl_expr, DECL_UID (decl)));
9973 struct gimplify_omp_ctx *outer
9974 = gimplify_omp_ctxp->outer_context;
9975 if (outer && lastprivate)
9977 if (outer->region_type == ORT_WORKSHARE
9978 && outer->combined_loop)
9980 n = splay_tree_lookup (outer->variables,
9981 (splay_tree_key)decl);
9982 if (n != NULL && (n->value & GOVD_LOCAL) != 0)
9984 lastprivate = false;
9985 outer = NULL;
9987 else if (outer->outer_context
9988 && (outer->outer_context->region_type
9989 == ORT_COMBINED_PARALLEL))
9990 outer = outer->outer_context;
9991 else if (omp_check_private (outer, decl, false))
9992 outer = NULL;
9994 else if (((outer->region_type & ORT_TASK) != 0)
9995 && outer->combined_loop
9996 && !omp_check_private (gimplify_omp_ctxp,
9997 decl, false))
9999 else if (outer->region_type != ORT_COMBINED_PARALLEL)
10001 omp_notice_variable (outer, decl, true);
10002 outer = NULL;
10004 if (outer)
10006 n = splay_tree_lookup (outer->variables,
10007 (splay_tree_key)decl);
10008 if (n == NULL || (n->value & GOVD_DATA_SHARE_CLASS) == 0)
10010 omp_add_variable (outer, decl,
10011 GOVD_LASTPRIVATE | GOVD_SEEN);
10012 if (outer->region_type == ORT_COMBINED_PARALLEL
10013 && outer->outer_context
10014 && (outer->outer_context->region_type
10015 == ORT_WORKSHARE)
10016 && outer->outer_context->combined_loop)
10018 outer = outer->outer_context;
10019 n = splay_tree_lookup (outer->variables,
10020 (splay_tree_key)decl);
10021 if (omp_check_private (outer, decl, false))
10022 outer = NULL;
10023 else if (n == NULL
10024 || ((n->value & GOVD_DATA_SHARE_CLASS)
10025 == 0))
10026 omp_add_variable (outer, decl,
10027 GOVD_LASTPRIVATE
10028 | GOVD_SEEN);
10029 else
10030 outer = NULL;
10032 if (outer && outer->outer_context
10033 && (outer->outer_context->region_type
10034 == ORT_COMBINED_TEAMS))
10036 outer = outer->outer_context;
10037 n = splay_tree_lookup (outer->variables,
10038 (splay_tree_key)decl);
10039 if (n == NULL
10040 || (n->value & GOVD_DATA_SHARE_CLASS) == 0)
10041 omp_add_variable (outer, decl,
10042 GOVD_SHARED | GOVD_SEEN);
10043 else
10044 outer = NULL;
10046 if (outer && outer->outer_context)
10047 omp_notice_variable (outer->outer_context, decl,
10048 true);
10053 c = build_omp_clause (input_location,
10054 lastprivate ? OMP_CLAUSE_LASTPRIVATE
10055 : OMP_CLAUSE_PRIVATE);
10056 OMP_CLAUSE_DECL (c) = decl;
10057 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (for_stmt);
10058 OMP_FOR_CLAUSES (for_stmt) = c;
10059 omp_add_variable (gimplify_omp_ctxp, decl,
10060 (lastprivate ? GOVD_LASTPRIVATE : GOVD_PRIVATE)
10061 | GOVD_EXPLICIT | GOVD_SEEN);
10062 c = NULL_TREE;
10065 else if (omp_is_private (gimplify_omp_ctxp, decl, 0))
10066 omp_notice_variable (gimplify_omp_ctxp, decl, true);
10067 else
10068 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
10070 /* If DECL is not a gimple register, create a temporary variable to act
10071 as an iteration counter. This is valid, since DECL cannot be
10072 modified in the body of the loop. Similarly for any iteration vars
10073 in simd with collapse > 1 where the iterator vars must be
10074 lastprivate. */
10075 if (orig_for_stmt != for_stmt)
10076 var = decl;
10077 else if (!is_gimple_reg (decl)
10078 || (ort == ORT_SIMD
10079 && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) > 1))
10081 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
10082 /* Make sure omp_add_variable is not called on it prematurely.
10083 We call it ourselves a few lines later. */
10084 gimplify_omp_ctxp = NULL;
10085 var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
10086 gimplify_omp_ctxp = ctx;
10087 TREE_OPERAND (t, 0) = var;
10089 gimplify_seq_add_stmt (&for_body, gimple_build_assign (decl, var));
10091 if (ort == ORT_SIMD
10092 && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) == 1)
10094 c2 = build_omp_clause (input_location, OMP_CLAUSE_LINEAR);
10095 OMP_CLAUSE_LINEAR_NO_COPYIN (c2) = 1;
10096 OMP_CLAUSE_LINEAR_NO_COPYOUT (c2) = 1;
10097 OMP_CLAUSE_DECL (c2) = var;
10098 OMP_CLAUSE_CHAIN (c2) = OMP_FOR_CLAUSES (for_stmt);
10099 OMP_FOR_CLAUSES (for_stmt) = c2;
10100 omp_add_variable (gimplify_omp_ctxp, var,
10101 GOVD_LINEAR | GOVD_EXPLICIT | GOVD_SEEN);
10102 if (c == NULL_TREE)
10104 c = c2;
10105 c2 = NULL_TREE;
10108 else
10109 omp_add_variable (gimplify_omp_ctxp, var,
10110 GOVD_PRIVATE | GOVD_SEEN);
10112 else
10113 var = decl;
10115 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
10116 is_gimple_val, fb_rvalue, false);
10117 ret = MIN (ret, tret);
10118 if (ret == GS_ERROR)
10119 return ret;
10121 /* Handle OMP_FOR_COND. */
10122 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
10123 gcc_assert (COMPARISON_CLASS_P (t));
10124 gcc_assert (TREE_OPERAND (t, 0) == decl);
10126 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
10127 is_gimple_val, fb_rvalue, false);
10128 ret = MIN (ret, tret);
10130 /* Handle OMP_FOR_INCR. */
10131 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
10132 switch (TREE_CODE (t))
10134 case PREINCREMENT_EXPR:
10135 case POSTINCREMENT_EXPR:
10137 tree decl = TREE_OPERAND (t, 0);
10138 /* c_omp_for_incr_canonicalize_ptr() should have been
10139 called to massage things appropriately. */
10140 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl)));
10142 if (orig_for_stmt != for_stmt)
10143 break;
10144 t = build_int_cst (TREE_TYPE (decl), 1);
10145 if (c)
10146 OMP_CLAUSE_LINEAR_STEP (c) = t;
10147 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
10148 t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
10149 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
10150 break;
10153 case PREDECREMENT_EXPR:
10154 case POSTDECREMENT_EXPR:
10155 /* c_omp_for_incr_canonicalize_ptr() should have been
10156 called to massage things appropriately. */
10157 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl)));
10158 if (orig_for_stmt != for_stmt)
10159 break;
10160 t = build_int_cst (TREE_TYPE (decl), -1);
10161 if (c)
10162 OMP_CLAUSE_LINEAR_STEP (c) = t;
10163 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
10164 t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
10165 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
10166 break;
10168 case MODIFY_EXPR:
10169 gcc_assert (TREE_OPERAND (t, 0) == decl);
10170 TREE_OPERAND (t, 0) = var;
10172 t = TREE_OPERAND (t, 1);
10173 switch (TREE_CODE (t))
10175 case PLUS_EXPR:
10176 if (TREE_OPERAND (t, 1) == decl)
10178 TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
10179 TREE_OPERAND (t, 0) = var;
10180 break;
10183 /* Fallthru. */
10184 case MINUS_EXPR:
10185 case POINTER_PLUS_EXPR:
10186 gcc_assert (TREE_OPERAND (t, 0) == decl);
10187 TREE_OPERAND (t, 0) = var;
10188 break;
10189 default:
10190 gcc_unreachable ();
10193 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
10194 is_gimple_val, fb_rvalue, false);
10195 ret = MIN (ret, tret);
10196 if (c)
10198 tree step = TREE_OPERAND (t, 1);
10199 tree stept = TREE_TYPE (decl);
10200 if (POINTER_TYPE_P (stept))
10201 stept = sizetype;
10202 step = fold_convert (stept, step);
10203 if (TREE_CODE (t) == MINUS_EXPR)
10204 step = fold_build1 (NEGATE_EXPR, stept, step);
10205 OMP_CLAUSE_LINEAR_STEP (c) = step;
10206 if (step != TREE_OPERAND (t, 1))
10208 tret = gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c),
10209 &for_pre_body, NULL,
10210 is_gimple_val, fb_rvalue, false);
10211 ret = MIN (ret, tret);
10214 break;
10216 default:
10217 gcc_unreachable ();
10220 if (c2)
10222 gcc_assert (c);
10223 OMP_CLAUSE_LINEAR_STEP (c2) = OMP_CLAUSE_LINEAR_STEP (c);
10226 if ((var != decl || collapse > 1 || tile) && orig_for_stmt == for_stmt)
10228 for (c = OMP_FOR_CLAUSES (for_stmt); c ; c = OMP_CLAUSE_CHAIN (c))
10229 if (((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
10230 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c) == NULL)
10231 || (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
10232 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c)
10233 && OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c) == NULL))
10234 && OMP_CLAUSE_DECL (c) == decl)
10236 if (is_doacross && (collapse == 1 || i >= collapse))
10237 t = var;
10238 else
10240 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
10241 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
10242 gcc_assert (TREE_OPERAND (t, 0) == var);
10243 t = TREE_OPERAND (t, 1);
10244 gcc_assert (TREE_CODE (t) == PLUS_EXPR
10245 || TREE_CODE (t) == MINUS_EXPR
10246 || TREE_CODE (t) == POINTER_PLUS_EXPR);
10247 gcc_assert (TREE_OPERAND (t, 0) == var);
10248 t = build2 (TREE_CODE (t), TREE_TYPE (decl),
10249 is_doacross ? var : decl,
10250 TREE_OPERAND (t, 1));
10252 gimple_seq *seq;
10253 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
10254 seq = &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c);
10255 else
10256 seq = &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c);
10257 gimplify_assign (decl, t, seq);
10262 BITMAP_FREE (has_decl_expr);
10264 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
10266 push_gimplify_context ();
10267 if (TREE_CODE (OMP_FOR_BODY (orig_for_stmt)) != BIND_EXPR)
10269 OMP_FOR_BODY (orig_for_stmt)
10270 = build3 (BIND_EXPR, void_type_node, NULL,
10271 OMP_FOR_BODY (orig_for_stmt), NULL);
10272 TREE_SIDE_EFFECTS (OMP_FOR_BODY (orig_for_stmt)) = 1;
10276 gimple *g = gimplify_and_return_first (OMP_FOR_BODY (orig_for_stmt),
10277 &for_body);
10279 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
10281 if (gimple_code (g) == GIMPLE_BIND)
10282 pop_gimplify_context (g);
10283 else
10284 pop_gimplify_context (NULL);
10287 if (orig_for_stmt != for_stmt)
10288 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
10290 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
10291 decl = TREE_OPERAND (t, 0);
10292 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
10293 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
10294 gimplify_omp_ctxp = ctx->outer_context;
10295 var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
10296 gimplify_omp_ctxp = ctx;
10297 omp_add_variable (gimplify_omp_ctxp, var, GOVD_PRIVATE | GOVD_SEEN);
10298 TREE_OPERAND (t, 0) = var;
10299 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
10300 TREE_OPERAND (t, 1) = copy_node (TREE_OPERAND (t, 1));
10301 TREE_OPERAND (TREE_OPERAND (t, 1), 0) = var;
10304 gimplify_adjust_omp_clauses (pre_p, for_body,
10305 &OMP_FOR_CLAUSES (orig_for_stmt),
10306 TREE_CODE (orig_for_stmt));
10308 int kind;
10309 switch (TREE_CODE (orig_for_stmt))
10311 case OMP_FOR: kind = GF_OMP_FOR_KIND_FOR; break;
10312 case OMP_SIMD: kind = GF_OMP_FOR_KIND_SIMD; break;
10313 case OMP_DISTRIBUTE: kind = GF_OMP_FOR_KIND_DISTRIBUTE; break;
10314 case OMP_TASKLOOP: kind = GF_OMP_FOR_KIND_TASKLOOP; break;
10315 case OACC_LOOP: kind = GF_OMP_FOR_KIND_OACC_LOOP; break;
10316 default:
10317 gcc_unreachable ();
10319 gfor = gimple_build_omp_for (for_body, kind, OMP_FOR_CLAUSES (orig_for_stmt),
10320 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)),
10321 for_pre_body);
10322 if (orig_for_stmt != for_stmt)
10323 gimple_omp_for_set_combined_p (gfor, true);
10324 if (gimplify_omp_ctxp
10325 && (gimplify_omp_ctxp->combined_loop
10326 || (gimplify_omp_ctxp->region_type == ORT_COMBINED_PARALLEL
10327 && gimplify_omp_ctxp->outer_context
10328 && gimplify_omp_ctxp->outer_context->combined_loop)))
10330 gimple_omp_for_set_combined_into_p (gfor, true);
10331 if (gimplify_omp_ctxp->combined_loop)
10332 gcc_assert (TREE_CODE (orig_for_stmt) == OMP_SIMD);
10333 else
10334 gcc_assert (TREE_CODE (orig_for_stmt) == OMP_FOR);
10337 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
10339 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
10340 gimple_omp_for_set_index (gfor, i, TREE_OPERAND (t, 0));
10341 gimple_omp_for_set_initial (gfor, i, TREE_OPERAND (t, 1));
10342 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
10343 gimple_omp_for_set_cond (gfor, i, TREE_CODE (t));
10344 gimple_omp_for_set_final (gfor, i, TREE_OPERAND (t, 1));
10345 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
10346 gimple_omp_for_set_incr (gfor, i, TREE_OPERAND (t, 1));
10349 /* OMP_TASKLOOP is gimplified as two GIMPLE_OMP_FOR taskloop
10350 constructs with GIMPLE_OMP_TASK sandwiched in between them.
10351 The outer taskloop stands for computing the number of iterations,
10352 counts for collapsed loops and holding taskloop specific clauses.
10353 The task construct stands for the effect of data sharing on the
10354 explicit task it creates and the inner taskloop stands for expansion
10355 of the static loop inside of the explicit task construct. */
10356 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
10358 tree *gfor_clauses_ptr = gimple_omp_for_clauses_ptr (gfor);
10359 tree task_clauses = NULL_TREE;
10360 tree c = *gfor_clauses_ptr;
10361 tree *gtask_clauses_ptr = &task_clauses;
10362 tree outer_for_clauses = NULL_TREE;
10363 tree *gforo_clauses_ptr = &outer_for_clauses;
10364 for (; c; c = OMP_CLAUSE_CHAIN (c))
10365 switch (OMP_CLAUSE_CODE (c))
10367 /* These clauses are allowed on task, move them there. */
10368 case OMP_CLAUSE_SHARED:
10369 case OMP_CLAUSE_FIRSTPRIVATE:
10370 case OMP_CLAUSE_DEFAULT:
10371 case OMP_CLAUSE_IF:
10372 case OMP_CLAUSE_UNTIED:
10373 case OMP_CLAUSE_FINAL:
10374 case OMP_CLAUSE_MERGEABLE:
10375 case OMP_CLAUSE_PRIORITY:
10376 *gtask_clauses_ptr = c;
10377 gtask_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
10378 break;
10379 case OMP_CLAUSE_PRIVATE:
10380 if (OMP_CLAUSE_PRIVATE_TASKLOOP_IV (c))
10382 /* We want private on outer for and firstprivate
10383 on task. */
10384 *gtask_clauses_ptr
10385 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
10386 OMP_CLAUSE_FIRSTPRIVATE);
10387 OMP_CLAUSE_DECL (*gtask_clauses_ptr) = OMP_CLAUSE_DECL (c);
10388 lang_hooks.decls.omp_finish_clause (*gtask_clauses_ptr, NULL);
10389 gtask_clauses_ptr = &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr);
10390 *gforo_clauses_ptr = c;
10391 gforo_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
10393 else
10395 *gtask_clauses_ptr = c;
10396 gtask_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
10398 break;
10399 /* These clauses go into outer taskloop clauses. */
10400 case OMP_CLAUSE_GRAINSIZE:
10401 case OMP_CLAUSE_NUM_TASKS:
10402 case OMP_CLAUSE_NOGROUP:
10403 *gforo_clauses_ptr = c;
10404 gforo_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
10405 break;
10406 /* Taskloop clause we duplicate on both taskloops. */
10407 case OMP_CLAUSE_COLLAPSE:
10408 *gfor_clauses_ptr = c;
10409 gfor_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
10410 *gforo_clauses_ptr = copy_node (c);
10411 gforo_clauses_ptr = &OMP_CLAUSE_CHAIN (*gforo_clauses_ptr);
10412 break;
10413 /* For lastprivate, keep the clause on inner taskloop, and add
10414 a shared clause on task. If the same decl is also firstprivate,
10415 add also firstprivate clause on the inner taskloop. */
10416 case OMP_CLAUSE_LASTPRIVATE:
10417 if (OMP_CLAUSE_LASTPRIVATE_TASKLOOP_IV (c))
10419 /* For taskloop C++ lastprivate IVs, we want:
10420 1) private on outer taskloop
10421 2) firstprivate and shared on task
10422 3) lastprivate on inner taskloop */
10423 *gtask_clauses_ptr
10424 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
10425 OMP_CLAUSE_FIRSTPRIVATE);
10426 OMP_CLAUSE_DECL (*gtask_clauses_ptr) = OMP_CLAUSE_DECL (c);
10427 lang_hooks.decls.omp_finish_clause (*gtask_clauses_ptr, NULL);
10428 gtask_clauses_ptr = &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr);
10429 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c) = 1;
10430 *gforo_clauses_ptr = build_omp_clause (OMP_CLAUSE_LOCATION (c),
10431 OMP_CLAUSE_PRIVATE);
10432 OMP_CLAUSE_DECL (*gforo_clauses_ptr) = OMP_CLAUSE_DECL (c);
10433 OMP_CLAUSE_PRIVATE_TASKLOOP_IV (*gforo_clauses_ptr) = 1;
10434 TREE_TYPE (*gforo_clauses_ptr) = TREE_TYPE (c);
10435 gforo_clauses_ptr = &OMP_CLAUSE_CHAIN (*gforo_clauses_ptr);
10437 *gfor_clauses_ptr = c;
10438 gfor_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
10439 *gtask_clauses_ptr
10440 = build_omp_clause (OMP_CLAUSE_LOCATION (c), OMP_CLAUSE_SHARED);
10441 OMP_CLAUSE_DECL (*gtask_clauses_ptr) = OMP_CLAUSE_DECL (c);
10442 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c))
10443 OMP_CLAUSE_SHARED_FIRSTPRIVATE (*gtask_clauses_ptr) = 1;
10444 gtask_clauses_ptr
10445 = &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr);
10446 break;
10447 default:
10448 gcc_unreachable ();
10450 *gfor_clauses_ptr = NULL_TREE;
10451 *gtask_clauses_ptr = NULL_TREE;
10452 *gforo_clauses_ptr = NULL_TREE;
10453 g = gimple_build_bind (NULL_TREE, gfor, NULL_TREE);
10454 g = gimple_build_omp_task (g, task_clauses, NULL_TREE, NULL_TREE,
10455 NULL_TREE, NULL_TREE, NULL_TREE);
10456 gimple_omp_task_set_taskloop_p (g, true);
10457 g = gimple_build_bind (NULL_TREE, g, NULL_TREE);
10458 gomp_for *gforo
10459 = gimple_build_omp_for (g, GF_OMP_FOR_KIND_TASKLOOP, outer_for_clauses,
10460 gimple_omp_for_collapse (gfor),
10461 gimple_omp_for_pre_body (gfor));
10462 gimple_omp_for_set_pre_body (gfor, NULL);
10463 gimple_omp_for_set_combined_p (gforo, true);
10464 gimple_omp_for_set_combined_into_p (gfor, true);
10465 for (i = 0; i < (int) gimple_omp_for_collapse (gfor); i++)
10467 tree type = TREE_TYPE (gimple_omp_for_index (gfor, i));
10468 tree v = create_tmp_var (type);
10469 gimple_omp_for_set_index (gforo, i, v);
10470 t = unshare_expr (gimple_omp_for_initial (gfor, i));
10471 gimple_omp_for_set_initial (gforo, i, t);
10472 gimple_omp_for_set_cond (gforo, i,
10473 gimple_omp_for_cond (gfor, i));
10474 t = unshare_expr (gimple_omp_for_final (gfor, i));
10475 gimple_omp_for_set_final (gforo, i, t);
10476 t = unshare_expr (gimple_omp_for_incr (gfor, i));
10477 gcc_assert (TREE_OPERAND (t, 0) == gimple_omp_for_index (gfor, i));
10478 TREE_OPERAND (t, 0) = v;
10479 gimple_omp_for_set_incr (gforo, i, t);
10480 t = build_omp_clause (input_location, OMP_CLAUSE_PRIVATE);
10481 OMP_CLAUSE_DECL (t) = v;
10482 OMP_CLAUSE_CHAIN (t) = gimple_omp_for_clauses (gforo);
10483 gimple_omp_for_set_clauses (gforo, t);
10485 gimplify_seq_add_stmt (pre_p, gforo);
10487 else
10488 gimplify_seq_add_stmt (pre_p, gfor);
10489 if (ret != GS_ALL_DONE)
10490 return GS_ERROR;
10491 *expr_p = NULL_TREE;
10492 return GS_ALL_DONE;
10495 /* Helper function of optimize_target_teams, find OMP_TEAMS inside
10496 of OMP_TARGET's body. */
10498 static tree
10499 find_omp_teams (tree *tp, int *walk_subtrees, void *)
10501 *walk_subtrees = 0;
10502 switch (TREE_CODE (*tp))
10504 case OMP_TEAMS:
10505 return *tp;
10506 case BIND_EXPR:
10507 case STATEMENT_LIST:
10508 *walk_subtrees = 1;
10509 break;
10510 default:
10511 break;
10513 return NULL_TREE;
10516 /* Helper function of optimize_target_teams, determine if the expression
10517 can be computed safely before the target construct on the host. */
10519 static tree
10520 computable_teams_clause (tree *tp, int *walk_subtrees, void *)
10522 splay_tree_node n;
10524 if (TYPE_P (*tp))
10526 *walk_subtrees = 0;
10527 return NULL_TREE;
10529 switch (TREE_CODE (*tp))
10531 case VAR_DECL:
10532 case PARM_DECL:
10533 case RESULT_DECL:
10534 *walk_subtrees = 0;
10535 if (error_operand_p (*tp)
10536 || !INTEGRAL_TYPE_P (TREE_TYPE (*tp))
10537 || DECL_HAS_VALUE_EXPR_P (*tp)
10538 || DECL_THREAD_LOCAL_P (*tp)
10539 || TREE_SIDE_EFFECTS (*tp)
10540 || TREE_THIS_VOLATILE (*tp))
10541 return *tp;
10542 if (is_global_var (*tp)
10543 && (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (*tp))
10544 || lookup_attribute ("omp declare target link",
10545 DECL_ATTRIBUTES (*tp))))
10546 return *tp;
10547 if (VAR_P (*tp)
10548 && !DECL_SEEN_IN_BIND_EXPR_P (*tp)
10549 && !is_global_var (*tp)
10550 && decl_function_context (*tp) == current_function_decl)
10551 return *tp;
10552 n = splay_tree_lookup (gimplify_omp_ctxp->variables,
10553 (splay_tree_key) *tp);
10554 if (n == NULL)
10556 if (gimplify_omp_ctxp->target_map_scalars_firstprivate)
10557 return NULL_TREE;
10558 return *tp;
10560 else if (n->value & GOVD_LOCAL)
10561 return *tp;
10562 else if (n->value & GOVD_FIRSTPRIVATE)
10563 return NULL_TREE;
10564 else if ((n->value & (GOVD_MAP | GOVD_MAP_ALWAYS_TO))
10565 == (GOVD_MAP | GOVD_MAP_ALWAYS_TO))
10566 return NULL_TREE;
10567 return *tp;
10568 case INTEGER_CST:
10569 if (!INTEGRAL_TYPE_P (TREE_TYPE (*tp)))
10570 return *tp;
10571 return NULL_TREE;
10572 case TARGET_EXPR:
10573 if (TARGET_EXPR_INITIAL (*tp)
10574 || TREE_CODE (TARGET_EXPR_SLOT (*tp)) != VAR_DECL)
10575 return *tp;
10576 return computable_teams_clause (&TARGET_EXPR_SLOT (*tp),
10577 walk_subtrees, NULL);
10578 /* Allow some reasonable subset of integral arithmetics. */
10579 case PLUS_EXPR:
10580 case MINUS_EXPR:
10581 case MULT_EXPR:
10582 case TRUNC_DIV_EXPR:
10583 case CEIL_DIV_EXPR:
10584 case FLOOR_DIV_EXPR:
10585 case ROUND_DIV_EXPR:
10586 case TRUNC_MOD_EXPR:
10587 case CEIL_MOD_EXPR:
10588 case FLOOR_MOD_EXPR:
10589 case ROUND_MOD_EXPR:
10590 case RDIV_EXPR:
10591 case EXACT_DIV_EXPR:
10592 case MIN_EXPR:
10593 case MAX_EXPR:
10594 case LSHIFT_EXPR:
10595 case RSHIFT_EXPR:
10596 case BIT_IOR_EXPR:
10597 case BIT_XOR_EXPR:
10598 case BIT_AND_EXPR:
10599 case NEGATE_EXPR:
10600 case ABS_EXPR:
10601 case BIT_NOT_EXPR:
10602 case NON_LVALUE_EXPR:
10603 CASE_CONVERT:
10604 if (!INTEGRAL_TYPE_P (TREE_TYPE (*tp)))
10605 return *tp;
10606 return NULL_TREE;
10607 /* And disallow anything else, except for comparisons. */
10608 default:
10609 if (COMPARISON_CLASS_P (*tp))
10610 return NULL_TREE;
10611 return *tp;
10615 /* Try to determine if the num_teams and/or thread_limit expressions
10616 can have their values determined already before entering the
10617 target construct.
10618 INTEGER_CSTs trivially are,
10619 integral decls that are firstprivate (explicitly or implicitly)
10620 or explicitly map(always, to:) or map(always, tofrom:) on the target
10621 region too, and expressions involving simple arithmetics on those
10622 too, function calls are not ok, dereferencing something neither etc.
10623 Add NUM_TEAMS and THREAD_LIMIT clauses to the OMP_CLAUSES of
10624 EXPR based on what we find:
10625 0 stands for clause not specified at all, use implementation default
10626 -1 stands for value that can't be determined easily before entering
10627 the target construct.
10628 If teams construct is not present at all, use 1 for num_teams
10629 and 0 for thread_limit (only one team is involved, and the thread
10630 limit is implementation defined. */
10632 static void
10633 optimize_target_teams (tree target, gimple_seq *pre_p)
10635 tree body = OMP_BODY (target);
10636 tree teams = walk_tree (&body, find_omp_teams, NULL, NULL);
10637 tree num_teams = integer_zero_node;
10638 tree thread_limit = integer_zero_node;
10639 location_t num_teams_loc = EXPR_LOCATION (target);
10640 location_t thread_limit_loc = EXPR_LOCATION (target);
10641 tree c, *p, expr;
10642 struct gimplify_omp_ctx *target_ctx = gimplify_omp_ctxp;
10644 if (teams == NULL_TREE)
10645 num_teams = integer_one_node;
10646 else
10647 for (c = OMP_TEAMS_CLAUSES (teams); c; c = OMP_CLAUSE_CHAIN (c))
10649 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_NUM_TEAMS)
10651 p = &num_teams;
10652 num_teams_loc = OMP_CLAUSE_LOCATION (c);
10654 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_THREAD_LIMIT)
10656 p = &thread_limit;
10657 thread_limit_loc = OMP_CLAUSE_LOCATION (c);
10659 else
10660 continue;
10661 expr = OMP_CLAUSE_OPERAND (c, 0);
10662 if (TREE_CODE (expr) == INTEGER_CST)
10664 *p = expr;
10665 continue;
10667 if (walk_tree (&expr, computable_teams_clause, NULL, NULL))
10669 *p = integer_minus_one_node;
10670 continue;
10672 *p = expr;
10673 gimplify_omp_ctxp = gimplify_omp_ctxp->outer_context;
10674 if (gimplify_expr (p, pre_p, NULL, is_gimple_val, fb_rvalue, false)
10675 == GS_ERROR)
10677 gimplify_omp_ctxp = target_ctx;
10678 *p = integer_minus_one_node;
10679 continue;
10681 gimplify_omp_ctxp = target_ctx;
10682 if (!DECL_P (expr) && TREE_CODE (expr) != TARGET_EXPR)
10683 OMP_CLAUSE_OPERAND (c, 0) = *p;
10685 c = build_omp_clause (thread_limit_loc, OMP_CLAUSE_THREAD_LIMIT);
10686 OMP_CLAUSE_THREAD_LIMIT_EXPR (c) = thread_limit;
10687 OMP_CLAUSE_CHAIN (c) = OMP_TARGET_CLAUSES (target);
10688 OMP_TARGET_CLAUSES (target) = c;
10689 c = build_omp_clause (num_teams_loc, OMP_CLAUSE_NUM_TEAMS);
10690 OMP_CLAUSE_NUM_TEAMS_EXPR (c) = num_teams;
10691 OMP_CLAUSE_CHAIN (c) = OMP_TARGET_CLAUSES (target);
10692 OMP_TARGET_CLAUSES (target) = c;
10695 /* Gimplify the gross structure of several OMP constructs. */
10697 static void
10698 gimplify_omp_workshare (tree *expr_p, gimple_seq *pre_p)
10700 tree expr = *expr_p;
10701 gimple *stmt;
10702 gimple_seq body = NULL;
10703 enum omp_region_type ort;
10705 switch (TREE_CODE (expr))
10707 case OMP_SECTIONS:
10708 case OMP_SINGLE:
10709 ort = ORT_WORKSHARE;
10710 break;
10711 case OMP_TARGET:
10712 ort = OMP_TARGET_COMBINED (expr) ? ORT_COMBINED_TARGET : ORT_TARGET;
10713 break;
10714 case OACC_KERNELS:
10715 ort = ORT_ACC_KERNELS;
10716 break;
10717 case OACC_PARALLEL:
10718 ort = ORT_ACC_PARALLEL;
10719 break;
10720 case OACC_DATA:
10721 ort = ORT_ACC_DATA;
10722 break;
10723 case OMP_TARGET_DATA:
10724 ort = ORT_TARGET_DATA;
10725 break;
10726 case OMP_TEAMS:
10727 ort = OMP_TEAMS_COMBINED (expr) ? ORT_COMBINED_TEAMS : ORT_TEAMS;
10728 break;
10729 case OACC_HOST_DATA:
10730 ort = ORT_ACC_HOST_DATA;
10731 break;
10732 default:
10733 gcc_unreachable ();
10735 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr), pre_p, ort,
10736 TREE_CODE (expr));
10737 if (TREE_CODE (expr) == OMP_TARGET)
10738 optimize_target_teams (expr, pre_p);
10739 if ((ort & (ORT_TARGET | ORT_TARGET_DATA)) != 0)
10741 push_gimplify_context ();
10742 gimple *g = gimplify_and_return_first (OMP_BODY (expr), &body);
10743 if (gimple_code (g) == GIMPLE_BIND)
10744 pop_gimplify_context (g);
10745 else
10746 pop_gimplify_context (NULL);
10747 if ((ort & ORT_TARGET_DATA) != 0)
10749 enum built_in_function end_ix;
10750 switch (TREE_CODE (expr))
10752 case OACC_DATA:
10753 case OACC_HOST_DATA:
10754 end_ix = BUILT_IN_GOACC_DATA_END;
10755 break;
10756 case OMP_TARGET_DATA:
10757 end_ix = BUILT_IN_GOMP_TARGET_END_DATA;
10758 break;
10759 default:
10760 gcc_unreachable ();
10762 tree fn = builtin_decl_explicit (end_ix);
10763 g = gimple_build_call (fn, 0);
10764 gimple_seq cleanup = NULL;
10765 gimple_seq_add_stmt (&cleanup, g);
10766 g = gimple_build_try (body, cleanup, GIMPLE_TRY_FINALLY);
10767 body = NULL;
10768 gimple_seq_add_stmt (&body, g);
10771 else
10772 gimplify_and_add (OMP_BODY (expr), &body);
10773 gimplify_adjust_omp_clauses (pre_p, body, &OMP_CLAUSES (expr),
10774 TREE_CODE (expr));
10776 switch (TREE_CODE (expr))
10778 case OACC_DATA:
10779 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_OACC_DATA,
10780 OMP_CLAUSES (expr));
10781 break;
10782 case OACC_KERNELS:
10783 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_OACC_KERNELS,
10784 OMP_CLAUSES (expr));
10785 break;
10786 case OACC_HOST_DATA:
10787 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_OACC_HOST_DATA,
10788 OMP_CLAUSES (expr));
10789 break;
10790 case OACC_PARALLEL:
10791 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_OACC_PARALLEL,
10792 OMP_CLAUSES (expr));
10793 break;
10794 case OMP_SECTIONS:
10795 stmt = gimple_build_omp_sections (body, OMP_CLAUSES (expr));
10796 break;
10797 case OMP_SINGLE:
10798 stmt = gimple_build_omp_single (body, OMP_CLAUSES (expr));
10799 break;
10800 case OMP_TARGET:
10801 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_REGION,
10802 OMP_CLAUSES (expr));
10803 break;
10804 case OMP_TARGET_DATA:
10805 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_DATA,
10806 OMP_CLAUSES (expr));
10807 break;
10808 case OMP_TEAMS:
10809 stmt = gimple_build_omp_teams (body, OMP_CLAUSES (expr));
10810 break;
10811 default:
10812 gcc_unreachable ();
10815 gimplify_seq_add_stmt (pre_p, stmt);
10816 *expr_p = NULL_TREE;
10819 /* Gimplify the gross structure of OpenACC enter/exit data, update, and OpenMP
10820 target update constructs. */
10822 static void
10823 gimplify_omp_target_update (tree *expr_p, gimple_seq *pre_p)
10825 tree expr = *expr_p;
10826 int kind;
10827 gomp_target *stmt;
10828 enum omp_region_type ort = ORT_WORKSHARE;
10830 switch (TREE_CODE (expr))
10832 case OACC_ENTER_DATA:
10833 case OACC_EXIT_DATA:
10834 kind = GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA;
10835 ort = ORT_ACC;
10836 break;
10837 case OACC_UPDATE:
10838 kind = GF_OMP_TARGET_KIND_OACC_UPDATE;
10839 ort = ORT_ACC;
10840 break;
10841 case OMP_TARGET_UPDATE:
10842 kind = GF_OMP_TARGET_KIND_UPDATE;
10843 break;
10844 case OMP_TARGET_ENTER_DATA:
10845 kind = GF_OMP_TARGET_KIND_ENTER_DATA;
10846 break;
10847 case OMP_TARGET_EXIT_DATA:
10848 kind = GF_OMP_TARGET_KIND_EXIT_DATA;
10849 break;
10850 default:
10851 gcc_unreachable ();
10853 gimplify_scan_omp_clauses (&OMP_STANDALONE_CLAUSES (expr), pre_p,
10854 ort, TREE_CODE (expr));
10855 gimplify_adjust_omp_clauses (pre_p, NULL, &OMP_STANDALONE_CLAUSES (expr),
10856 TREE_CODE (expr));
10857 stmt = gimple_build_omp_target (NULL, kind, OMP_STANDALONE_CLAUSES (expr));
10859 gimplify_seq_add_stmt (pre_p, stmt);
10860 *expr_p = NULL_TREE;
10863 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
10864 stabilized the lhs of the atomic operation as *ADDR. Return true if
10865 EXPR is this stabilized form. */
10867 static bool
10868 goa_lhs_expr_p (tree expr, tree addr)
10870 /* Also include casts to other type variants. The C front end is fond
10871 of adding these for e.g. volatile variables. This is like
10872 STRIP_TYPE_NOPS but includes the main variant lookup. */
10873 STRIP_USELESS_TYPE_CONVERSION (expr);
10875 if (TREE_CODE (expr) == INDIRECT_REF)
10877 expr = TREE_OPERAND (expr, 0);
10878 while (expr != addr
10879 && (CONVERT_EXPR_P (expr)
10880 || TREE_CODE (expr) == NON_LVALUE_EXPR)
10881 && TREE_CODE (expr) == TREE_CODE (addr)
10882 && types_compatible_p (TREE_TYPE (expr), TREE_TYPE (addr)))
10884 expr = TREE_OPERAND (expr, 0);
10885 addr = TREE_OPERAND (addr, 0);
10887 if (expr == addr)
10888 return true;
10889 return (TREE_CODE (addr) == ADDR_EXPR
10890 && TREE_CODE (expr) == ADDR_EXPR
10891 && TREE_OPERAND (addr, 0) == TREE_OPERAND (expr, 0));
10893 if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0))
10894 return true;
10895 return false;
10898 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
10899 expression does not involve the lhs, evaluate it into a temporary.
10900 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
10901 or -1 if an error was encountered. */
10903 static int
10904 goa_stabilize_expr (tree *expr_p, gimple_seq *pre_p, tree lhs_addr,
10905 tree lhs_var)
10907 tree expr = *expr_p;
10908 int saw_lhs;
10910 if (goa_lhs_expr_p (expr, lhs_addr))
10912 *expr_p = lhs_var;
10913 return 1;
10915 if (is_gimple_val (expr))
10916 return 0;
10918 saw_lhs = 0;
10919 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
10921 case tcc_binary:
10922 case tcc_comparison:
10923 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p, lhs_addr,
10924 lhs_var);
10925 /* FALLTHRU */
10926 case tcc_unary:
10927 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p, lhs_addr,
10928 lhs_var);
10929 break;
10930 case tcc_expression:
10931 switch (TREE_CODE (expr))
10933 case TRUTH_ANDIF_EXPR:
10934 case TRUTH_ORIF_EXPR:
10935 case TRUTH_AND_EXPR:
10936 case TRUTH_OR_EXPR:
10937 case TRUTH_XOR_EXPR:
10938 case BIT_INSERT_EXPR:
10939 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
10940 lhs_addr, lhs_var);
10941 /* FALLTHRU */
10942 case TRUTH_NOT_EXPR:
10943 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
10944 lhs_addr, lhs_var);
10945 break;
10946 case COMPOUND_EXPR:
10947 /* Break out any preevaluations from cp_build_modify_expr. */
10948 for (; TREE_CODE (expr) == COMPOUND_EXPR;
10949 expr = TREE_OPERAND (expr, 1))
10950 gimplify_stmt (&TREE_OPERAND (expr, 0), pre_p);
10951 *expr_p = expr;
10952 return goa_stabilize_expr (expr_p, pre_p, lhs_addr, lhs_var);
10953 default:
10954 break;
10956 break;
10957 case tcc_reference:
10958 if (TREE_CODE (expr) == BIT_FIELD_REF)
10959 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
10960 lhs_addr, lhs_var);
10961 break;
10962 default:
10963 break;
10966 if (saw_lhs == 0)
10968 enum gimplify_status gs;
10969 gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue);
10970 if (gs != GS_ALL_DONE)
10971 saw_lhs = -1;
10974 return saw_lhs;
10977 /* Gimplify an OMP_ATOMIC statement. */
10979 static enum gimplify_status
10980 gimplify_omp_atomic (tree *expr_p, gimple_seq *pre_p)
10982 tree addr = TREE_OPERAND (*expr_p, 0);
10983 tree rhs = TREE_CODE (*expr_p) == OMP_ATOMIC_READ
10984 ? NULL : TREE_OPERAND (*expr_p, 1);
10985 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
10986 tree tmp_load;
10987 gomp_atomic_load *loadstmt;
10988 gomp_atomic_store *storestmt;
10990 tmp_load = create_tmp_reg (type);
10991 if (rhs && goa_stabilize_expr (&rhs, pre_p, addr, tmp_load) < 0)
10992 return GS_ERROR;
10994 if (gimplify_expr (&addr, pre_p, NULL, is_gimple_val, fb_rvalue)
10995 != GS_ALL_DONE)
10996 return GS_ERROR;
10998 loadstmt = gimple_build_omp_atomic_load (tmp_load, addr);
10999 gimplify_seq_add_stmt (pre_p, loadstmt);
11000 if (rhs && gimplify_expr (&rhs, pre_p, NULL, is_gimple_val, fb_rvalue)
11001 != GS_ALL_DONE)
11002 return GS_ERROR;
11004 if (TREE_CODE (*expr_p) == OMP_ATOMIC_READ)
11005 rhs = tmp_load;
11006 storestmt = gimple_build_omp_atomic_store (rhs);
11007 gimplify_seq_add_stmt (pre_p, storestmt);
11008 if (OMP_ATOMIC_SEQ_CST (*expr_p))
11010 gimple_omp_atomic_set_seq_cst (loadstmt);
11011 gimple_omp_atomic_set_seq_cst (storestmt);
11013 switch (TREE_CODE (*expr_p))
11015 case OMP_ATOMIC_READ:
11016 case OMP_ATOMIC_CAPTURE_OLD:
11017 *expr_p = tmp_load;
11018 gimple_omp_atomic_set_need_value (loadstmt);
11019 break;
11020 case OMP_ATOMIC_CAPTURE_NEW:
11021 *expr_p = rhs;
11022 gimple_omp_atomic_set_need_value (storestmt);
11023 break;
11024 default:
11025 *expr_p = NULL;
11026 break;
11029 return GS_ALL_DONE;
11032 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
11033 body, and adding some EH bits. */
11035 static enum gimplify_status
11036 gimplify_transaction (tree *expr_p, gimple_seq *pre_p)
11038 tree expr = *expr_p, temp, tbody = TRANSACTION_EXPR_BODY (expr);
11039 gimple *body_stmt;
11040 gtransaction *trans_stmt;
11041 gimple_seq body = NULL;
11042 int subcode = 0;
11044 /* Wrap the transaction body in a BIND_EXPR so we have a context
11045 where to put decls for OMP. */
11046 if (TREE_CODE (tbody) != BIND_EXPR)
11048 tree bind = build3 (BIND_EXPR, void_type_node, NULL, tbody, NULL);
11049 TREE_SIDE_EFFECTS (bind) = 1;
11050 SET_EXPR_LOCATION (bind, EXPR_LOCATION (tbody));
11051 TRANSACTION_EXPR_BODY (expr) = bind;
11054 push_gimplify_context ();
11055 temp = voidify_wrapper_expr (*expr_p, NULL);
11057 body_stmt = gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr), &body);
11058 pop_gimplify_context (body_stmt);
11060 trans_stmt = gimple_build_transaction (body);
11061 if (TRANSACTION_EXPR_OUTER (expr))
11062 subcode = GTMA_IS_OUTER;
11063 else if (TRANSACTION_EXPR_RELAXED (expr))
11064 subcode = GTMA_IS_RELAXED;
11065 gimple_transaction_set_subcode (trans_stmt, subcode);
11067 gimplify_seq_add_stmt (pre_p, trans_stmt);
11069 if (temp)
11071 *expr_p = temp;
11072 return GS_OK;
11075 *expr_p = NULL_TREE;
11076 return GS_ALL_DONE;
11079 /* Gimplify an OMP_ORDERED construct. EXPR is the tree version. BODY
11080 is the OMP_BODY of the original EXPR (which has already been
11081 gimplified so it's not present in the EXPR).
11083 Return the gimplified GIMPLE_OMP_ORDERED tuple. */
11085 static gimple *
11086 gimplify_omp_ordered (tree expr, gimple_seq body)
11088 tree c, decls;
11089 int failures = 0;
11090 unsigned int i;
11091 tree source_c = NULL_TREE;
11092 tree sink_c = NULL_TREE;
11094 if (gimplify_omp_ctxp)
11096 for (c = OMP_ORDERED_CLAUSES (expr); c; c = OMP_CLAUSE_CHAIN (c))
11097 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
11098 && gimplify_omp_ctxp->loop_iter_var.is_empty ()
11099 && (OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SINK
11100 || OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SOURCE))
11102 error_at (OMP_CLAUSE_LOCATION (c),
11103 "%<ordered%> construct with %<depend%> clause must be "
11104 "closely nested inside a loop with %<ordered%> clause "
11105 "with a parameter");
11106 failures++;
11108 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
11109 && OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SINK)
11111 bool fail = false;
11112 for (decls = OMP_CLAUSE_DECL (c), i = 0;
11113 decls && TREE_CODE (decls) == TREE_LIST;
11114 decls = TREE_CHAIN (decls), ++i)
11115 if (i >= gimplify_omp_ctxp->loop_iter_var.length () / 2)
11116 continue;
11117 else if (TREE_VALUE (decls)
11118 != gimplify_omp_ctxp->loop_iter_var[2 * i])
11120 error_at (OMP_CLAUSE_LOCATION (c),
11121 "variable %qE is not an iteration "
11122 "of outermost loop %d, expected %qE",
11123 TREE_VALUE (decls), i + 1,
11124 gimplify_omp_ctxp->loop_iter_var[2 * i]);
11125 fail = true;
11126 failures++;
11128 else
11129 TREE_VALUE (decls)
11130 = gimplify_omp_ctxp->loop_iter_var[2 * i + 1];
11131 if (!fail && i != gimplify_omp_ctxp->loop_iter_var.length () / 2)
11133 error_at (OMP_CLAUSE_LOCATION (c),
11134 "number of variables in %<depend(sink)%> "
11135 "clause does not match number of "
11136 "iteration variables");
11137 failures++;
11139 sink_c = c;
11141 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
11142 && OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SOURCE)
11144 if (source_c)
11146 error_at (OMP_CLAUSE_LOCATION (c),
11147 "more than one %<depend(source)%> clause on an "
11148 "%<ordered%> construct");
11149 failures++;
11151 else
11152 source_c = c;
11155 if (source_c && sink_c)
11157 error_at (OMP_CLAUSE_LOCATION (source_c),
11158 "%<depend(source)%> clause specified together with "
11159 "%<depend(sink:)%> clauses on the same construct");
11160 failures++;
11163 if (failures)
11164 return gimple_build_nop ();
11165 return gimple_build_omp_ordered (body, OMP_ORDERED_CLAUSES (expr));
11168 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
11169 expression produces a value to be used as an operand inside a GIMPLE
11170 statement, the value will be stored back in *EXPR_P. This value will
11171 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
11172 an SSA_NAME. The corresponding sequence of GIMPLE statements is
11173 emitted in PRE_P and POST_P.
11175 Additionally, this process may overwrite parts of the input
11176 expression during gimplification. Ideally, it should be
11177 possible to do non-destructive gimplification.
11179 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
11180 the expression needs to evaluate to a value to be used as
11181 an operand in a GIMPLE statement, this value will be stored in
11182 *EXPR_P on exit. This happens when the caller specifies one
11183 of fb_lvalue or fb_rvalue fallback flags.
11185 PRE_P will contain the sequence of GIMPLE statements corresponding
11186 to the evaluation of EXPR and all the side-effects that must
11187 be executed before the main expression. On exit, the last
11188 statement of PRE_P is the core statement being gimplified. For
11189 instance, when gimplifying 'if (++a)' the last statement in
11190 PRE_P will be 'if (t.1)' where t.1 is the result of
11191 pre-incrementing 'a'.
11193 POST_P will contain the sequence of GIMPLE statements corresponding
11194 to the evaluation of all the side-effects that must be executed
11195 after the main expression. If this is NULL, the post
11196 side-effects are stored at the end of PRE_P.
11198 The reason why the output is split in two is to handle post
11199 side-effects explicitly. In some cases, an expression may have
11200 inner and outer post side-effects which need to be emitted in
11201 an order different from the one given by the recursive
11202 traversal. For instance, for the expression (*p--)++ the post
11203 side-effects of '--' must actually occur *after* the post
11204 side-effects of '++'. However, gimplification will first visit
11205 the inner expression, so if a separate POST sequence was not
11206 used, the resulting sequence would be:
11208 1 t.1 = *p
11209 2 p = p - 1
11210 3 t.2 = t.1 + 1
11211 4 *p = t.2
11213 However, the post-decrement operation in line #2 must not be
11214 evaluated until after the store to *p at line #4, so the
11215 correct sequence should be:
11217 1 t.1 = *p
11218 2 t.2 = t.1 + 1
11219 3 *p = t.2
11220 4 p = p - 1
11222 So, by specifying a separate post queue, it is possible
11223 to emit the post side-effects in the correct order.
11224 If POST_P is NULL, an internal queue will be used. Before
11225 returning to the caller, the sequence POST_P is appended to
11226 the main output sequence PRE_P.
11228 GIMPLE_TEST_F points to a function that takes a tree T and
11229 returns nonzero if T is in the GIMPLE form requested by the
11230 caller. The GIMPLE predicates are in gimple.c.
11232 FALLBACK tells the function what sort of a temporary we want if
11233 gimplification cannot produce an expression that complies with
11234 GIMPLE_TEST_F.
11236 fb_none means that no temporary should be generated
11237 fb_rvalue means that an rvalue is OK to generate
11238 fb_lvalue means that an lvalue is OK to generate
11239 fb_either means that either is OK, but an lvalue is preferable.
11240 fb_mayfail means that gimplification may fail (in which case
11241 GS_ERROR will be returned)
11243 The return value is either GS_ERROR or GS_ALL_DONE, since this
11244 function iterates until EXPR is completely gimplified or an error
11245 occurs. */
11247 enum gimplify_status
11248 gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
11249 bool (*gimple_test_f) (tree), fallback_t fallback)
11251 tree tmp;
11252 gimple_seq internal_pre = NULL;
11253 gimple_seq internal_post = NULL;
11254 tree save_expr;
11255 bool is_statement;
11256 location_t saved_location;
11257 enum gimplify_status ret;
11258 gimple_stmt_iterator pre_last_gsi, post_last_gsi;
11259 tree label;
11261 save_expr = *expr_p;
11262 if (save_expr == NULL_TREE)
11263 return GS_ALL_DONE;
11265 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
11266 is_statement = gimple_test_f == is_gimple_stmt;
11267 if (is_statement)
11268 gcc_assert (pre_p);
11270 /* Consistency checks. */
11271 if (gimple_test_f == is_gimple_reg)
11272 gcc_assert (fallback & (fb_rvalue | fb_lvalue));
11273 else if (gimple_test_f == is_gimple_val
11274 || gimple_test_f == is_gimple_call_addr
11275 || gimple_test_f == is_gimple_condexpr
11276 || gimple_test_f == is_gimple_mem_rhs
11277 || gimple_test_f == is_gimple_mem_rhs_or_call
11278 || gimple_test_f == is_gimple_reg_rhs
11279 || gimple_test_f == is_gimple_reg_rhs_or_call
11280 || gimple_test_f == is_gimple_asm_val
11281 || gimple_test_f == is_gimple_mem_ref_addr)
11282 gcc_assert (fallback & fb_rvalue);
11283 else if (gimple_test_f == is_gimple_min_lval
11284 || gimple_test_f == is_gimple_lvalue)
11285 gcc_assert (fallback & fb_lvalue);
11286 else if (gimple_test_f == is_gimple_addressable)
11287 gcc_assert (fallback & fb_either);
11288 else if (gimple_test_f == is_gimple_stmt)
11289 gcc_assert (fallback == fb_none);
11290 else
11292 /* We should have recognized the GIMPLE_TEST_F predicate to
11293 know what kind of fallback to use in case a temporary is
11294 needed to hold the value or address of *EXPR_P. */
11295 gcc_unreachable ();
11298 /* We used to check the predicate here and return immediately if it
11299 succeeds. This is wrong; the design is for gimplification to be
11300 idempotent, and for the predicates to only test for valid forms, not
11301 whether they are fully simplified. */
11302 if (pre_p == NULL)
11303 pre_p = &internal_pre;
11305 if (post_p == NULL)
11306 post_p = &internal_post;
11308 /* Remember the last statements added to PRE_P and POST_P. Every
11309 new statement added by the gimplification helpers needs to be
11310 annotated with location information. To centralize the
11311 responsibility, we remember the last statement that had been
11312 added to both queues before gimplifying *EXPR_P. If
11313 gimplification produces new statements in PRE_P and POST_P, those
11314 statements will be annotated with the same location information
11315 as *EXPR_P. */
11316 pre_last_gsi = gsi_last (*pre_p);
11317 post_last_gsi = gsi_last (*post_p);
11319 saved_location = input_location;
11320 if (save_expr != error_mark_node
11321 && EXPR_HAS_LOCATION (*expr_p))
11322 input_location = EXPR_LOCATION (*expr_p);
11324 /* Loop over the specific gimplifiers until the toplevel node
11325 remains the same. */
11328 /* Strip away as many useless type conversions as possible
11329 at the toplevel. */
11330 STRIP_USELESS_TYPE_CONVERSION (*expr_p);
11332 /* Remember the expr. */
11333 save_expr = *expr_p;
11335 /* Die, die, die, my darling. */
11336 if (error_operand_p (save_expr))
11338 ret = GS_ERROR;
11339 break;
11342 /* Do any language-specific gimplification. */
11343 ret = ((enum gimplify_status)
11344 lang_hooks.gimplify_expr (expr_p, pre_p, post_p));
11345 if (ret == GS_OK)
11347 if (*expr_p == NULL_TREE)
11348 break;
11349 if (*expr_p != save_expr)
11350 continue;
11352 else if (ret != GS_UNHANDLED)
11353 break;
11355 /* Make sure that all the cases set 'ret' appropriately. */
11356 ret = GS_UNHANDLED;
11357 switch (TREE_CODE (*expr_p))
11359 /* First deal with the special cases. */
11361 case POSTINCREMENT_EXPR:
11362 case POSTDECREMENT_EXPR:
11363 case PREINCREMENT_EXPR:
11364 case PREDECREMENT_EXPR:
11365 ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
11366 fallback != fb_none,
11367 TREE_TYPE (*expr_p));
11368 break;
11370 case VIEW_CONVERT_EXPR:
11371 if (is_gimple_reg_type (TREE_TYPE (*expr_p))
11372 && is_gimple_reg_type (TREE_TYPE (TREE_OPERAND (*expr_p, 0))))
11374 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11375 post_p, is_gimple_val, fb_rvalue);
11376 recalculate_side_effects (*expr_p);
11377 break;
11379 /* Fallthru. */
11381 case ARRAY_REF:
11382 case ARRAY_RANGE_REF:
11383 case REALPART_EXPR:
11384 case IMAGPART_EXPR:
11385 case COMPONENT_REF:
11386 ret = gimplify_compound_lval (expr_p, pre_p, post_p,
11387 fallback ? fallback : fb_rvalue);
11388 break;
11390 case COND_EXPR:
11391 ret = gimplify_cond_expr (expr_p, pre_p, fallback);
11393 /* C99 code may assign to an array in a structure value of a
11394 conditional expression, and this has undefined behavior
11395 only on execution, so create a temporary if an lvalue is
11396 required. */
11397 if (fallback == fb_lvalue)
11399 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p, false);
11400 mark_addressable (*expr_p);
11401 ret = GS_OK;
11403 break;
11405 case CALL_EXPR:
11406 ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
11408 /* C99 code may assign to an array in a structure returned
11409 from a function, and this has undefined behavior only on
11410 execution, so create a temporary if an lvalue is
11411 required. */
11412 if (fallback == fb_lvalue)
11414 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p, false);
11415 mark_addressable (*expr_p);
11416 ret = GS_OK;
11418 break;
11420 case TREE_LIST:
11421 gcc_unreachable ();
11423 case COMPOUND_EXPR:
11424 ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
11425 break;
11427 case COMPOUND_LITERAL_EXPR:
11428 ret = gimplify_compound_literal_expr (expr_p, pre_p,
11429 gimple_test_f, fallback);
11430 break;
11432 case MODIFY_EXPR:
11433 case INIT_EXPR:
11434 ret = gimplify_modify_expr (expr_p, pre_p, post_p,
11435 fallback != fb_none);
11436 break;
11438 case TRUTH_ANDIF_EXPR:
11439 case TRUTH_ORIF_EXPR:
11441 /* Preserve the original type of the expression and the
11442 source location of the outer expression. */
11443 tree org_type = TREE_TYPE (*expr_p);
11444 *expr_p = gimple_boolify (*expr_p);
11445 *expr_p = build3_loc (input_location, COND_EXPR,
11446 org_type, *expr_p,
11447 fold_convert_loc
11448 (input_location,
11449 org_type, boolean_true_node),
11450 fold_convert_loc
11451 (input_location,
11452 org_type, boolean_false_node));
11453 ret = GS_OK;
11454 break;
11457 case TRUTH_NOT_EXPR:
11459 tree type = TREE_TYPE (*expr_p);
11460 /* The parsers are careful to generate TRUTH_NOT_EXPR
11461 only with operands that are always zero or one.
11462 We do not fold here but handle the only interesting case
11463 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
11464 *expr_p = gimple_boolify (*expr_p);
11465 if (TYPE_PRECISION (TREE_TYPE (*expr_p)) == 1)
11466 *expr_p = build1_loc (input_location, BIT_NOT_EXPR,
11467 TREE_TYPE (*expr_p),
11468 TREE_OPERAND (*expr_p, 0));
11469 else
11470 *expr_p = build2_loc (input_location, BIT_XOR_EXPR,
11471 TREE_TYPE (*expr_p),
11472 TREE_OPERAND (*expr_p, 0),
11473 build_int_cst (TREE_TYPE (*expr_p), 1));
11474 if (!useless_type_conversion_p (type, TREE_TYPE (*expr_p)))
11475 *expr_p = fold_convert_loc (input_location, type, *expr_p);
11476 ret = GS_OK;
11477 break;
11480 case ADDR_EXPR:
11481 ret = gimplify_addr_expr (expr_p, pre_p, post_p);
11482 break;
11484 case ANNOTATE_EXPR:
11486 tree cond = TREE_OPERAND (*expr_p, 0);
11487 tree kind = TREE_OPERAND (*expr_p, 1);
11488 tree data = TREE_OPERAND (*expr_p, 2);
11489 tree type = TREE_TYPE (cond);
11490 if (!INTEGRAL_TYPE_P (type))
11492 *expr_p = cond;
11493 ret = GS_OK;
11494 break;
11496 tree tmp = create_tmp_var (type);
11497 gimplify_arg (&cond, pre_p, EXPR_LOCATION (*expr_p));
11498 gcall *call
11499 = gimple_build_call_internal (IFN_ANNOTATE, 3, cond, kind, data);
11500 gimple_call_set_lhs (call, tmp);
11501 gimplify_seq_add_stmt (pre_p, call);
11502 *expr_p = tmp;
11503 ret = GS_ALL_DONE;
11504 break;
11507 case VA_ARG_EXPR:
11508 ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
11509 break;
11511 CASE_CONVERT:
11512 if (IS_EMPTY_STMT (*expr_p))
11514 ret = GS_ALL_DONE;
11515 break;
11518 if (VOID_TYPE_P (TREE_TYPE (*expr_p))
11519 || fallback == fb_none)
11521 /* Just strip a conversion to void (or in void context) and
11522 try again. */
11523 *expr_p = TREE_OPERAND (*expr_p, 0);
11524 ret = GS_OK;
11525 break;
11528 ret = gimplify_conversion (expr_p);
11529 if (ret == GS_ERROR)
11530 break;
11531 if (*expr_p != save_expr)
11532 break;
11533 /* FALLTHRU */
11535 case FIX_TRUNC_EXPR:
11536 /* unary_expr: ... | '(' cast ')' val | ... */
11537 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
11538 is_gimple_val, fb_rvalue);
11539 recalculate_side_effects (*expr_p);
11540 break;
11542 case INDIRECT_REF:
11544 bool volatilep = TREE_THIS_VOLATILE (*expr_p);
11545 bool notrap = TREE_THIS_NOTRAP (*expr_p);
11546 tree saved_ptr_type = TREE_TYPE (TREE_OPERAND (*expr_p, 0));
11548 *expr_p = fold_indirect_ref_loc (input_location, *expr_p);
11549 if (*expr_p != save_expr)
11551 ret = GS_OK;
11552 break;
11555 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
11556 is_gimple_reg, fb_rvalue);
11557 if (ret == GS_ERROR)
11558 break;
11560 recalculate_side_effects (*expr_p);
11561 *expr_p = fold_build2_loc (input_location, MEM_REF,
11562 TREE_TYPE (*expr_p),
11563 TREE_OPERAND (*expr_p, 0),
11564 build_int_cst (saved_ptr_type, 0));
11565 TREE_THIS_VOLATILE (*expr_p) = volatilep;
11566 TREE_THIS_NOTRAP (*expr_p) = notrap;
11567 ret = GS_OK;
11568 break;
11571 /* We arrive here through the various re-gimplifcation paths. */
11572 case MEM_REF:
11573 /* First try re-folding the whole thing. */
11574 tmp = fold_binary (MEM_REF, TREE_TYPE (*expr_p),
11575 TREE_OPERAND (*expr_p, 0),
11576 TREE_OPERAND (*expr_p, 1));
11577 if (tmp)
11579 REF_REVERSE_STORAGE_ORDER (tmp)
11580 = REF_REVERSE_STORAGE_ORDER (*expr_p);
11581 *expr_p = tmp;
11582 recalculate_side_effects (*expr_p);
11583 ret = GS_OK;
11584 break;
11586 /* Avoid re-gimplifying the address operand if it is already
11587 in suitable form. Re-gimplifying would mark the address
11588 operand addressable. Always gimplify when not in SSA form
11589 as we still may have to gimplify decls with value-exprs. */
11590 if (!gimplify_ctxp || !gimple_in_ssa_p (cfun)
11591 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p, 0)))
11593 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
11594 is_gimple_mem_ref_addr, fb_rvalue);
11595 if (ret == GS_ERROR)
11596 break;
11598 recalculate_side_effects (*expr_p);
11599 ret = GS_ALL_DONE;
11600 break;
11602 /* Constants need not be gimplified. */
11603 case INTEGER_CST:
11604 case REAL_CST:
11605 case FIXED_CST:
11606 case STRING_CST:
11607 case COMPLEX_CST:
11608 case VECTOR_CST:
11609 /* Drop the overflow flag on constants, we do not want
11610 that in the GIMPLE IL. */
11611 if (TREE_OVERFLOW_P (*expr_p))
11612 *expr_p = drop_tree_overflow (*expr_p);
11613 ret = GS_ALL_DONE;
11614 break;
11616 case CONST_DECL:
11617 /* If we require an lvalue, such as for ADDR_EXPR, retain the
11618 CONST_DECL node. Otherwise the decl is replaceable by its
11619 value. */
11620 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
11621 if (fallback & fb_lvalue)
11622 ret = GS_ALL_DONE;
11623 else
11625 *expr_p = DECL_INITIAL (*expr_p);
11626 ret = GS_OK;
11628 break;
11630 case DECL_EXPR:
11631 ret = gimplify_decl_expr (expr_p, pre_p);
11632 break;
11634 case BIND_EXPR:
11635 ret = gimplify_bind_expr (expr_p, pre_p);
11636 break;
11638 case LOOP_EXPR:
11639 ret = gimplify_loop_expr (expr_p, pre_p);
11640 break;
11642 case SWITCH_EXPR:
11643 ret = gimplify_switch_expr (expr_p, pre_p);
11644 break;
11646 case EXIT_EXPR:
11647 ret = gimplify_exit_expr (expr_p);
11648 break;
11650 case GOTO_EXPR:
11651 /* If the target is not LABEL, then it is a computed jump
11652 and the target needs to be gimplified. */
11653 if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
11655 ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
11656 NULL, is_gimple_val, fb_rvalue);
11657 if (ret == GS_ERROR)
11658 break;
11660 gimplify_seq_add_stmt (pre_p,
11661 gimple_build_goto (GOTO_DESTINATION (*expr_p)));
11662 ret = GS_ALL_DONE;
11663 break;
11665 case PREDICT_EXPR:
11666 gimplify_seq_add_stmt (pre_p,
11667 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p),
11668 PREDICT_EXPR_OUTCOME (*expr_p)));
11669 ret = GS_ALL_DONE;
11670 break;
11672 case LABEL_EXPR:
11673 ret = gimplify_label_expr (expr_p, pre_p);
11674 label = LABEL_EXPR_LABEL (*expr_p);
11675 gcc_assert (decl_function_context (label) == current_function_decl);
11677 /* If the label is used in a goto statement, or address of the label
11678 is taken, we need to unpoison all variables that were seen so far.
11679 Doing so would prevent us from reporting a false positives. */
11680 if (asan_poisoned_variables
11681 && asan_used_labels != NULL
11682 && asan_used_labels->contains (label))
11683 asan_poison_variables (asan_poisoned_variables, false, pre_p);
11684 break;
11686 case CASE_LABEL_EXPR:
11687 ret = gimplify_case_label_expr (expr_p, pre_p);
11689 if (gimplify_ctxp->live_switch_vars)
11690 asan_poison_variables (gimplify_ctxp->live_switch_vars, false,
11691 pre_p);
11692 break;
11694 case RETURN_EXPR:
11695 ret = gimplify_return_expr (*expr_p, pre_p);
11696 break;
11698 case CONSTRUCTOR:
11699 /* Don't reduce this in place; let gimplify_init_constructor work its
11700 magic. Buf if we're just elaborating this for side effects, just
11701 gimplify any element that has side-effects. */
11702 if (fallback == fb_none)
11704 unsigned HOST_WIDE_INT ix;
11705 tree val;
11706 tree temp = NULL_TREE;
11707 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p), ix, val)
11708 if (TREE_SIDE_EFFECTS (val))
11709 append_to_statement_list (val, &temp);
11711 *expr_p = temp;
11712 ret = temp ? GS_OK : GS_ALL_DONE;
11714 /* C99 code may assign to an array in a constructed
11715 structure or union, and this has undefined behavior only
11716 on execution, so create a temporary if an lvalue is
11717 required. */
11718 else if (fallback == fb_lvalue)
11720 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p, false);
11721 mark_addressable (*expr_p);
11722 ret = GS_OK;
11724 else
11725 ret = GS_ALL_DONE;
11726 break;
11728 /* The following are special cases that are not handled by the
11729 original GIMPLE grammar. */
11731 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
11732 eliminated. */
11733 case SAVE_EXPR:
11734 ret = gimplify_save_expr (expr_p, pre_p, post_p);
11735 break;
11737 case BIT_FIELD_REF:
11738 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11739 post_p, is_gimple_lvalue, fb_either);
11740 recalculate_side_effects (*expr_p);
11741 break;
11743 case TARGET_MEM_REF:
11745 enum gimplify_status r0 = GS_ALL_DONE, r1 = GS_ALL_DONE;
11747 if (TMR_BASE (*expr_p))
11748 r0 = gimplify_expr (&TMR_BASE (*expr_p), pre_p,
11749 post_p, is_gimple_mem_ref_addr, fb_either);
11750 if (TMR_INDEX (*expr_p))
11751 r1 = gimplify_expr (&TMR_INDEX (*expr_p), pre_p,
11752 post_p, is_gimple_val, fb_rvalue);
11753 if (TMR_INDEX2 (*expr_p))
11754 r1 = gimplify_expr (&TMR_INDEX2 (*expr_p), pre_p,
11755 post_p, is_gimple_val, fb_rvalue);
11756 /* TMR_STEP and TMR_OFFSET are always integer constants. */
11757 ret = MIN (r0, r1);
11759 break;
11761 case NON_LVALUE_EXPR:
11762 /* This should have been stripped above. */
11763 gcc_unreachable ();
11765 case ASM_EXPR:
11766 ret = gimplify_asm_expr (expr_p, pre_p, post_p);
11767 break;
11769 case TRY_FINALLY_EXPR:
11770 case TRY_CATCH_EXPR:
11772 gimple_seq eval, cleanup;
11773 gtry *try_;
11775 /* Calls to destructors are generated automatically in FINALLY/CATCH
11776 block. They should have location as UNKNOWN_LOCATION. However,
11777 gimplify_call_expr will reset these call stmts to input_location
11778 if it finds stmt's location is unknown. To prevent resetting for
11779 destructors, we set the input_location to unknown.
11780 Note that this only affects the destructor calls in FINALLY/CATCH
11781 block, and will automatically reset to its original value by the
11782 end of gimplify_expr. */
11783 input_location = UNKNOWN_LOCATION;
11784 eval = cleanup = NULL;
11785 gimplify_and_add (TREE_OPERAND (*expr_p, 0), &eval);
11786 gimplify_and_add (TREE_OPERAND (*expr_p, 1), &cleanup);
11787 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
11788 if (gimple_seq_empty_p (cleanup))
11790 gimple_seq_add_seq (pre_p, eval);
11791 ret = GS_ALL_DONE;
11792 break;
11794 try_ = gimple_build_try (eval, cleanup,
11795 TREE_CODE (*expr_p) == TRY_FINALLY_EXPR
11796 ? GIMPLE_TRY_FINALLY
11797 : GIMPLE_TRY_CATCH);
11798 if (EXPR_HAS_LOCATION (save_expr))
11799 gimple_set_location (try_, EXPR_LOCATION (save_expr));
11800 else if (LOCATION_LOCUS (saved_location) != UNKNOWN_LOCATION)
11801 gimple_set_location (try_, saved_location);
11802 if (TREE_CODE (*expr_p) == TRY_CATCH_EXPR)
11803 gimple_try_set_catch_is_cleanup (try_,
11804 TRY_CATCH_IS_CLEANUP (*expr_p));
11805 gimplify_seq_add_stmt (pre_p, try_);
11806 ret = GS_ALL_DONE;
11807 break;
11810 case CLEANUP_POINT_EXPR:
11811 ret = gimplify_cleanup_point_expr (expr_p, pre_p);
11812 break;
11814 case TARGET_EXPR:
11815 ret = gimplify_target_expr (expr_p, pre_p, post_p);
11816 break;
11818 case CATCH_EXPR:
11820 gimple *c;
11821 gimple_seq handler = NULL;
11822 gimplify_and_add (CATCH_BODY (*expr_p), &handler);
11823 c = gimple_build_catch (CATCH_TYPES (*expr_p), handler);
11824 gimplify_seq_add_stmt (pre_p, c);
11825 ret = GS_ALL_DONE;
11826 break;
11829 case EH_FILTER_EXPR:
11831 gimple *ehf;
11832 gimple_seq failure = NULL;
11834 gimplify_and_add (EH_FILTER_FAILURE (*expr_p), &failure);
11835 ehf = gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p), failure);
11836 gimple_set_no_warning (ehf, TREE_NO_WARNING (*expr_p));
11837 gimplify_seq_add_stmt (pre_p, ehf);
11838 ret = GS_ALL_DONE;
11839 break;
11842 case OBJ_TYPE_REF:
11844 enum gimplify_status r0, r1;
11845 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p,
11846 post_p, is_gimple_val, fb_rvalue);
11847 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p,
11848 post_p, is_gimple_val, fb_rvalue);
11849 TREE_SIDE_EFFECTS (*expr_p) = 0;
11850 ret = MIN (r0, r1);
11852 break;
11854 case LABEL_DECL:
11855 /* We get here when taking the address of a label. We mark
11856 the label as "forced"; meaning it can never be removed and
11857 it is a potential target for any computed goto. */
11858 FORCED_LABEL (*expr_p) = 1;
11859 ret = GS_ALL_DONE;
11860 break;
11862 case STATEMENT_LIST:
11863 ret = gimplify_statement_list (expr_p, pre_p);
11864 break;
11866 case WITH_SIZE_EXPR:
11868 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11869 post_p == &internal_post ? NULL : post_p,
11870 gimple_test_f, fallback);
11871 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
11872 is_gimple_val, fb_rvalue);
11873 ret = GS_ALL_DONE;
11875 break;
11877 case VAR_DECL:
11878 case PARM_DECL:
11879 ret = gimplify_var_or_parm_decl (expr_p);
11880 break;
11882 case RESULT_DECL:
11883 /* When within an OMP context, notice uses of variables. */
11884 if (gimplify_omp_ctxp)
11885 omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
11886 ret = GS_ALL_DONE;
11887 break;
11889 case DEBUG_EXPR_DECL:
11890 gcc_unreachable ();
11892 case DEBUG_BEGIN_STMT:
11893 gimplify_seq_add_stmt (pre_p,
11894 gimple_build_debug_begin_stmt
11895 (TREE_BLOCK (*expr_p),
11896 EXPR_LOCATION (*expr_p)));
11897 ret = GS_ALL_DONE;
11898 *expr_p = NULL;
11899 break;
11901 case SSA_NAME:
11902 /* Allow callbacks into the gimplifier during optimization. */
11903 ret = GS_ALL_DONE;
11904 break;
11906 case OMP_PARALLEL:
11907 gimplify_omp_parallel (expr_p, pre_p);
11908 ret = GS_ALL_DONE;
11909 break;
11911 case OMP_TASK:
11912 gimplify_omp_task (expr_p, pre_p);
11913 ret = GS_ALL_DONE;
11914 break;
11916 case OMP_FOR:
11917 case OMP_SIMD:
11918 case OMP_DISTRIBUTE:
11919 case OMP_TASKLOOP:
11920 case OACC_LOOP:
11921 ret = gimplify_omp_for (expr_p, pre_p);
11922 break;
11924 case OACC_CACHE:
11925 gimplify_oacc_cache (expr_p, pre_p);
11926 ret = GS_ALL_DONE;
11927 break;
11929 case OACC_DECLARE:
11930 gimplify_oacc_declare (expr_p, pre_p);
11931 ret = GS_ALL_DONE;
11932 break;
11934 case OACC_HOST_DATA:
11935 case OACC_DATA:
11936 case OACC_KERNELS:
11937 case OACC_PARALLEL:
11938 case OMP_SECTIONS:
11939 case OMP_SINGLE:
11940 case OMP_TARGET:
11941 case OMP_TARGET_DATA:
11942 case OMP_TEAMS:
11943 gimplify_omp_workshare (expr_p, pre_p);
11944 ret = GS_ALL_DONE;
11945 break;
11947 case OACC_ENTER_DATA:
11948 case OACC_EXIT_DATA:
11949 case OACC_UPDATE:
11950 case OMP_TARGET_UPDATE:
11951 case OMP_TARGET_ENTER_DATA:
11952 case OMP_TARGET_EXIT_DATA:
11953 gimplify_omp_target_update (expr_p, pre_p);
11954 ret = GS_ALL_DONE;
11955 break;
11957 case OMP_SECTION:
11958 case OMP_MASTER:
11959 case OMP_TASKGROUP:
11960 case OMP_ORDERED:
11961 case OMP_CRITICAL:
11963 gimple_seq body = NULL;
11964 gimple *g;
11966 gimplify_and_add (OMP_BODY (*expr_p), &body);
11967 switch (TREE_CODE (*expr_p))
11969 case OMP_SECTION:
11970 g = gimple_build_omp_section (body);
11971 break;
11972 case OMP_MASTER:
11973 g = gimple_build_omp_master (body);
11974 break;
11975 case OMP_TASKGROUP:
11977 gimple_seq cleanup = NULL;
11978 tree fn
11979 = builtin_decl_explicit (BUILT_IN_GOMP_TASKGROUP_END);
11980 g = gimple_build_call (fn, 0);
11981 gimple_seq_add_stmt (&cleanup, g);
11982 g = gimple_build_try (body, cleanup, GIMPLE_TRY_FINALLY);
11983 body = NULL;
11984 gimple_seq_add_stmt (&body, g);
11985 g = gimple_build_omp_taskgroup (body);
11987 break;
11988 case OMP_ORDERED:
11989 g = gimplify_omp_ordered (*expr_p, body);
11990 break;
11991 case OMP_CRITICAL:
11992 gimplify_scan_omp_clauses (&OMP_CRITICAL_CLAUSES (*expr_p),
11993 pre_p, ORT_WORKSHARE, OMP_CRITICAL);
11994 gimplify_adjust_omp_clauses (pre_p, body,
11995 &OMP_CRITICAL_CLAUSES (*expr_p),
11996 OMP_CRITICAL);
11997 g = gimple_build_omp_critical (body,
11998 OMP_CRITICAL_NAME (*expr_p),
11999 OMP_CRITICAL_CLAUSES (*expr_p));
12000 break;
12001 default:
12002 gcc_unreachable ();
12004 gimplify_seq_add_stmt (pre_p, g);
12005 ret = GS_ALL_DONE;
12006 break;
12009 case OMP_ATOMIC:
12010 case OMP_ATOMIC_READ:
12011 case OMP_ATOMIC_CAPTURE_OLD:
12012 case OMP_ATOMIC_CAPTURE_NEW:
12013 ret = gimplify_omp_atomic (expr_p, pre_p);
12014 break;
12016 case TRANSACTION_EXPR:
12017 ret = gimplify_transaction (expr_p, pre_p);
12018 break;
12020 case TRUTH_AND_EXPR:
12021 case TRUTH_OR_EXPR:
12022 case TRUTH_XOR_EXPR:
12024 tree orig_type = TREE_TYPE (*expr_p);
12025 tree new_type, xop0, xop1;
12026 *expr_p = gimple_boolify (*expr_p);
12027 new_type = TREE_TYPE (*expr_p);
12028 if (!useless_type_conversion_p (orig_type, new_type))
12030 *expr_p = fold_convert_loc (input_location, orig_type, *expr_p);
12031 ret = GS_OK;
12032 break;
12035 /* Boolified binary truth expressions are semantically equivalent
12036 to bitwise binary expressions. Canonicalize them to the
12037 bitwise variant. */
12038 switch (TREE_CODE (*expr_p))
12040 case TRUTH_AND_EXPR:
12041 TREE_SET_CODE (*expr_p, BIT_AND_EXPR);
12042 break;
12043 case TRUTH_OR_EXPR:
12044 TREE_SET_CODE (*expr_p, BIT_IOR_EXPR);
12045 break;
12046 case TRUTH_XOR_EXPR:
12047 TREE_SET_CODE (*expr_p, BIT_XOR_EXPR);
12048 break;
12049 default:
12050 break;
12052 /* Now make sure that operands have compatible type to
12053 expression's new_type. */
12054 xop0 = TREE_OPERAND (*expr_p, 0);
12055 xop1 = TREE_OPERAND (*expr_p, 1);
12056 if (!useless_type_conversion_p (new_type, TREE_TYPE (xop0)))
12057 TREE_OPERAND (*expr_p, 0) = fold_convert_loc (input_location,
12058 new_type,
12059 xop0);
12060 if (!useless_type_conversion_p (new_type, TREE_TYPE (xop1)))
12061 TREE_OPERAND (*expr_p, 1) = fold_convert_loc (input_location,
12062 new_type,
12063 xop1);
12064 /* Continue classified as tcc_binary. */
12065 goto expr_2;
12068 case VEC_COND_EXPR:
12070 enum gimplify_status r0, r1, r2;
12072 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
12073 post_p, is_gimple_condexpr, fb_rvalue);
12074 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
12075 post_p, is_gimple_val, fb_rvalue);
12076 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
12077 post_p, is_gimple_val, fb_rvalue);
12079 ret = MIN (MIN (r0, r1), r2);
12080 recalculate_side_effects (*expr_p);
12082 break;
12084 case FMA_EXPR:
12085 case VEC_PERM_EXPR:
12086 /* Classified as tcc_expression. */
12087 goto expr_3;
12089 case BIT_INSERT_EXPR:
12090 /* Argument 3 is a constant. */
12091 goto expr_2;
12093 case POINTER_PLUS_EXPR:
12095 enum gimplify_status r0, r1;
12096 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
12097 post_p, is_gimple_val, fb_rvalue);
12098 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
12099 post_p, is_gimple_val, fb_rvalue);
12100 recalculate_side_effects (*expr_p);
12101 ret = MIN (r0, r1);
12102 break;
12105 default:
12106 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
12108 case tcc_comparison:
12109 /* Handle comparison of objects of non scalar mode aggregates
12110 with a call to memcmp. It would be nice to only have to do
12111 this for variable-sized objects, but then we'd have to allow
12112 the same nest of reference nodes we allow for MODIFY_EXPR and
12113 that's too complex.
12115 Compare scalar mode aggregates as scalar mode values. Using
12116 memcmp for them would be very inefficient at best, and is
12117 plain wrong if bitfields are involved. */
12119 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
12121 /* Vector comparisons need no boolification. */
12122 if (TREE_CODE (type) == VECTOR_TYPE)
12123 goto expr_2;
12124 else if (!AGGREGATE_TYPE_P (type))
12126 tree org_type = TREE_TYPE (*expr_p);
12127 *expr_p = gimple_boolify (*expr_p);
12128 if (!useless_type_conversion_p (org_type,
12129 TREE_TYPE (*expr_p)))
12131 *expr_p = fold_convert_loc (input_location,
12132 org_type, *expr_p);
12133 ret = GS_OK;
12135 else
12136 goto expr_2;
12138 else if (TYPE_MODE (type) != BLKmode)
12139 ret = gimplify_scalar_mode_aggregate_compare (expr_p);
12140 else
12141 ret = gimplify_variable_sized_compare (expr_p);
12143 break;
12146 /* If *EXPR_P does not need to be special-cased, handle it
12147 according to its class. */
12148 case tcc_unary:
12149 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
12150 post_p, is_gimple_val, fb_rvalue);
12151 break;
12153 case tcc_binary:
12154 expr_2:
12156 enum gimplify_status r0, r1;
12158 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
12159 post_p, is_gimple_val, fb_rvalue);
12160 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
12161 post_p, is_gimple_val, fb_rvalue);
12163 ret = MIN (r0, r1);
12164 break;
12167 expr_3:
12169 enum gimplify_status r0, r1, r2;
12171 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
12172 post_p, is_gimple_val, fb_rvalue);
12173 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
12174 post_p, is_gimple_val, fb_rvalue);
12175 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
12176 post_p, is_gimple_val, fb_rvalue);
12178 ret = MIN (MIN (r0, r1), r2);
12179 break;
12182 case tcc_declaration:
12183 case tcc_constant:
12184 ret = GS_ALL_DONE;
12185 goto dont_recalculate;
12187 default:
12188 gcc_unreachable ();
12191 recalculate_side_effects (*expr_p);
12193 dont_recalculate:
12194 break;
12197 gcc_assert (*expr_p || ret != GS_OK);
12199 while (ret == GS_OK);
12201 /* If we encountered an error_mark somewhere nested inside, either
12202 stub out the statement or propagate the error back out. */
12203 if (ret == GS_ERROR)
12205 if (is_statement)
12206 *expr_p = NULL;
12207 goto out;
12210 /* This was only valid as a return value from the langhook, which
12211 we handled. Make sure it doesn't escape from any other context. */
12212 gcc_assert (ret != GS_UNHANDLED);
12214 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
12216 /* We aren't looking for a value, and we don't have a valid
12217 statement. If it doesn't have side-effects, throw it away.
12218 We can also get here with code such as "*&&L;", where L is
12219 a LABEL_DECL that is marked as FORCED_LABEL. */
12220 if (TREE_CODE (*expr_p) == LABEL_DECL
12221 || !TREE_SIDE_EFFECTS (*expr_p))
12222 *expr_p = NULL;
12223 else if (!TREE_THIS_VOLATILE (*expr_p))
12225 /* This is probably a _REF that contains something nested that
12226 has side effects. Recurse through the operands to find it. */
12227 enum tree_code code = TREE_CODE (*expr_p);
12229 switch (code)
12231 case COMPONENT_REF:
12232 case REALPART_EXPR:
12233 case IMAGPART_EXPR:
12234 case VIEW_CONVERT_EXPR:
12235 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
12236 gimple_test_f, fallback);
12237 break;
12239 case ARRAY_REF:
12240 case ARRAY_RANGE_REF:
12241 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
12242 gimple_test_f, fallback);
12243 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
12244 gimple_test_f, fallback);
12245 break;
12247 default:
12248 /* Anything else with side-effects must be converted to
12249 a valid statement before we get here. */
12250 gcc_unreachable ();
12253 *expr_p = NULL;
12255 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p))
12256 && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode)
12258 /* Historically, the compiler has treated a bare reference
12259 to a non-BLKmode volatile lvalue as forcing a load. */
12260 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
12262 /* Normally, we do not want to create a temporary for a
12263 TREE_ADDRESSABLE type because such a type should not be
12264 copied by bitwise-assignment. However, we make an
12265 exception here, as all we are doing here is ensuring that
12266 we read the bytes that make up the type. We use
12267 create_tmp_var_raw because create_tmp_var will abort when
12268 given a TREE_ADDRESSABLE type. */
12269 tree tmp = create_tmp_var_raw (type, "vol");
12270 gimple_add_tmp_var (tmp);
12271 gimplify_assign (tmp, *expr_p, pre_p);
12272 *expr_p = NULL;
12274 else
12275 /* We can't do anything useful with a volatile reference to
12276 an incomplete type, so just throw it away. Likewise for
12277 a BLKmode type, since any implicit inner load should
12278 already have been turned into an explicit one by the
12279 gimplification process. */
12280 *expr_p = NULL;
12283 /* If we are gimplifying at the statement level, we're done. Tack
12284 everything together and return. */
12285 if (fallback == fb_none || is_statement)
12287 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
12288 it out for GC to reclaim it. */
12289 *expr_p = NULL_TREE;
12291 if (!gimple_seq_empty_p (internal_pre)
12292 || !gimple_seq_empty_p (internal_post))
12294 gimplify_seq_add_seq (&internal_pre, internal_post);
12295 gimplify_seq_add_seq (pre_p, internal_pre);
12298 /* The result of gimplifying *EXPR_P is going to be the last few
12299 statements in *PRE_P and *POST_P. Add location information
12300 to all the statements that were added by the gimplification
12301 helpers. */
12302 if (!gimple_seq_empty_p (*pre_p))
12303 annotate_all_with_location_after (*pre_p, pre_last_gsi, input_location);
12305 if (!gimple_seq_empty_p (*post_p))
12306 annotate_all_with_location_after (*post_p, post_last_gsi,
12307 input_location);
12309 goto out;
12312 #ifdef ENABLE_GIMPLE_CHECKING
12313 if (*expr_p)
12315 enum tree_code code = TREE_CODE (*expr_p);
12316 /* These expressions should already be in gimple IR form. */
12317 gcc_assert (code != MODIFY_EXPR
12318 && code != ASM_EXPR
12319 && code != BIND_EXPR
12320 && code != CATCH_EXPR
12321 && (code != COND_EXPR || gimplify_ctxp->allow_rhs_cond_expr)
12322 && code != EH_FILTER_EXPR
12323 && code != GOTO_EXPR
12324 && code != LABEL_EXPR
12325 && code != LOOP_EXPR
12326 && code != SWITCH_EXPR
12327 && code != TRY_FINALLY_EXPR
12328 && code != OACC_PARALLEL
12329 && code != OACC_KERNELS
12330 && code != OACC_DATA
12331 && code != OACC_HOST_DATA
12332 && code != OACC_DECLARE
12333 && code != OACC_UPDATE
12334 && code != OACC_ENTER_DATA
12335 && code != OACC_EXIT_DATA
12336 && code != OACC_CACHE
12337 && code != OMP_CRITICAL
12338 && code != OMP_FOR
12339 && code != OACC_LOOP
12340 && code != OMP_MASTER
12341 && code != OMP_TASKGROUP
12342 && code != OMP_ORDERED
12343 && code != OMP_PARALLEL
12344 && code != OMP_SECTIONS
12345 && code != OMP_SECTION
12346 && code != OMP_SINGLE);
12348 #endif
12350 /* Otherwise we're gimplifying a subexpression, so the resulting
12351 value is interesting. If it's a valid operand that matches
12352 GIMPLE_TEST_F, we're done. Unless we are handling some
12353 post-effects internally; if that's the case, we need to copy into
12354 a temporary before adding the post-effects to POST_P. */
12355 if (gimple_seq_empty_p (internal_post) && (*gimple_test_f) (*expr_p))
12356 goto out;
12358 /* Otherwise, we need to create a new temporary for the gimplified
12359 expression. */
12361 /* We can't return an lvalue if we have an internal postqueue. The
12362 object the lvalue refers to would (probably) be modified by the
12363 postqueue; we need to copy the value out first, which means an
12364 rvalue. */
12365 if ((fallback & fb_lvalue)
12366 && gimple_seq_empty_p (internal_post)
12367 && is_gimple_addressable (*expr_p))
12369 /* An lvalue will do. Take the address of the expression, store it
12370 in a temporary, and replace the expression with an INDIRECT_REF of
12371 that temporary. */
12372 tmp = build_fold_addr_expr_loc (input_location, *expr_p);
12373 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
12374 *expr_p = build_simple_mem_ref (tmp);
12376 else if ((fallback & fb_rvalue) && is_gimple_reg_rhs_or_call (*expr_p))
12378 /* An rvalue will do. Assign the gimplified expression into a
12379 new temporary TMP and replace the original expression with
12380 TMP. First, make sure that the expression has a type so that
12381 it can be assigned into a temporary. */
12382 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
12383 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
12385 else
12387 #ifdef ENABLE_GIMPLE_CHECKING
12388 if (!(fallback & fb_mayfail))
12390 fprintf (stderr, "gimplification failed:\n");
12391 print_generic_expr (stderr, *expr_p);
12392 debug_tree (*expr_p);
12393 internal_error ("gimplification failed");
12395 #endif
12396 gcc_assert (fallback & fb_mayfail);
12398 /* If this is an asm statement, and the user asked for the
12399 impossible, don't die. Fail and let gimplify_asm_expr
12400 issue an error. */
12401 ret = GS_ERROR;
12402 goto out;
12405 /* Make sure the temporary matches our predicate. */
12406 gcc_assert ((*gimple_test_f) (*expr_p));
12408 if (!gimple_seq_empty_p (internal_post))
12410 annotate_all_with_location (internal_post, input_location);
12411 gimplify_seq_add_seq (pre_p, internal_post);
12414 out:
12415 input_location = saved_location;
12416 return ret;
12419 /* Like gimplify_expr but make sure the gimplified result is not itself
12420 a SSA name (but a decl if it were). Temporaries required by
12421 evaluating *EXPR_P may be still SSA names. */
12423 static enum gimplify_status
12424 gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
12425 bool (*gimple_test_f) (tree), fallback_t fallback,
12426 bool allow_ssa)
12428 bool was_ssa_name_p = TREE_CODE (*expr_p) == SSA_NAME;
12429 enum gimplify_status ret = gimplify_expr (expr_p, pre_p, post_p,
12430 gimple_test_f, fallback);
12431 if (! allow_ssa
12432 && TREE_CODE (*expr_p) == SSA_NAME)
12434 tree name = *expr_p;
12435 if (was_ssa_name_p)
12436 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, NULL, false);
12437 else
12439 /* Avoid the extra copy if possible. */
12440 *expr_p = create_tmp_reg (TREE_TYPE (name));
12441 gimple_set_lhs (SSA_NAME_DEF_STMT (name), *expr_p);
12442 release_ssa_name (name);
12445 return ret;
12448 /* Look through TYPE for variable-sized objects and gimplify each such
12449 size that we find. Add to LIST_P any statements generated. */
12451 void
12452 gimplify_type_sizes (tree type, gimple_seq *list_p)
12454 tree field, t;
12456 if (type == NULL || type == error_mark_node)
12457 return;
12459 /* We first do the main variant, then copy into any other variants. */
12460 type = TYPE_MAIN_VARIANT (type);
12462 /* Avoid infinite recursion. */
12463 if (TYPE_SIZES_GIMPLIFIED (type))
12464 return;
12466 TYPE_SIZES_GIMPLIFIED (type) = 1;
12468 switch (TREE_CODE (type))
12470 case INTEGER_TYPE:
12471 case ENUMERAL_TYPE:
12472 case BOOLEAN_TYPE:
12473 case REAL_TYPE:
12474 case FIXED_POINT_TYPE:
12475 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
12476 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
12478 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
12480 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
12481 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
12483 break;
12485 case ARRAY_TYPE:
12486 /* These types may not have declarations, so handle them here. */
12487 gimplify_type_sizes (TREE_TYPE (type), list_p);
12488 gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
12489 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
12490 with assigned stack slots, for -O1+ -g they should be tracked
12491 by VTA. */
12492 if (!(TYPE_NAME (type)
12493 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12494 && DECL_IGNORED_P (TYPE_NAME (type)))
12495 && TYPE_DOMAIN (type)
12496 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type)))
12498 t = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
12499 if (t && VAR_P (t) && DECL_ARTIFICIAL (t))
12500 DECL_IGNORED_P (t) = 0;
12501 t = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
12502 if (t && VAR_P (t) && DECL_ARTIFICIAL (t))
12503 DECL_IGNORED_P (t) = 0;
12505 break;
12507 case RECORD_TYPE:
12508 case UNION_TYPE:
12509 case QUAL_UNION_TYPE:
12510 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
12511 if (TREE_CODE (field) == FIELD_DECL)
12513 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
12514 gimplify_one_sizepos (&DECL_SIZE (field), list_p);
12515 gimplify_one_sizepos (&DECL_SIZE_UNIT (field), list_p);
12516 gimplify_type_sizes (TREE_TYPE (field), list_p);
12518 break;
12520 case POINTER_TYPE:
12521 case REFERENCE_TYPE:
12522 /* We used to recurse on the pointed-to type here, which turned out to
12523 be incorrect because its definition might refer to variables not
12524 yet initialized at this point if a forward declaration is involved.
12526 It was actually useful for anonymous pointed-to types to ensure
12527 that the sizes evaluation dominates every possible later use of the
12528 values. Restricting to such types here would be safe since there
12529 is no possible forward declaration around, but would introduce an
12530 undesirable middle-end semantic to anonymity. We then defer to
12531 front-ends the responsibility of ensuring that the sizes are
12532 evaluated both early and late enough, e.g. by attaching artificial
12533 type declarations to the tree. */
12534 break;
12536 default:
12537 break;
12540 gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
12541 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
12543 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
12545 TYPE_SIZE (t) = TYPE_SIZE (type);
12546 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type);
12547 TYPE_SIZES_GIMPLIFIED (t) = 1;
12551 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
12552 a size or position, has had all of its SAVE_EXPRs evaluated.
12553 We add any required statements to *STMT_P. */
12555 void
12556 gimplify_one_sizepos (tree *expr_p, gimple_seq *stmt_p)
12558 tree expr = *expr_p;
12560 /* We don't do anything if the value isn't there, is constant, or contains
12561 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
12562 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
12563 will want to replace it with a new variable, but that will cause problems
12564 if this type is from outside the function. It's OK to have that here. */
12565 if (is_gimple_sizepos (expr))
12566 return;
12568 *expr_p = unshare_expr (expr);
12570 /* SSA names in decl/type fields are a bad idea - they'll get reclaimed
12571 if the def vanishes. */
12572 gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue, false);
12575 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
12576 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
12577 is true, also gimplify the parameters. */
12579 gbind *
12580 gimplify_body (tree fndecl, bool do_parms)
12582 location_t saved_location = input_location;
12583 gimple_seq parm_stmts, seq;
12584 gimple *outer_stmt;
12585 gbind *outer_bind;
12586 struct cgraph_node *cgn;
12588 timevar_push (TV_TREE_GIMPLIFY);
12590 init_tree_ssa (cfun);
12592 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
12593 gimplification. */
12594 default_rtl_profile ();
12596 gcc_assert (gimplify_ctxp == NULL);
12597 push_gimplify_context (true);
12599 if (flag_openacc || flag_openmp)
12601 gcc_assert (gimplify_omp_ctxp == NULL);
12602 if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (fndecl)))
12603 gimplify_omp_ctxp = new_omp_context (ORT_TARGET);
12606 /* Unshare most shared trees in the body and in that of any nested functions.
12607 It would seem we don't have to do this for nested functions because
12608 they are supposed to be output and then the outer function gimplified
12609 first, but the g++ front end doesn't always do it that way. */
12610 unshare_body (fndecl);
12611 unvisit_body (fndecl);
12613 cgn = cgraph_node::get (fndecl);
12614 if (cgn && cgn->origin)
12615 nonlocal_vlas = new hash_set<tree>;
12617 /* Make sure input_location isn't set to something weird. */
12618 input_location = DECL_SOURCE_LOCATION (fndecl);
12620 /* Resolve callee-copies. This has to be done before processing
12621 the body so that DECL_VALUE_EXPR gets processed correctly. */
12622 parm_stmts = do_parms ? gimplify_parameters () : NULL;
12624 /* Gimplify the function's body. */
12625 seq = NULL;
12626 gimplify_stmt (&DECL_SAVED_TREE (fndecl), &seq);
12627 outer_stmt = gimple_seq_first_stmt (seq);
12628 if (!outer_stmt)
12630 outer_stmt = gimple_build_nop ();
12631 gimplify_seq_add_stmt (&seq, outer_stmt);
12634 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
12635 not the case, wrap everything in a GIMPLE_BIND to make it so. */
12636 if (gimple_code (outer_stmt) == GIMPLE_BIND
12637 && gimple_seq_first (seq) == gimple_seq_last (seq))
12638 outer_bind = as_a <gbind *> (outer_stmt);
12639 else
12640 outer_bind = gimple_build_bind (NULL_TREE, seq, NULL);
12642 DECL_SAVED_TREE (fndecl) = NULL_TREE;
12644 /* If we had callee-copies statements, insert them at the beginning
12645 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
12646 if (!gimple_seq_empty_p (parm_stmts))
12648 tree parm;
12650 gimplify_seq_add_seq (&parm_stmts, gimple_bind_body (outer_bind));
12651 gimple_bind_set_body (outer_bind, parm_stmts);
12653 for (parm = DECL_ARGUMENTS (current_function_decl);
12654 parm; parm = DECL_CHAIN (parm))
12655 if (DECL_HAS_VALUE_EXPR_P (parm))
12657 DECL_HAS_VALUE_EXPR_P (parm) = 0;
12658 DECL_IGNORED_P (parm) = 0;
12662 if (nonlocal_vlas)
12664 if (nonlocal_vla_vars)
12666 /* tree-nested.c may later on call declare_vars (..., true);
12667 which relies on BLOCK_VARS chain to be the tail of the
12668 gimple_bind_vars chain. Ensure we don't violate that
12669 assumption. */
12670 if (gimple_bind_block (outer_bind)
12671 == DECL_INITIAL (current_function_decl))
12672 declare_vars (nonlocal_vla_vars, outer_bind, true);
12673 else
12674 BLOCK_VARS (DECL_INITIAL (current_function_decl))
12675 = chainon (BLOCK_VARS (DECL_INITIAL (current_function_decl)),
12676 nonlocal_vla_vars);
12677 nonlocal_vla_vars = NULL_TREE;
12679 delete nonlocal_vlas;
12680 nonlocal_vlas = NULL;
12683 if ((flag_openacc || flag_openmp || flag_openmp_simd)
12684 && gimplify_omp_ctxp)
12686 delete_omp_context (gimplify_omp_ctxp);
12687 gimplify_omp_ctxp = NULL;
12690 pop_gimplify_context (outer_bind);
12691 gcc_assert (gimplify_ctxp == NULL);
12693 if (flag_checking && !seen_error ())
12694 verify_gimple_in_seq (gimple_bind_body (outer_bind));
12696 timevar_pop (TV_TREE_GIMPLIFY);
12697 input_location = saved_location;
12699 return outer_bind;
12702 typedef char *char_p; /* For DEF_VEC_P. */
12704 /* Return whether we should exclude FNDECL from instrumentation. */
12706 static bool
12707 flag_instrument_functions_exclude_p (tree fndecl)
12709 vec<char_p> *v;
12711 v = (vec<char_p> *) flag_instrument_functions_exclude_functions;
12712 if (v && v->length () > 0)
12714 const char *name;
12715 int i;
12716 char *s;
12718 name = lang_hooks.decl_printable_name (fndecl, 0);
12719 FOR_EACH_VEC_ELT (*v, i, s)
12720 if (strstr (name, s) != NULL)
12721 return true;
12724 v = (vec<char_p> *) flag_instrument_functions_exclude_files;
12725 if (v && v->length () > 0)
12727 const char *name;
12728 int i;
12729 char *s;
12731 name = DECL_SOURCE_FILE (fndecl);
12732 FOR_EACH_VEC_ELT (*v, i, s)
12733 if (strstr (name, s) != NULL)
12734 return true;
12737 return false;
12740 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
12741 node for the function we want to gimplify.
12743 Return the sequence of GIMPLE statements corresponding to the body
12744 of FNDECL. */
12746 void
12747 gimplify_function_tree (tree fndecl)
12749 tree parm, ret;
12750 gimple_seq seq;
12751 gbind *bind;
12753 gcc_assert (!gimple_body (fndecl));
12755 if (DECL_STRUCT_FUNCTION (fndecl))
12756 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
12757 else
12758 push_struct_function (fndecl);
12760 /* Tentatively set PROP_gimple_lva here, and reset it in gimplify_va_arg_expr
12761 if necessary. */
12762 cfun->curr_properties |= PROP_gimple_lva;
12764 for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = DECL_CHAIN (parm))
12766 /* Preliminarily mark non-addressed complex variables as eligible
12767 for promotion to gimple registers. We'll transform their uses
12768 as we find them. */
12769 if ((TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
12770 || TREE_CODE (TREE_TYPE (parm)) == VECTOR_TYPE)
12771 && !TREE_THIS_VOLATILE (parm)
12772 && !needs_to_live_in_memory (parm))
12773 DECL_GIMPLE_REG_P (parm) = 1;
12776 ret = DECL_RESULT (fndecl);
12777 if ((TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE
12778 || TREE_CODE (TREE_TYPE (ret)) == VECTOR_TYPE)
12779 && !needs_to_live_in_memory (ret))
12780 DECL_GIMPLE_REG_P (ret) = 1;
12782 if (asan_sanitize_use_after_scope () && sanitize_flags_p (SANITIZE_ADDRESS))
12783 asan_poisoned_variables = new hash_set<tree> ();
12784 bind = gimplify_body (fndecl, true);
12785 if (asan_poisoned_variables)
12787 delete asan_poisoned_variables;
12788 asan_poisoned_variables = NULL;
12791 /* The tree body of the function is no longer needed, replace it
12792 with the new GIMPLE body. */
12793 seq = NULL;
12794 gimple_seq_add_stmt (&seq, bind);
12795 gimple_set_body (fndecl, seq);
12797 /* If we're instrumenting function entry/exit, then prepend the call to
12798 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
12799 catch the exit hook. */
12800 /* ??? Add some way to ignore exceptions for this TFE. */
12801 if (flag_instrument_function_entry_exit
12802 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl)
12803 /* Do not instrument extern inline functions. */
12804 && !(DECL_DECLARED_INLINE_P (fndecl)
12805 && DECL_EXTERNAL (fndecl)
12806 && DECL_DISREGARD_INLINE_LIMITS (fndecl))
12807 && !flag_instrument_functions_exclude_p (fndecl))
12809 tree x;
12810 gbind *new_bind;
12811 gimple *tf;
12812 gimple_seq cleanup = NULL, body = NULL;
12813 tree tmp_var;
12814 gcall *call;
12816 x = builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS);
12817 call = gimple_build_call (x, 1, integer_zero_node);
12818 tmp_var = create_tmp_var (ptr_type_node, "return_addr");
12819 gimple_call_set_lhs (call, tmp_var);
12820 gimplify_seq_add_stmt (&cleanup, call);
12821 x = builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT);
12822 call = gimple_build_call (x, 2,
12823 build_fold_addr_expr (current_function_decl),
12824 tmp_var);
12825 gimplify_seq_add_stmt (&cleanup, call);
12826 tf = gimple_build_try (seq, cleanup, GIMPLE_TRY_FINALLY);
12828 x = builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS);
12829 call = gimple_build_call (x, 1, integer_zero_node);
12830 tmp_var = create_tmp_var (ptr_type_node, "return_addr");
12831 gimple_call_set_lhs (call, tmp_var);
12832 gimplify_seq_add_stmt (&body, call);
12833 x = builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER);
12834 call = gimple_build_call (x, 2,
12835 build_fold_addr_expr (current_function_decl),
12836 tmp_var);
12837 gimplify_seq_add_stmt (&body, call);
12838 gimplify_seq_add_stmt (&body, tf);
12839 new_bind = gimple_build_bind (NULL, body, NULL);
12841 /* Replace the current function body with the body
12842 wrapped in the try/finally TF. */
12843 seq = NULL;
12844 gimple_seq_add_stmt (&seq, new_bind);
12845 gimple_set_body (fndecl, seq);
12846 bind = new_bind;
12849 if (sanitize_flags_p (SANITIZE_THREAD))
12851 gcall *call = gimple_build_call_internal (IFN_TSAN_FUNC_EXIT, 0);
12852 gimple *tf = gimple_build_try (seq, call, GIMPLE_TRY_FINALLY);
12853 gbind *new_bind = gimple_build_bind (NULL, tf, NULL);
12854 /* Replace the current function body with the body
12855 wrapped in the try/finally TF. */
12856 seq = NULL;
12857 gimple_seq_add_stmt (&seq, new_bind);
12858 gimple_set_body (fndecl, seq);
12861 DECL_SAVED_TREE (fndecl) = NULL_TREE;
12862 cfun->curr_properties |= PROP_gimple_any;
12864 pop_cfun ();
12866 dump_function (TDI_gimple, fndecl);
12869 /* Return a dummy expression of type TYPE in order to keep going after an
12870 error. */
12872 static tree
12873 dummy_object (tree type)
12875 tree t = build_int_cst (build_pointer_type (type), 0);
12876 return build2 (MEM_REF, type, t, t);
12879 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
12880 builtin function, but a very special sort of operator. */
12882 enum gimplify_status
12883 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p,
12884 gimple_seq *post_p ATTRIBUTE_UNUSED)
12886 tree promoted_type, have_va_type;
12887 tree valist = TREE_OPERAND (*expr_p, 0);
12888 tree type = TREE_TYPE (*expr_p);
12889 tree t, tag, aptag;
12890 location_t loc = EXPR_LOCATION (*expr_p);
12892 /* Verify that valist is of the proper type. */
12893 have_va_type = TREE_TYPE (valist);
12894 if (have_va_type == error_mark_node)
12895 return GS_ERROR;
12896 have_va_type = targetm.canonical_va_list_type (have_va_type);
12897 if (have_va_type == NULL_TREE
12898 && POINTER_TYPE_P (TREE_TYPE (valist)))
12899 /* Handle 'Case 1: Not an array type' from c-common.c/build_va_arg. */
12900 have_va_type
12901 = targetm.canonical_va_list_type (TREE_TYPE (TREE_TYPE (valist)));
12902 gcc_assert (have_va_type != NULL_TREE);
12904 /* Generate a diagnostic for requesting data of a type that cannot
12905 be passed through `...' due to type promotion at the call site. */
12906 if ((promoted_type = lang_hooks.types.type_promotes_to (type))
12907 != type)
12909 static bool gave_help;
12910 bool warned;
12911 /* Use the expansion point to handle cases such as passing bool (defined
12912 in a system header) through `...'. */
12913 source_location xloc
12914 = expansion_point_location_if_in_system_header (loc);
12916 /* Unfortunately, this is merely undefined, rather than a constraint
12917 violation, so we cannot make this an error. If this call is never
12918 executed, the program is still strictly conforming. */
12919 warned = warning_at (xloc, 0,
12920 "%qT is promoted to %qT when passed through %<...%>",
12921 type, promoted_type);
12922 if (!gave_help && warned)
12924 gave_help = true;
12925 inform (xloc, "(so you should pass %qT not %qT to %<va_arg%>)",
12926 promoted_type, type);
12929 /* We can, however, treat "undefined" any way we please.
12930 Call abort to encourage the user to fix the program. */
12931 if (warned)
12932 inform (xloc, "if this code is reached, the program will abort");
12933 /* Before the abort, allow the evaluation of the va_list
12934 expression to exit or longjmp. */
12935 gimplify_and_add (valist, pre_p);
12936 t = build_call_expr_loc (loc,
12937 builtin_decl_implicit (BUILT_IN_TRAP), 0);
12938 gimplify_and_add (t, pre_p);
12940 /* This is dead code, but go ahead and finish so that the
12941 mode of the result comes out right. */
12942 *expr_p = dummy_object (type);
12943 return GS_ALL_DONE;
12946 tag = build_int_cst (build_pointer_type (type), 0);
12947 aptag = build_int_cst (TREE_TYPE (valist), 0);
12949 *expr_p = build_call_expr_internal_loc (loc, IFN_VA_ARG, type, 3,
12950 valist, tag, aptag);
12952 /* Clear the tentatively set PROP_gimple_lva, to indicate that IFN_VA_ARG
12953 needs to be expanded. */
12954 cfun->curr_properties &= ~PROP_gimple_lva;
12956 return GS_OK;
12959 /* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
12961 DST/SRC are the destination and source respectively. You can pass
12962 ungimplified trees in DST or SRC, in which case they will be
12963 converted to a gimple operand if necessary.
12965 This function returns the newly created GIMPLE_ASSIGN tuple. */
12967 gimple *
12968 gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
12970 tree t = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
12971 gimplify_and_add (t, seq_p);
12972 ggc_free (t);
12973 return gimple_seq_last_stmt (*seq_p);
12976 inline hashval_t
12977 gimplify_hasher::hash (const elt_t *p)
12979 tree t = p->val;
12980 return iterative_hash_expr (t, 0);
12983 inline bool
12984 gimplify_hasher::equal (const elt_t *p1, const elt_t *p2)
12986 tree t1 = p1->val;
12987 tree t2 = p2->val;
12988 enum tree_code code = TREE_CODE (t1);
12990 if (TREE_CODE (t2) != code
12991 || TREE_TYPE (t1) != TREE_TYPE (t2))
12992 return false;
12994 if (!operand_equal_p (t1, t2, 0))
12995 return false;
12997 /* Only allow them to compare equal if they also hash equal; otherwise
12998 results are nondeterminate, and we fail bootstrap comparison. */
12999 gcc_checking_assert (hash (p1) == hash (p2));
13001 return true;