PR fortran/77973
[official-gcc.git] / gcc / gimplify.c
blob5da1725acd14f79d83e5235accd161be300e7ab0
1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002-2016 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 "gimple.h"
31 #include "gimple-predict.h"
32 #include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
33 #include "ssa.h"
34 #include "cgraph.h"
35 #include "tree-pretty-print.h"
36 #include "diagnostic-core.h"
37 #include "alias.h"
38 #include "fold-const.h"
39 #include "calls.h"
40 #include "varasm.h"
41 #include "stmt.h"
42 #include "expr.h"
43 #include "gimple-fold.h"
44 #include "tree-eh.h"
45 #include "gimplify.h"
46 #include "gimple-iterator.h"
47 #include "stor-layout.h"
48 #include "print-tree.h"
49 #include "tree-iterator.h"
50 #include "tree-inline.h"
51 #include "langhooks.h"
52 #include "tree-cfg.h"
53 #include "tree-ssa.h"
54 #include "omp-low.h"
55 #include "gimple-low.h"
56 #include "cilk.h"
57 #include "gomp-constants.h"
58 #include "tree-dump.h"
59 #include "gimple-walk.h"
60 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
61 #include "builtins.h"
63 enum gimplify_omp_var_data
65 GOVD_SEEN = 1,
66 GOVD_EXPLICIT = 2,
67 GOVD_SHARED = 4,
68 GOVD_PRIVATE = 8,
69 GOVD_FIRSTPRIVATE = 16,
70 GOVD_LASTPRIVATE = 32,
71 GOVD_REDUCTION = 64,
72 GOVD_LOCAL = 128,
73 GOVD_MAP = 256,
74 GOVD_DEBUG_PRIVATE = 512,
75 GOVD_PRIVATE_OUTER_REF = 1024,
76 GOVD_LINEAR = 2048,
77 GOVD_ALIGNED = 4096,
79 /* Flag for GOVD_MAP: don't copy back. */
80 GOVD_MAP_TO_ONLY = 8192,
82 /* Flag for GOVD_LINEAR or GOVD_LASTPRIVATE: no outer reference. */
83 GOVD_LINEAR_LASTPRIVATE_NO_OUTER = 16384,
85 GOVD_MAP_0LEN_ARRAY = 32768,
87 /* Flag for GOVD_MAP, if it is always, to or always, tofrom mapping. */
88 GOVD_MAP_ALWAYS_TO = 65536,
90 /* Flag for shared vars that are or might be stored to in the region. */
91 GOVD_WRITTEN = 131072,
93 /* Flag for GOVD_MAP, if it is a forced mapping. */
94 GOVD_MAP_FORCE = 262144,
96 GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
97 | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LINEAR
98 | GOVD_LOCAL)
102 enum omp_region_type
104 ORT_WORKSHARE = 0x00,
105 ORT_SIMD = 0x01,
107 ORT_PARALLEL = 0x02,
108 ORT_COMBINED_PARALLEL = 0x03,
110 ORT_TASK = 0x04,
111 ORT_UNTIED_TASK = 0x05,
113 ORT_TEAMS = 0x08,
114 ORT_COMBINED_TEAMS = 0x09,
116 /* Data region. */
117 ORT_TARGET_DATA = 0x10,
119 /* Data region with offloading. */
120 ORT_TARGET = 0x20,
121 ORT_COMBINED_TARGET = 0x21,
123 /* OpenACC variants. */
124 ORT_ACC = 0x40, /* A generic OpenACC region. */
125 ORT_ACC_DATA = ORT_ACC | ORT_TARGET_DATA, /* Data construct. */
126 ORT_ACC_PARALLEL = ORT_ACC | ORT_TARGET, /* Parallel construct */
127 ORT_ACC_KERNELS = ORT_ACC | ORT_TARGET | 0x80, /* Kernels construct. */
128 ORT_ACC_HOST_DATA = ORT_ACC | ORT_TARGET_DATA | 0x80, /* Host data. */
130 /* Dummy OpenMP region, used to disable expansion of
131 DECL_VALUE_EXPRs in taskloop pre body. */
132 ORT_NONE = 0x100
135 /* Gimplify hashtable helper. */
137 struct gimplify_hasher : free_ptr_hash <elt_t>
139 static inline hashval_t hash (const elt_t *);
140 static inline bool equal (const elt_t *, const elt_t *);
143 struct gimplify_ctx
145 struct gimplify_ctx *prev_context;
147 vec<gbind *> bind_expr_stack;
148 tree temps;
149 gimple_seq conditional_cleanups;
150 tree exit_label;
151 tree return_temp;
153 vec<tree> case_labels;
154 /* The formal temporary table. Should this be persistent? */
155 hash_table<gimplify_hasher> *temp_htab;
157 int conditions;
158 unsigned into_ssa : 1;
159 unsigned allow_rhs_cond_expr : 1;
160 unsigned in_cleanup_point_expr : 1;
161 unsigned keep_stack : 1;
162 unsigned save_stack : 1;
163 unsigned in_switch_expr : 1;
166 struct gimplify_omp_ctx
168 struct gimplify_omp_ctx *outer_context;
169 splay_tree variables;
170 hash_set<tree> *privatized_types;
171 /* Iteration variables in an OMP_FOR. */
172 vec<tree> loop_iter_var;
173 location_t location;
174 enum omp_clause_default_kind default_kind;
175 enum omp_region_type region_type;
176 bool combined_loop;
177 bool distribute;
178 bool target_map_scalars_firstprivate;
179 bool target_map_pointers_as_0len_arrays;
180 bool target_firstprivatize_array_bases;
183 static struct gimplify_ctx *gimplify_ctxp;
184 static struct gimplify_omp_ctx *gimplify_omp_ctxp;
186 /* Forward declaration. */
187 static enum gimplify_status gimplify_compound_expr (tree *, gimple_seq *, bool);
188 static hash_map<tree, tree> *oacc_declare_returns;
189 static enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *,
190 bool (*) (tree), fallback_t, bool);
192 /* Shorter alias name for the above function for use in gimplify.c
193 only. */
195 static inline void
196 gimplify_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
198 gimple_seq_add_stmt_without_update (seq_p, gs);
201 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
202 NULL, a new sequence is allocated. This function is
203 similar to gimple_seq_add_seq, but does not scan the operands.
204 During gimplification, we need to manipulate statement sequences
205 before the def/use vectors have been constructed. */
207 static void
208 gimplify_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
210 gimple_stmt_iterator si;
212 if (src == NULL)
213 return;
215 si = gsi_last (*dst_p);
216 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
220 /* Pointer to a list of allocated gimplify_ctx structs to be used for pushing
221 and popping gimplify contexts. */
223 static struct gimplify_ctx *ctx_pool = NULL;
225 /* Return a gimplify context struct from the pool. */
227 static inline struct gimplify_ctx *
228 ctx_alloc (void)
230 struct gimplify_ctx * c = ctx_pool;
232 if (c)
233 ctx_pool = c->prev_context;
234 else
235 c = XNEW (struct gimplify_ctx);
237 memset (c, '\0', sizeof (*c));
238 return c;
241 /* Put gimplify context C back into the pool. */
243 static inline void
244 ctx_free (struct gimplify_ctx *c)
246 c->prev_context = ctx_pool;
247 ctx_pool = c;
250 /* Free allocated ctx stack memory. */
252 void
253 free_gimplify_stack (void)
255 struct gimplify_ctx *c;
257 while ((c = ctx_pool))
259 ctx_pool = c->prev_context;
260 free (c);
265 /* Set up a context for the gimplifier. */
267 void
268 push_gimplify_context (bool in_ssa, bool rhs_cond_ok)
270 struct gimplify_ctx *c = ctx_alloc ();
272 c->prev_context = gimplify_ctxp;
273 gimplify_ctxp = c;
274 gimplify_ctxp->into_ssa = in_ssa;
275 gimplify_ctxp->allow_rhs_cond_expr = rhs_cond_ok;
278 /* Tear down a context for the gimplifier. If BODY is non-null, then
279 put the temporaries into the outer BIND_EXPR. Otherwise, put them
280 in the local_decls.
282 BODY is not a sequence, but the first tuple in a sequence. */
284 void
285 pop_gimplify_context (gimple *body)
287 struct gimplify_ctx *c = gimplify_ctxp;
289 gcc_assert (c
290 && (!c->bind_expr_stack.exists ()
291 || c->bind_expr_stack.is_empty ()));
292 c->bind_expr_stack.release ();
293 gimplify_ctxp = c->prev_context;
295 if (body)
296 declare_vars (c->temps, body, false);
297 else
298 record_vars (c->temps);
300 delete c->temp_htab;
301 c->temp_htab = NULL;
302 ctx_free (c);
305 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
307 static void
308 gimple_push_bind_expr (gbind *bind_stmt)
310 gimplify_ctxp->bind_expr_stack.reserve (8);
311 gimplify_ctxp->bind_expr_stack.safe_push (bind_stmt);
314 /* Pop the first element off the stack of bindings. */
316 static void
317 gimple_pop_bind_expr (void)
319 gimplify_ctxp->bind_expr_stack.pop ();
322 /* Return the first element of the stack of bindings. */
324 gbind *
325 gimple_current_bind_expr (void)
327 return gimplify_ctxp->bind_expr_stack.last ();
330 /* Return the stack of bindings created during gimplification. */
332 vec<gbind *>
333 gimple_bind_expr_stack (void)
335 return gimplify_ctxp->bind_expr_stack;
338 /* Return true iff there is a COND_EXPR between us and the innermost
339 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
341 static bool
342 gimple_conditional_context (void)
344 return gimplify_ctxp->conditions > 0;
347 /* Note that we've entered a COND_EXPR. */
349 static void
350 gimple_push_condition (void)
352 #ifdef ENABLE_GIMPLE_CHECKING
353 if (gimplify_ctxp->conditions == 0)
354 gcc_assert (gimple_seq_empty_p (gimplify_ctxp->conditional_cleanups));
355 #endif
356 ++(gimplify_ctxp->conditions);
359 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
360 now, add any conditional cleanups we've seen to the prequeue. */
362 static void
363 gimple_pop_condition (gimple_seq *pre_p)
365 int conds = --(gimplify_ctxp->conditions);
367 gcc_assert (conds >= 0);
368 if (conds == 0)
370 gimplify_seq_add_seq (pre_p, gimplify_ctxp->conditional_cleanups);
371 gimplify_ctxp->conditional_cleanups = NULL;
375 /* A stable comparison routine for use with splay trees and DECLs. */
377 static int
378 splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
380 tree a = (tree) xa;
381 tree b = (tree) xb;
383 return DECL_UID (a) - DECL_UID (b);
386 /* Create a new omp construct that deals with variable remapping. */
388 static struct gimplify_omp_ctx *
389 new_omp_context (enum omp_region_type region_type)
391 struct gimplify_omp_ctx *c;
393 c = XCNEW (struct gimplify_omp_ctx);
394 c->outer_context = gimplify_omp_ctxp;
395 c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
396 c->privatized_types = new hash_set<tree>;
397 c->location = input_location;
398 c->region_type = region_type;
399 if ((region_type & ORT_TASK) == 0)
400 c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
401 else
402 c->default_kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
404 return c;
407 /* Destroy an omp construct that deals with variable remapping. */
409 static void
410 delete_omp_context (struct gimplify_omp_ctx *c)
412 splay_tree_delete (c->variables);
413 delete c->privatized_types;
414 c->loop_iter_var.release ();
415 XDELETE (c);
418 static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
419 static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
421 /* Both gimplify the statement T and append it to *SEQ_P. This function
422 behaves exactly as gimplify_stmt, but you don't have to pass T as a
423 reference. */
425 void
426 gimplify_and_add (tree t, gimple_seq *seq_p)
428 gimplify_stmt (&t, seq_p);
431 /* Gimplify statement T into sequence *SEQ_P, and return the first
432 tuple in the sequence of generated tuples for this statement.
433 Return NULL if gimplifying T produced no tuples. */
435 static gimple *
436 gimplify_and_return_first (tree t, gimple_seq *seq_p)
438 gimple_stmt_iterator last = gsi_last (*seq_p);
440 gimplify_and_add (t, seq_p);
442 if (!gsi_end_p (last))
444 gsi_next (&last);
445 return gsi_stmt (last);
447 else
448 return gimple_seq_first_stmt (*seq_p);
451 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
452 LHS, or for a call argument. */
454 static bool
455 is_gimple_mem_rhs (tree t)
457 /* If we're dealing with a renamable type, either source or dest must be
458 a renamed variable. */
459 if (is_gimple_reg_type (TREE_TYPE (t)))
460 return is_gimple_val (t);
461 else
462 return is_gimple_val (t) || is_gimple_lvalue (t);
465 /* Return true if T is a CALL_EXPR or an expression that can be
466 assigned to a temporary. Note that this predicate should only be
467 used during gimplification. See the rationale for this in
468 gimplify_modify_expr. */
470 static bool
471 is_gimple_reg_rhs_or_call (tree t)
473 return (get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS
474 || TREE_CODE (t) == CALL_EXPR);
477 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
478 this predicate should only be used during gimplification. See the
479 rationale for this in gimplify_modify_expr. */
481 static bool
482 is_gimple_mem_rhs_or_call (tree t)
484 /* If we're dealing with a renamable type, either source or dest must be
485 a renamed variable. */
486 if (is_gimple_reg_type (TREE_TYPE (t)))
487 return is_gimple_val (t);
488 else
489 return (is_gimple_val (t) || is_gimple_lvalue (t)
490 || TREE_CODE (t) == CALL_EXPR);
493 /* Create a temporary with a name derived from VAL. Subroutine of
494 lookup_tmp_var; nobody else should call this function. */
496 static inline tree
497 create_tmp_from_val (tree val)
499 /* Drop all qualifiers and address-space information from the value type. */
500 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (val));
501 tree var = create_tmp_var (type, get_name (val));
502 if (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
503 || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE)
504 DECL_GIMPLE_REG_P (var) = 1;
505 return var;
508 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
509 an existing expression temporary. */
511 static tree
512 lookup_tmp_var (tree val, bool is_formal)
514 tree ret;
516 /* If not optimizing, never really reuse a temporary. local-alloc
517 won't allocate any variable that is used in more than one basic
518 block, which means it will go into memory, causing much extra
519 work in reload and final and poorer code generation, outweighing
520 the extra memory allocation here. */
521 if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
522 ret = create_tmp_from_val (val);
523 else
525 elt_t elt, *elt_p;
526 elt_t **slot;
528 elt.val = val;
529 if (!gimplify_ctxp->temp_htab)
530 gimplify_ctxp->temp_htab = new hash_table<gimplify_hasher> (1000);
531 slot = gimplify_ctxp->temp_htab->find_slot (&elt, INSERT);
532 if (*slot == NULL)
534 elt_p = XNEW (elt_t);
535 elt_p->val = val;
536 elt_p->temp = ret = create_tmp_from_val (val);
537 *slot = elt_p;
539 else
541 elt_p = *slot;
542 ret = elt_p->temp;
546 return ret;
549 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
551 static tree
552 internal_get_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
553 bool is_formal, bool allow_ssa)
555 tree t, mod;
557 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
558 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
559 gimplify_expr (&val, pre_p, post_p, is_gimple_reg_rhs_or_call,
560 fb_rvalue);
562 if (allow_ssa
563 && gimplify_ctxp->into_ssa
564 && is_gimple_reg_type (TREE_TYPE (val)))
566 t = make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val)));
567 if (! gimple_in_ssa_p (cfun))
569 const char *name = get_name (val);
570 if (name)
571 SET_SSA_NAME_VAR_OR_IDENTIFIER (t, create_tmp_var_name (name));
574 else
575 t = lookup_tmp_var (val, is_formal);
577 mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
579 SET_EXPR_LOCATION (mod, EXPR_LOC_OR_LOC (val, input_location));
581 /* gimplify_modify_expr might want to reduce this further. */
582 gimplify_and_add (mod, pre_p);
583 ggc_free (mod);
585 return t;
588 /* Return a formal temporary variable initialized with VAL. PRE_P is as
589 in gimplify_expr. Only use this function if:
591 1) The value of the unfactored expression represented by VAL will not
592 change between the initialization and use of the temporary, and
593 2) The temporary will not be otherwise modified.
595 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
596 and #2 means it is inappropriate for && temps.
598 For other cases, use get_initialized_tmp_var instead. */
600 tree
601 get_formal_tmp_var (tree val, gimple_seq *pre_p)
603 return internal_get_tmp_var (val, pre_p, NULL, true, true);
606 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
607 are as in gimplify_expr. */
609 tree
610 get_initialized_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
611 bool allow_ssa)
613 return internal_get_tmp_var (val, pre_p, post_p, false, allow_ssa);
616 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
617 generate debug info for them; otherwise don't. */
619 void
620 declare_vars (tree vars, gimple *gs, bool debug_info)
622 tree last = vars;
623 if (last)
625 tree temps, block;
627 gbind *scope = as_a <gbind *> (gs);
629 temps = nreverse (last);
631 block = gimple_bind_block (scope);
632 gcc_assert (!block || TREE_CODE (block) == BLOCK);
633 if (!block || !debug_info)
635 DECL_CHAIN (last) = gimple_bind_vars (scope);
636 gimple_bind_set_vars (scope, temps);
638 else
640 /* We need to attach the nodes both to the BIND_EXPR and to its
641 associated BLOCK for debugging purposes. The key point here
642 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
643 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
644 if (BLOCK_VARS (block))
645 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
646 else
648 gimple_bind_set_vars (scope,
649 chainon (gimple_bind_vars (scope), temps));
650 BLOCK_VARS (block) = temps;
656 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
657 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
658 no such upper bound can be obtained. */
660 static void
661 force_constant_size (tree var)
663 /* The only attempt we make is by querying the maximum size of objects
664 of the variable's type. */
666 HOST_WIDE_INT max_size;
668 gcc_assert (VAR_P (var));
670 max_size = max_int_size_in_bytes (TREE_TYPE (var));
672 gcc_assert (max_size >= 0);
674 DECL_SIZE_UNIT (var)
675 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size);
676 DECL_SIZE (var)
677 = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT);
680 /* Push the temporary variable TMP into the current binding. */
682 void
683 gimple_add_tmp_var_fn (struct function *fn, tree tmp)
685 gcc_assert (!DECL_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
687 /* Later processing assumes that the object size is constant, which might
688 not be true at this point. Force the use of a constant upper bound in
689 this case. */
690 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (tmp)))
691 force_constant_size (tmp);
693 DECL_CONTEXT (tmp) = fn->decl;
694 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
696 record_vars_into (tmp, fn->decl);
699 /* Push the temporary variable TMP into the current binding. */
701 void
702 gimple_add_tmp_var (tree tmp)
704 gcc_assert (!DECL_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
706 /* Later processing assumes that the object size is constant, which might
707 not be true at this point. Force the use of a constant upper bound in
708 this case. */
709 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (tmp)))
710 force_constant_size (tmp);
712 DECL_CONTEXT (tmp) = current_function_decl;
713 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
715 if (gimplify_ctxp)
717 DECL_CHAIN (tmp) = gimplify_ctxp->temps;
718 gimplify_ctxp->temps = tmp;
720 /* Mark temporaries local within the nearest enclosing parallel. */
721 if (gimplify_omp_ctxp)
723 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
724 while (ctx
725 && (ctx->region_type == ORT_WORKSHARE
726 || ctx->region_type == ORT_SIMD
727 || ctx->region_type == ORT_ACC))
728 ctx = ctx->outer_context;
729 if (ctx)
730 omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
733 else if (cfun)
734 record_vars (tmp);
735 else
737 gimple_seq body_seq;
739 /* This case is for nested functions. We need to expose the locals
740 they create. */
741 body_seq = gimple_body (current_function_decl);
742 declare_vars (tmp, gimple_seq_first_stmt (body_seq), false);
748 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
749 nodes that are referenced more than once in GENERIC functions. This is
750 necessary because gimplification (translation into GIMPLE) is performed
751 by modifying tree nodes in-place, so gimplication of a shared node in a
752 first context could generate an invalid GIMPLE form in a second context.
754 This is achieved with a simple mark/copy/unmark algorithm that walks the
755 GENERIC representation top-down, marks nodes with TREE_VISITED the first
756 time it encounters them, duplicates them if they already have TREE_VISITED
757 set, and finally removes the TREE_VISITED marks it has set.
759 The algorithm works only at the function level, i.e. it generates a GENERIC
760 representation of a function with no nodes shared within the function when
761 passed a GENERIC function (except for nodes that are allowed to be shared).
763 At the global level, it is also necessary to unshare tree nodes that are
764 referenced in more than one function, for the same aforementioned reason.
765 This requires some cooperation from the front-end. There are 2 strategies:
767 1. Manual unsharing. The front-end needs to call unshare_expr on every
768 expression that might end up being shared across functions.
770 2. Deep unsharing. This is an extension of regular unsharing. Instead
771 of calling unshare_expr on expressions that might be shared across
772 functions, the front-end pre-marks them with TREE_VISITED. This will
773 ensure that they are unshared on the first reference within functions
774 when the regular unsharing algorithm runs. The counterpart is that
775 this algorithm must look deeper than for manual unsharing, which is
776 specified by LANG_HOOKS_DEEP_UNSHARING.
778 If there are only few specific cases of node sharing across functions, it is
779 probably easier for a front-end to unshare the expressions manually. On the
780 contrary, if the expressions generated at the global level are as widespread
781 as expressions generated within functions, deep unsharing is very likely the
782 way to go. */
784 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
785 These nodes model computations that must be done once. If we were to
786 unshare something like SAVE_EXPR(i++), the gimplification process would
787 create wrong code. However, if DATA is non-null, it must hold a pointer
788 set that is used to unshare the subtrees of these nodes. */
790 static tree
791 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
793 tree t = *tp;
794 enum tree_code code = TREE_CODE (t);
796 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
797 copy their subtrees if we can make sure to do it only once. */
798 if (code == SAVE_EXPR || code == TARGET_EXPR || code == BIND_EXPR)
800 if (data && !((hash_set<tree> *)data)->add (t))
802 else
803 *walk_subtrees = 0;
806 /* Stop at types, decls, constants like copy_tree_r. */
807 else if (TREE_CODE_CLASS (code) == tcc_type
808 || TREE_CODE_CLASS (code) == tcc_declaration
809 || TREE_CODE_CLASS (code) == tcc_constant
810 /* We can't do anything sensible with a BLOCK used as an
811 expression, but we also can't just die when we see it
812 because of non-expression uses. So we avert our eyes
813 and cross our fingers. Silly Java. */
814 || code == BLOCK)
815 *walk_subtrees = 0;
817 /* Cope with the statement expression extension. */
818 else if (code == STATEMENT_LIST)
821 /* Leave the bulk of the work to copy_tree_r itself. */
822 else
823 copy_tree_r (tp, walk_subtrees, NULL);
825 return NULL_TREE;
828 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
829 If *TP has been visited already, then *TP is deeply copied by calling
830 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
832 static tree
833 copy_if_shared_r (tree *tp, int *walk_subtrees, void *data)
835 tree t = *tp;
836 enum tree_code code = TREE_CODE (t);
838 /* Skip types, decls, and constants. But we do want to look at their
839 types and the bounds of types. Mark them as visited so we properly
840 unmark their subtrees on the unmark pass. If we've already seen them,
841 don't look down further. */
842 if (TREE_CODE_CLASS (code) == tcc_type
843 || TREE_CODE_CLASS (code) == tcc_declaration
844 || TREE_CODE_CLASS (code) == tcc_constant)
846 if (TREE_VISITED (t))
847 *walk_subtrees = 0;
848 else
849 TREE_VISITED (t) = 1;
852 /* If this node has been visited already, unshare it and don't look
853 any deeper. */
854 else if (TREE_VISITED (t))
856 walk_tree (tp, mostly_copy_tree_r, data, NULL);
857 *walk_subtrees = 0;
860 /* Otherwise, mark the node as visited and keep looking. */
861 else
862 TREE_VISITED (t) = 1;
864 return NULL_TREE;
867 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
868 copy_if_shared_r callback unmodified. */
870 static inline void
871 copy_if_shared (tree *tp, void *data)
873 walk_tree (tp, copy_if_shared_r, data, NULL);
876 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
877 any nested functions. */
879 static void
880 unshare_body (tree fndecl)
882 struct cgraph_node *cgn = cgraph_node::get (fndecl);
883 /* If the language requires deep unsharing, we need a pointer set to make
884 sure we don't repeatedly unshare subtrees of unshareable nodes. */
885 hash_set<tree> *visited
886 = lang_hooks.deep_unsharing ? new hash_set<tree> : NULL;
888 copy_if_shared (&DECL_SAVED_TREE (fndecl), visited);
889 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl)), visited);
890 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl)), visited);
892 delete visited;
894 if (cgn)
895 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
896 unshare_body (cgn->decl);
899 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
900 Subtrees are walked until the first unvisited node is encountered. */
902 static tree
903 unmark_visited_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
905 tree t = *tp;
907 /* If this node has been visited, unmark it and keep looking. */
908 if (TREE_VISITED (t))
909 TREE_VISITED (t) = 0;
911 /* Otherwise, don't look any deeper. */
912 else
913 *walk_subtrees = 0;
915 return NULL_TREE;
918 /* Unmark the visited trees rooted at *TP. */
920 static inline void
921 unmark_visited (tree *tp)
923 walk_tree (tp, unmark_visited_r, NULL, NULL);
926 /* Likewise, but mark all trees as not visited. */
928 static void
929 unvisit_body (tree fndecl)
931 struct cgraph_node *cgn = cgraph_node::get (fndecl);
933 unmark_visited (&DECL_SAVED_TREE (fndecl));
934 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl)));
935 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl)));
937 if (cgn)
938 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
939 unvisit_body (cgn->decl);
942 /* Unconditionally make an unshared copy of EXPR. This is used when using
943 stored expressions which span multiple functions, such as BINFO_VTABLE,
944 as the normal unsharing process can't tell that they're shared. */
946 tree
947 unshare_expr (tree expr)
949 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
950 return expr;
953 /* Worker for unshare_expr_without_location. */
955 static tree
956 prune_expr_location (tree *tp, int *walk_subtrees, void *)
958 if (EXPR_P (*tp))
959 SET_EXPR_LOCATION (*tp, UNKNOWN_LOCATION);
960 else
961 *walk_subtrees = 0;
962 return NULL_TREE;
965 /* Similar to unshare_expr but also prune all expression locations
966 from EXPR. */
968 tree
969 unshare_expr_without_location (tree expr)
971 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
972 if (EXPR_P (expr))
973 walk_tree (&expr, prune_expr_location, NULL, NULL);
974 return expr;
977 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
978 contain statements and have a value. Assign its value to a temporary
979 and give it void_type_node. Return the temporary, or NULL_TREE if
980 WRAPPER was already void. */
982 tree
983 voidify_wrapper_expr (tree wrapper, tree temp)
985 tree type = TREE_TYPE (wrapper);
986 if (type && !VOID_TYPE_P (type))
988 tree *p;
990 /* Set p to point to the body of the wrapper. Loop until we find
991 something that isn't a wrapper. */
992 for (p = &wrapper; p && *p; )
994 switch (TREE_CODE (*p))
996 case BIND_EXPR:
997 TREE_SIDE_EFFECTS (*p) = 1;
998 TREE_TYPE (*p) = void_type_node;
999 /* For a BIND_EXPR, the body is operand 1. */
1000 p = &BIND_EXPR_BODY (*p);
1001 break;
1003 case CLEANUP_POINT_EXPR:
1004 case TRY_FINALLY_EXPR:
1005 case TRY_CATCH_EXPR:
1006 TREE_SIDE_EFFECTS (*p) = 1;
1007 TREE_TYPE (*p) = void_type_node;
1008 p = &TREE_OPERAND (*p, 0);
1009 break;
1011 case STATEMENT_LIST:
1013 tree_stmt_iterator i = tsi_last (*p);
1014 TREE_SIDE_EFFECTS (*p) = 1;
1015 TREE_TYPE (*p) = void_type_node;
1016 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
1018 break;
1020 case COMPOUND_EXPR:
1021 /* Advance to the last statement. Set all container types to
1022 void. */
1023 for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
1025 TREE_SIDE_EFFECTS (*p) = 1;
1026 TREE_TYPE (*p) = void_type_node;
1028 break;
1030 case TRANSACTION_EXPR:
1031 TREE_SIDE_EFFECTS (*p) = 1;
1032 TREE_TYPE (*p) = void_type_node;
1033 p = &TRANSACTION_EXPR_BODY (*p);
1034 break;
1036 default:
1037 /* Assume that any tree upon which voidify_wrapper_expr is
1038 directly called is a wrapper, and that its body is op0. */
1039 if (p == &wrapper)
1041 TREE_SIDE_EFFECTS (*p) = 1;
1042 TREE_TYPE (*p) = void_type_node;
1043 p = &TREE_OPERAND (*p, 0);
1044 break;
1046 goto out;
1050 out:
1051 if (p == NULL || IS_EMPTY_STMT (*p))
1052 temp = NULL_TREE;
1053 else if (temp)
1055 /* The wrapper is on the RHS of an assignment that we're pushing
1056 down. */
1057 gcc_assert (TREE_CODE (temp) == INIT_EXPR
1058 || TREE_CODE (temp) == MODIFY_EXPR);
1059 TREE_OPERAND (temp, 1) = *p;
1060 *p = temp;
1062 else
1064 temp = create_tmp_var (type, "retval");
1065 *p = build2 (INIT_EXPR, type, temp, *p);
1068 return temp;
1071 return NULL_TREE;
1074 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1075 a temporary through which they communicate. */
1077 static void
1078 build_stack_save_restore (gcall **save, gcall **restore)
1080 tree tmp_var;
1082 *save = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE), 0);
1083 tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
1084 gimple_call_set_lhs (*save, tmp_var);
1086 *restore
1087 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE),
1088 1, tmp_var);
1091 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1093 static enum gimplify_status
1094 gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
1096 tree bind_expr = *expr_p;
1097 bool old_keep_stack = gimplify_ctxp->keep_stack;
1098 bool old_save_stack = gimplify_ctxp->save_stack;
1099 tree t;
1100 gbind *bind_stmt;
1101 gimple_seq body, cleanup;
1102 gcall *stack_save;
1103 location_t start_locus = 0, end_locus = 0;
1104 tree ret_clauses = NULL;
1106 tree temp = voidify_wrapper_expr (bind_expr, NULL);
1108 /* Mark variables seen in this bind expr. */
1109 for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
1111 if (VAR_P (t))
1113 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1115 /* Mark variable as local. */
1116 if (ctx && ctx->region_type != ORT_NONE && !DECL_EXTERNAL (t)
1117 && (! DECL_SEEN_IN_BIND_EXPR_P (t)
1118 || splay_tree_lookup (ctx->variables,
1119 (splay_tree_key) t) == NULL))
1121 if (ctx->region_type == ORT_SIMD
1122 && TREE_ADDRESSABLE (t)
1123 && !TREE_STATIC (t))
1124 omp_add_variable (ctx, t, GOVD_PRIVATE | GOVD_SEEN);
1125 else
1126 omp_add_variable (ctx, t, GOVD_LOCAL | GOVD_SEEN);
1129 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
1131 if (DECL_HARD_REGISTER (t) && !is_global_var (t) && cfun)
1132 cfun->has_local_explicit_reg_vars = true;
1135 /* Preliminarily mark non-addressed complex variables as eligible
1136 for promotion to gimple registers. We'll transform their uses
1137 as we find them. */
1138 if ((TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
1139 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
1140 && !TREE_THIS_VOLATILE (t)
1141 && (VAR_P (t) && !DECL_HARD_REGISTER (t))
1142 && !needs_to_live_in_memory (t))
1143 DECL_GIMPLE_REG_P (t) = 1;
1146 bind_stmt = gimple_build_bind (BIND_EXPR_VARS (bind_expr), NULL,
1147 BIND_EXPR_BLOCK (bind_expr));
1148 gimple_push_bind_expr (bind_stmt);
1150 gimplify_ctxp->keep_stack = false;
1151 gimplify_ctxp->save_stack = false;
1153 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1154 body = NULL;
1155 gimplify_stmt (&BIND_EXPR_BODY (bind_expr), &body);
1156 gimple_bind_set_body (bind_stmt, body);
1158 /* Source location wise, the cleanup code (stack_restore and clobbers)
1159 belongs to the end of the block, so propagate what we have. The
1160 stack_save operation belongs to the beginning of block, which we can
1161 infer from the bind_expr directly if the block has no explicit
1162 assignment. */
1163 if (BIND_EXPR_BLOCK (bind_expr))
1165 end_locus = BLOCK_SOURCE_END_LOCATION (BIND_EXPR_BLOCK (bind_expr));
1166 start_locus = BLOCK_SOURCE_LOCATION (BIND_EXPR_BLOCK (bind_expr));
1168 if (start_locus == 0)
1169 start_locus = EXPR_LOCATION (bind_expr);
1171 cleanup = NULL;
1172 stack_save = NULL;
1174 /* If the code both contains VLAs and calls alloca, then we cannot reclaim
1175 the stack space allocated to the VLAs. */
1176 if (gimplify_ctxp->save_stack && !gimplify_ctxp->keep_stack)
1178 gcall *stack_restore;
1180 /* Save stack on entry and restore it on exit. Add a try_finally
1181 block to achieve this. */
1182 build_stack_save_restore (&stack_save, &stack_restore);
1184 gimple_set_location (stack_save, start_locus);
1185 gimple_set_location (stack_restore, end_locus);
1187 gimplify_seq_add_stmt (&cleanup, stack_restore);
1190 /* Add clobbers for all variables that go out of scope. */
1191 for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
1193 if (VAR_P (t)
1194 && !is_global_var (t)
1195 && DECL_CONTEXT (t) == current_function_decl)
1197 if (!DECL_HARD_REGISTER (t)
1198 && !TREE_THIS_VOLATILE (t)
1199 && !DECL_HAS_VALUE_EXPR_P (t)
1200 /* Only care for variables that have to be in memory. Others
1201 will be rewritten into SSA names, hence moved to the
1202 top-level. */
1203 && !is_gimple_reg (t)
1204 && flag_stack_reuse != SR_NONE)
1206 tree clobber = build_constructor (TREE_TYPE (t), NULL);
1207 gimple *clobber_stmt;
1208 TREE_THIS_VOLATILE (clobber) = 1;
1209 clobber_stmt = gimple_build_assign (t, clobber);
1210 gimple_set_location (clobber_stmt, end_locus);
1211 gimplify_seq_add_stmt (&cleanup, clobber_stmt);
1214 if (flag_openacc && oacc_declare_returns != NULL)
1216 tree *c = oacc_declare_returns->get (t);
1217 if (c != NULL)
1219 if (ret_clauses)
1220 OMP_CLAUSE_CHAIN (*c) = ret_clauses;
1222 ret_clauses = *c;
1224 oacc_declare_returns->remove (t);
1226 if (oacc_declare_returns->elements () == 0)
1228 delete oacc_declare_returns;
1229 oacc_declare_returns = NULL;
1236 if (ret_clauses)
1238 gomp_target *stmt;
1239 gimple_stmt_iterator si = gsi_start (cleanup);
1241 stmt = gimple_build_omp_target (NULL, GF_OMP_TARGET_KIND_OACC_DECLARE,
1242 ret_clauses);
1243 gsi_insert_seq_before_without_update (&si, stmt, GSI_NEW_STMT);
1246 if (cleanup)
1248 gtry *gs;
1249 gimple_seq new_body;
1251 new_body = NULL;
1252 gs = gimple_build_try (gimple_bind_body (bind_stmt), cleanup,
1253 GIMPLE_TRY_FINALLY);
1255 if (stack_save)
1256 gimplify_seq_add_stmt (&new_body, stack_save);
1257 gimplify_seq_add_stmt (&new_body, gs);
1258 gimple_bind_set_body (bind_stmt, new_body);
1261 /* keep_stack propagates all the way up to the outermost BIND_EXPR. */
1262 if (!gimplify_ctxp->keep_stack)
1263 gimplify_ctxp->keep_stack = old_keep_stack;
1264 gimplify_ctxp->save_stack = old_save_stack;
1266 gimple_pop_bind_expr ();
1268 gimplify_seq_add_stmt (pre_p, bind_stmt);
1270 if (temp)
1272 *expr_p = temp;
1273 return GS_OK;
1276 *expr_p = NULL_TREE;
1277 return GS_ALL_DONE;
1280 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1281 GIMPLE value, it is assigned to a new temporary and the statement is
1282 re-written to return the temporary.
1284 PRE_P points to the sequence where side effects that must happen before
1285 STMT should be stored. */
1287 static enum gimplify_status
1288 gimplify_return_expr (tree stmt, gimple_seq *pre_p)
1290 greturn *ret;
1291 tree ret_expr = TREE_OPERAND (stmt, 0);
1292 tree result_decl, result;
1294 if (ret_expr == error_mark_node)
1295 return GS_ERROR;
1297 /* Implicit _Cilk_sync must be inserted right before any return statement
1298 if there is a _Cilk_spawn in the function. If the user has provided a
1299 _Cilk_sync, the optimizer should remove this duplicate one. */
1300 if (fn_contains_cilk_spawn_p (cfun))
1302 tree impl_sync = build0 (CILK_SYNC_STMT, void_type_node);
1303 gimplify_and_add (impl_sync, pre_p);
1306 if (!ret_expr
1307 || TREE_CODE (ret_expr) == RESULT_DECL
1308 || ret_expr == error_mark_node)
1310 greturn *ret = gimple_build_return (ret_expr);
1311 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1312 gimplify_seq_add_stmt (pre_p, ret);
1313 return GS_ALL_DONE;
1316 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1317 result_decl = NULL_TREE;
1318 else
1320 result_decl = TREE_OPERAND (ret_expr, 0);
1322 /* See through a return by reference. */
1323 if (TREE_CODE (result_decl) == INDIRECT_REF)
1324 result_decl = TREE_OPERAND (result_decl, 0);
1326 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
1327 || TREE_CODE (ret_expr) == INIT_EXPR)
1328 && TREE_CODE (result_decl) == RESULT_DECL);
1331 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1332 Recall that aggregate_value_p is FALSE for any aggregate type that is
1333 returned in registers. If we're returning values in registers, then
1334 we don't want to extend the lifetime of the RESULT_DECL, particularly
1335 across another call. In addition, for those aggregates for which
1336 hard_function_value generates a PARALLEL, we'll die during normal
1337 expansion of structure assignments; there's special code in expand_return
1338 to handle this case that does not exist in expand_expr. */
1339 if (!result_decl)
1340 result = NULL_TREE;
1341 else if (aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1343 if (TREE_CODE (DECL_SIZE (result_decl)) != INTEGER_CST)
1345 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl)))
1346 gimplify_type_sizes (TREE_TYPE (result_decl), pre_p);
1347 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1348 should be effectively allocated by the caller, i.e. all calls to
1349 this function must be subject to the Return Slot Optimization. */
1350 gimplify_one_sizepos (&DECL_SIZE (result_decl), pre_p);
1351 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl), pre_p);
1353 result = result_decl;
1355 else if (gimplify_ctxp->return_temp)
1356 result = gimplify_ctxp->return_temp;
1357 else
1359 result = create_tmp_reg (TREE_TYPE (result_decl));
1361 /* ??? With complex control flow (usually involving abnormal edges),
1362 we can wind up warning about an uninitialized value for this. Due
1363 to how this variable is constructed and initialized, this is never
1364 true. Give up and never warn. */
1365 TREE_NO_WARNING (result) = 1;
1367 gimplify_ctxp->return_temp = result;
1370 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1371 Then gimplify the whole thing. */
1372 if (result != result_decl)
1373 TREE_OPERAND (ret_expr, 0) = result;
1375 gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1377 ret = gimple_build_return (result);
1378 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1379 gimplify_seq_add_stmt (pre_p, ret);
1381 return GS_ALL_DONE;
1384 /* Gimplify a variable-length array DECL. */
1386 static void
1387 gimplify_vla_decl (tree decl, gimple_seq *seq_p)
1389 /* This is a variable-sized decl. Simplify its size and mark it
1390 for deferred expansion. */
1391 tree t, addr, ptr_type;
1393 gimplify_one_sizepos (&DECL_SIZE (decl), seq_p);
1394 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), seq_p);
1396 /* Don't mess with a DECL_VALUE_EXPR set by the front-end. */
1397 if (DECL_HAS_VALUE_EXPR_P (decl))
1398 return;
1400 /* All occurrences of this decl in final gimplified code will be
1401 replaced by indirection. Setting DECL_VALUE_EXPR does two
1402 things: First, it lets the rest of the gimplifier know what
1403 replacement to use. Second, it lets the debug info know
1404 where to find the value. */
1405 ptr_type = build_pointer_type (TREE_TYPE (decl));
1406 addr = create_tmp_var (ptr_type, get_name (decl));
1407 DECL_IGNORED_P (addr) = 0;
1408 t = build_fold_indirect_ref (addr);
1409 TREE_THIS_NOTRAP (t) = 1;
1410 SET_DECL_VALUE_EXPR (decl, t);
1411 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1413 t = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN);
1414 t = build_call_expr (t, 2, DECL_SIZE_UNIT (decl),
1415 size_int (DECL_ALIGN (decl)));
1416 /* The call has been built for a variable-sized object. */
1417 CALL_ALLOCA_FOR_VAR_P (t) = 1;
1418 t = fold_convert (ptr_type, t);
1419 t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
1421 gimplify_and_add (t, seq_p);
1424 /* A helper function to be called via walk_tree. Mark all labels under *TP
1425 as being forced. To be called for DECL_INITIAL of static variables. */
1427 static tree
1428 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1430 if (TYPE_P (*tp))
1431 *walk_subtrees = 0;
1432 if (TREE_CODE (*tp) == LABEL_DECL)
1434 FORCED_LABEL (*tp) = 1;
1435 cfun->has_forced_label_in_static = 1;
1438 return NULL_TREE;
1441 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1442 and initialization explicit. */
1444 static enum gimplify_status
1445 gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p)
1447 tree stmt = *stmt_p;
1448 tree decl = DECL_EXPR_DECL (stmt);
1450 *stmt_p = NULL_TREE;
1452 if (TREE_TYPE (decl) == error_mark_node)
1453 return GS_ERROR;
1455 if ((TREE_CODE (decl) == TYPE_DECL
1456 || VAR_P (decl))
1457 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1459 gimplify_type_sizes (TREE_TYPE (decl), seq_p);
1460 if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
1461 gimplify_type_sizes (TREE_TYPE (TREE_TYPE (decl)), seq_p);
1464 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1465 in case its size expressions contain problematic nodes like CALL_EXPR. */
1466 if (TREE_CODE (decl) == TYPE_DECL
1467 && DECL_ORIGINAL_TYPE (decl)
1468 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl)))
1470 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl), seq_p);
1471 if (TREE_CODE (DECL_ORIGINAL_TYPE (decl)) == REFERENCE_TYPE)
1472 gimplify_type_sizes (TREE_TYPE (DECL_ORIGINAL_TYPE (decl)), seq_p);
1475 if (VAR_P (decl) && !DECL_EXTERNAL (decl))
1477 tree init = DECL_INITIAL (decl);
1479 if (TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1480 || (!TREE_STATIC (decl)
1481 && flag_stack_check == GENERIC_STACK_CHECK
1482 && compare_tree_int (DECL_SIZE_UNIT (decl),
1483 STACK_CHECK_MAX_VAR_SIZE) > 0))
1484 gimplify_vla_decl (decl, seq_p);
1486 /* Some front ends do not explicitly declare all anonymous
1487 artificial variables. We compensate here by declaring the
1488 variables, though it would be better if the front ends would
1489 explicitly declare them. */
1490 if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1491 && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1492 gimple_add_tmp_var (decl);
1494 if (init && init != error_mark_node)
1496 if (!TREE_STATIC (decl))
1498 DECL_INITIAL (decl) = NULL_TREE;
1499 init = build2 (INIT_EXPR, void_type_node, decl, init);
1500 gimplify_and_add (init, seq_p);
1501 ggc_free (init);
1503 else
1504 /* We must still examine initializers for static variables
1505 as they may contain a label address. */
1506 walk_tree (&init, force_labels_r, NULL, NULL);
1510 return GS_ALL_DONE;
1513 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1514 and replacing the LOOP_EXPR with goto, but if the loop contains an
1515 EXIT_EXPR, we need to append a label for it to jump to. */
1517 static enum gimplify_status
1518 gimplify_loop_expr (tree *expr_p, gimple_seq *pre_p)
1520 tree saved_label = gimplify_ctxp->exit_label;
1521 tree start_label = create_artificial_label (UNKNOWN_LOCATION);
1523 gimplify_seq_add_stmt (pre_p, gimple_build_label (start_label));
1525 gimplify_ctxp->exit_label = NULL_TREE;
1527 gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1529 gimplify_seq_add_stmt (pre_p, gimple_build_goto (start_label));
1531 if (gimplify_ctxp->exit_label)
1532 gimplify_seq_add_stmt (pre_p,
1533 gimple_build_label (gimplify_ctxp->exit_label));
1535 gimplify_ctxp->exit_label = saved_label;
1537 *expr_p = NULL;
1538 return GS_ALL_DONE;
1541 /* Gimplify a statement list onto a sequence. These may be created either
1542 by an enlightened front-end, or by shortcut_cond_expr. */
1544 static enum gimplify_status
1545 gimplify_statement_list (tree *expr_p, gimple_seq *pre_p)
1547 tree temp = voidify_wrapper_expr (*expr_p, NULL);
1549 tree_stmt_iterator i = tsi_start (*expr_p);
1551 while (!tsi_end_p (i))
1553 gimplify_stmt (tsi_stmt_ptr (i), pre_p);
1554 tsi_delink (&i);
1557 if (temp)
1559 *expr_p = temp;
1560 return GS_OK;
1563 return GS_ALL_DONE;
1566 /* Callback for walk_gimple_seq. */
1568 static tree
1569 warn_switch_unreachable_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
1570 struct walk_stmt_info *wi)
1572 gimple *stmt = gsi_stmt (*gsi_p);
1574 *handled_ops_p = true;
1575 switch (gimple_code (stmt))
1577 case GIMPLE_TRY:
1578 /* A compiler-generated cleanup or a user-written try block.
1579 If it's empty, don't dive into it--that would result in
1580 worse location info. */
1581 if (gimple_try_eval (stmt) == NULL)
1583 wi->info = stmt;
1584 return integer_zero_node;
1586 /* Fall through. */
1587 case GIMPLE_BIND:
1588 case GIMPLE_CATCH:
1589 case GIMPLE_EH_FILTER:
1590 case GIMPLE_TRANSACTION:
1591 /* Walk the sub-statements. */
1592 *handled_ops_p = false;
1593 break;
1594 default:
1595 /* Save the first "real" statement (not a decl/lexical scope/...). */
1596 wi->info = stmt;
1597 return integer_zero_node;
1599 return NULL_TREE;
1602 /* Possibly warn about unreachable statements between switch's controlling
1603 expression and the first case. SEQ is the body of a switch expression. */
1605 static void
1606 maybe_warn_switch_unreachable (gimple_seq seq)
1608 if (!warn_switch_unreachable
1609 /* This warning doesn't play well with Fortran when optimizations
1610 are on. */
1611 || lang_GNU_Fortran ()
1612 || seq == NULL)
1613 return;
1615 struct walk_stmt_info wi;
1616 memset (&wi, 0, sizeof (wi));
1617 walk_gimple_seq (seq, warn_switch_unreachable_r, NULL, &wi);
1618 gimple *stmt = (gimple *) wi.info;
1620 if (stmt && gimple_code (stmt) != GIMPLE_LABEL)
1622 if (gimple_code (stmt) == GIMPLE_GOTO
1623 && TREE_CODE (gimple_goto_dest (stmt)) == LABEL_DECL
1624 && DECL_ARTIFICIAL (gimple_goto_dest (stmt)))
1625 /* Don't warn for compiler-generated gotos. These occur
1626 in Duff's devices, for example. */;
1627 else
1628 warning_at (gimple_location (stmt), OPT_Wswitch_unreachable,
1629 "statement will never be executed");
1634 /* A label entry that pairs label and a location. */
1635 struct label_entry
1637 tree label;
1638 location_t loc;
1641 /* Find LABEL in vector of label entries VEC. */
1643 static struct label_entry *
1644 find_label_entry (const auto_vec<struct label_entry> *vec, tree label)
1646 unsigned int i;
1647 struct label_entry *l;
1649 FOR_EACH_VEC_ELT (*vec, i, l)
1650 if (l->label == label)
1651 return l;
1652 return NULL;
1655 /* Return true if LABEL, a LABEL_DECL, represents a case label
1656 in a vector of labels CASES. */
1658 static bool
1659 case_label_p (const vec<tree> *cases, tree label)
1661 unsigned int i;
1662 tree l;
1664 FOR_EACH_VEC_ELT (*cases, i, l)
1665 if (CASE_LABEL (l) == label)
1666 return true;
1667 return false;
1670 /* Find the last statement in a scope STMT. */
1672 static gimple *
1673 last_stmt_in_scope (gimple *stmt)
1675 if (!stmt)
1676 return NULL;
1678 switch (gimple_code (stmt))
1680 case GIMPLE_BIND:
1682 gbind *bind = as_a <gbind *> (stmt);
1683 stmt = gimple_seq_last_stmt (gimple_bind_body (bind));
1684 return last_stmt_in_scope (stmt);
1687 case GIMPLE_TRY:
1689 gtry *try_stmt = as_a <gtry *> (stmt);
1690 stmt = gimple_seq_last_stmt (gimple_try_eval (try_stmt));
1691 gimple *last_eval = last_stmt_in_scope (stmt);
1692 if (gimple_stmt_may_fallthru (last_eval)
1693 && (last_eval == NULL
1694 || !gimple_call_internal_p (last_eval, IFN_FALLTHROUGH))
1695 && gimple_try_kind (try_stmt) == GIMPLE_TRY_FINALLY)
1697 stmt = gimple_seq_last_stmt (gimple_try_cleanup (try_stmt));
1698 return last_stmt_in_scope (stmt);
1700 else
1701 return last_eval;
1704 default:
1705 return stmt;
1709 /* Collect interesting labels in LABELS and return the statement preceding
1710 another case label, or a user-defined label. */
1712 static gimple *
1713 collect_fallthrough_labels (gimple_stmt_iterator *gsi_p,
1714 auto_vec <struct label_entry> *labels)
1716 gimple *prev = NULL;
1720 if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_BIND
1721 || gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_TRY)
1723 /* Nested scope. Only look at the last statement of
1724 the innermost scope. */
1725 location_t bind_loc = gimple_location (gsi_stmt (*gsi_p));
1726 gimple *last = last_stmt_in_scope (gsi_stmt (*gsi_p));
1727 if (last)
1729 prev = last;
1730 /* It might be a label without a location. Use the
1731 location of the scope then. */
1732 if (!gimple_has_location (prev))
1733 gimple_set_location (prev, bind_loc);
1735 gsi_next (gsi_p);
1736 continue;
1739 /* Ifs are tricky. */
1740 if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_COND)
1742 gcond *cond_stmt = as_a <gcond *> (gsi_stmt (*gsi_p));
1743 tree false_lab = gimple_cond_false_label (cond_stmt);
1744 location_t if_loc = gimple_location (cond_stmt);
1746 /* If we have e.g.
1747 if (i > 1) goto <D.2259>; else goto D;
1748 we can't do much with the else-branch. */
1749 if (!DECL_ARTIFICIAL (false_lab))
1750 break;
1752 /* Go on until the false label, then one step back. */
1753 for (; !gsi_end_p (*gsi_p); gsi_next (gsi_p))
1755 gimple *stmt = gsi_stmt (*gsi_p);
1756 if (gimple_code (stmt) == GIMPLE_LABEL
1757 && gimple_label_label (as_a <glabel *> (stmt)) == false_lab)
1758 break;
1761 /* Not found? Oops. */
1762 if (gsi_end_p (*gsi_p))
1763 break;
1765 struct label_entry l = { false_lab, if_loc };
1766 labels->safe_push (l);
1768 /* Go to the last statement of the then branch. */
1769 gsi_prev (gsi_p);
1771 /* if (i != 0) goto <D.1759>; else goto <D.1760>;
1772 <D.1759>:
1773 <stmt>;
1774 goto <D.1761>;
1775 <D.1760>:
1777 if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_GOTO
1778 && !gimple_has_location (gsi_stmt (*gsi_p)))
1780 /* Look at the statement before, it might be
1781 attribute fallthrough, in which case don't warn. */
1782 gsi_prev (gsi_p);
1783 bool fallthru_before_dest
1784 = gimple_call_internal_p (gsi_stmt (*gsi_p), IFN_FALLTHROUGH);
1785 gsi_next (gsi_p);
1786 tree goto_dest = gimple_goto_dest (gsi_stmt (*gsi_p));
1787 if (!fallthru_before_dest)
1789 struct label_entry l = { goto_dest, if_loc };
1790 labels->safe_push (l);
1793 /* And move back. */
1794 gsi_next (gsi_p);
1797 /* Remember the last statement. Skip labels that are of no interest
1798 to us. */
1799 if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_LABEL)
1801 tree label = gimple_label_label (as_a <glabel *> (gsi_stmt (*gsi_p)));
1802 if (find_label_entry (labels, label))
1803 prev = gsi_stmt (*gsi_p);
1805 else
1806 prev = gsi_stmt (*gsi_p);
1807 gsi_next (gsi_p);
1809 while (!gsi_end_p (*gsi_p)
1810 /* Stop if we find a case or a user-defined label. */
1811 && (gimple_code (gsi_stmt (*gsi_p)) != GIMPLE_LABEL
1812 || !gimple_has_location (gsi_stmt (*gsi_p))));
1814 return prev;
1817 /* Return true if the switch fallthough warning should occur. LABEL is
1818 the label statement that we're falling through to. */
1820 static bool
1821 should_warn_for_implicit_fallthrough (gimple_stmt_iterator *gsi_p, tree label)
1823 gimple_stmt_iterator gsi = *gsi_p;
1825 /* Don't warn if the label is marked with a "falls through" comment. */
1826 if (FALLTHROUGH_LABEL_P (label))
1827 return false;
1829 /* Don't warn for a non-case label followed by a statement:
1830 case 0:
1831 foo ();
1832 label:
1833 bar ();
1834 as these are likely intentional. */
1835 if (!case_label_p (&gimplify_ctxp->case_labels, label))
1837 gsi_next (&gsi);
1838 if (gsi_end_p (gsi) || gimple_code (gsi_stmt (gsi)) != GIMPLE_LABEL)
1839 return false;
1842 /* Don't warn for terminated branches, i.e. when the subsequent case labels
1843 immediately breaks. */
1844 gsi = *gsi_p;
1846 /* Skip all immediately following labels. */
1847 while (!gsi_end_p (gsi) && gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL)
1848 gsi_next (&gsi);
1850 /* { ... something; default:; } */
1851 if (gsi_end_p (gsi)
1852 /* { ... something; default: break; } or
1853 { ... something; default: goto L; } */
1854 || gimple_code (gsi_stmt (gsi)) == GIMPLE_GOTO
1855 /* { ... something; default: return; } */
1856 || gimple_code (gsi_stmt (gsi)) == GIMPLE_RETURN)
1857 return false;
1859 return true;
1862 /* Callback for walk_gimple_seq. */
1864 static tree
1865 warn_implicit_fallthrough_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
1866 struct walk_stmt_info *)
1868 gimple *stmt = gsi_stmt (*gsi_p);
1870 *handled_ops_p = true;
1871 switch (gimple_code (stmt))
1873 case GIMPLE_TRY:
1874 case GIMPLE_BIND:
1875 case GIMPLE_CATCH:
1876 case GIMPLE_EH_FILTER:
1877 case GIMPLE_TRANSACTION:
1878 /* Walk the sub-statements. */
1879 *handled_ops_p = false;
1880 break;
1882 /* Find a sequence of form:
1884 GIMPLE_LABEL
1885 [...]
1886 <may fallthru stmt>
1887 GIMPLE_LABEL
1889 and possibly warn. */
1890 case GIMPLE_LABEL:
1892 /* Found a label. Skip all immediately following labels. */
1893 while (!gsi_end_p (*gsi_p)
1894 && gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_LABEL)
1895 gsi_next (gsi_p);
1897 /* There might be no more statements. */
1898 if (gsi_end_p (*gsi_p))
1899 return integer_zero_node;
1901 /* Vector of labels that fall through. */
1902 auto_vec <struct label_entry> labels;
1903 gimple *prev = collect_fallthrough_labels (gsi_p, &labels);
1905 /* There might be no more statements. */
1906 if (gsi_end_p (*gsi_p))
1907 return integer_zero_node;
1909 gimple *next = gsi_stmt (*gsi_p);
1910 tree label;
1911 /* If what follows is a label, then we may have a fallthrough. */
1912 if (gimple_code (next) == GIMPLE_LABEL
1913 && gimple_has_location (next)
1914 && (label = gimple_label_label (as_a <glabel *> (next)))
1915 && prev != NULL)
1917 struct label_entry *l;
1918 bool warned_p = false;
1919 if (!should_warn_for_implicit_fallthrough (gsi_p, label))
1920 /* Quiet. */;
1921 else if (gimple_code (prev) == GIMPLE_LABEL
1922 && (label = gimple_label_label (as_a <glabel *> (prev)))
1923 && (l = find_label_entry (&labels, label)))
1924 warned_p = warning_at (l->loc, OPT_Wimplicit_fallthrough_,
1925 "this statement may fall through");
1926 else if (!gimple_call_internal_p (prev, IFN_FALLTHROUGH)
1927 /* Try to be clever and don't warn when the statement
1928 can't actually fall through. */
1929 && gimple_stmt_may_fallthru (prev)
1930 && gimple_has_location (prev))
1931 warned_p = warning_at (gimple_location (prev),
1932 OPT_Wimplicit_fallthrough_,
1933 "this statement may fall through");
1934 if (warned_p)
1935 inform (gimple_location (next), "here");
1937 /* Mark this label as processed so as to prevent multiple
1938 warnings in nested switches. */
1939 FALLTHROUGH_LABEL_P (label) = true;
1941 /* So that next warn_implicit_fallthrough_r will start looking for
1942 a new sequence starting with this label. */
1943 gsi_prev (gsi_p);
1946 break;
1947 default:
1948 break;
1950 return NULL_TREE;
1953 /* Warn when a switch case falls through. */
1955 static void
1956 maybe_warn_implicit_fallthrough (gimple_seq seq)
1958 if (!warn_implicit_fallthrough)
1959 return;
1961 /* This warning is meant for C/C++/ObjC/ObjC++ only. */
1962 if (!(lang_GNU_C ()
1963 || lang_GNU_CXX ()
1964 || lang_GNU_OBJC ()))
1965 return;
1967 struct walk_stmt_info wi;
1968 memset (&wi, 0, sizeof (wi));
1969 walk_gimple_seq (seq, warn_implicit_fallthrough_r, NULL, &wi);
1972 /* Callback for walk_gimple_seq. */
1974 static tree
1975 expand_FALLTHROUGH_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
1976 struct walk_stmt_info *)
1978 gimple *stmt = gsi_stmt (*gsi_p);
1980 *handled_ops_p = true;
1981 switch (gimple_code (stmt))
1983 case GIMPLE_TRY:
1984 case GIMPLE_BIND:
1985 case GIMPLE_CATCH:
1986 case GIMPLE_EH_FILTER:
1987 case GIMPLE_TRANSACTION:
1988 /* Walk the sub-statements. */
1989 *handled_ops_p = false;
1990 break;
1991 case GIMPLE_CALL:
1992 if (gimple_call_internal_p (stmt, IFN_FALLTHROUGH))
1994 gsi_remove (gsi_p, true);
1995 if (gsi_end_p (*gsi_p))
1996 return integer_zero_node;
1998 bool found = false;
1999 location_t loc = gimple_location (stmt);
2001 gimple_stmt_iterator gsi2 = *gsi_p;
2002 stmt = gsi_stmt (gsi2);
2003 if (gimple_code (stmt) == GIMPLE_GOTO && !gimple_has_location (stmt))
2005 /* Go on until the artificial label. */
2006 tree goto_dest = gimple_goto_dest (stmt);
2007 for (; !gsi_end_p (gsi2); gsi_next (&gsi2))
2009 if (gimple_code (gsi_stmt (gsi2)) == GIMPLE_LABEL
2010 && gimple_label_label (as_a <glabel *> (gsi_stmt (gsi2)))
2011 == goto_dest)
2012 break;
2015 /* Not found? Stop. */
2016 if (gsi_end_p (gsi2))
2017 break;
2019 /* Look one past it. */
2020 gsi_next (&gsi2);
2023 /* We're looking for a case label or default label here. */
2024 while (!gsi_end_p (gsi2))
2026 stmt = gsi_stmt (gsi2);
2027 if (gimple_code (stmt) == GIMPLE_LABEL)
2029 tree label = gimple_label_label (as_a <glabel *> (stmt));
2030 if (gimple_has_location (stmt) && DECL_ARTIFICIAL (label))
2032 found = true;
2033 break;
2036 else
2037 /* Something other than a label. That's not expected. */
2038 break;
2039 gsi_next (&gsi2);
2041 if (!found)
2042 warning_at (loc, 0, "attribute %<fallthrough%> not preceding "
2043 "a case label or default label");
2045 break;
2046 default:
2047 break;
2049 return NULL_TREE;
2052 /* Expand all FALLTHROUGH () calls in SEQ. */
2054 static void
2055 expand_FALLTHROUGH (gimple_seq *seq_p)
2057 struct walk_stmt_info wi;
2058 memset (&wi, 0, sizeof (wi));
2059 walk_gimple_seq_mod (seq_p, expand_FALLTHROUGH_r, NULL, &wi);
2063 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
2064 branch to. */
2066 static enum gimplify_status
2067 gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
2069 tree switch_expr = *expr_p;
2070 gimple_seq switch_body_seq = NULL;
2071 enum gimplify_status ret;
2072 tree index_type = TREE_TYPE (switch_expr);
2073 if (index_type == NULL_TREE)
2074 index_type = TREE_TYPE (SWITCH_COND (switch_expr));
2076 ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, is_gimple_val,
2077 fb_rvalue);
2078 if (ret == GS_ERROR || ret == GS_UNHANDLED)
2079 return ret;
2081 if (SWITCH_BODY (switch_expr))
2083 vec<tree> labels;
2084 vec<tree> saved_labels;
2085 tree default_case = NULL_TREE;
2086 gswitch *switch_stmt;
2088 /* If someone can be bothered to fill in the labels, they can
2089 be bothered to null out the body too. */
2090 gcc_assert (!SWITCH_LABELS (switch_expr));
2092 /* Save old labels, get new ones from body, then restore the old
2093 labels. Save all the things from the switch body to append after. */
2094 saved_labels = gimplify_ctxp->case_labels;
2095 gimplify_ctxp->case_labels.create (8);
2096 bool old_in_switch_expr = gimplify_ctxp->in_switch_expr;
2097 gimplify_ctxp->in_switch_expr = true;
2099 gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq);
2101 gimplify_ctxp->in_switch_expr = old_in_switch_expr;
2102 maybe_warn_switch_unreachable (switch_body_seq);
2103 maybe_warn_implicit_fallthrough (switch_body_seq);
2104 /* Only do this for the outermost GIMPLE_SWITCH. */
2105 if (!gimplify_ctxp->in_switch_expr)
2106 expand_FALLTHROUGH (&switch_body_seq);
2108 labels = gimplify_ctxp->case_labels;
2109 gimplify_ctxp->case_labels = saved_labels;
2111 preprocess_case_label_vec_for_gimple (labels, index_type,
2112 &default_case);
2114 if (!default_case)
2116 glabel *new_default;
2118 default_case
2119 = build_case_label (NULL_TREE, NULL_TREE,
2120 create_artificial_label (UNKNOWN_LOCATION));
2121 new_default = gimple_build_label (CASE_LABEL (default_case));
2122 gimplify_seq_add_stmt (&switch_body_seq, new_default);
2125 switch_stmt = gimple_build_switch (SWITCH_COND (switch_expr),
2126 default_case, labels);
2127 gimplify_seq_add_stmt (pre_p, switch_stmt);
2128 gimplify_seq_add_seq (pre_p, switch_body_seq);
2129 labels.release ();
2131 else
2132 gcc_assert (SWITCH_LABELS (switch_expr));
2134 return GS_ALL_DONE;
2137 /* Gimplify the LABEL_EXPR pointed to by EXPR_P. */
2139 static enum gimplify_status
2140 gimplify_label_expr (tree *expr_p, gimple_seq *pre_p)
2142 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
2143 == current_function_decl);
2145 glabel *label_stmt = gimple_build_label (LABEL_EXPR_LABEL (*expr_p));
2146 gimple_set_location (label_stmt, EXPR_LOCATION (*expr_p));
2147 gimplify_seq_add_stmt (pre_p, label_stmt);
2149 return GS_ALL_DONE;
2152 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
2154 static enum gimplify_status
2155 gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
2157 struct gimplify_ctx *ctxp;
2158 glabel *label_stmt;
2160 /* Invalid programs can play Duff's Device type games with, for example,
2161 #pragma omp parallel. At least in the C front end, we don't
2162 detect such invalid branches until after gimplification, in the
2163 diagnose_omp_blocks pass. */
2164 for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
2165 if (ctxp->case_labels.exists ())
2166 break;
2168 label_stmt = gimple_build_label (CASE_LABEL (*expr_p));
2169 gimple_set_location (label_stmt, EXPR_LOCATION (*expr_p));
2170 ctxp->case_labels.safe_push (*expr_p);
2171 gimplify_seq_add_stmt (pre_p, label_stmt);
2173 return GS_ALL_DONE;
2176 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
2177 if necessary. */
2179 tree
2180 build_and_jump (tree *label_p)
2182 if (label_p == NULL)
2183 /* If there's nowhere to jump, just fall through. */
2184 return NULL_TREE;
2186 if (*label_p == NULL_TREE)
2188 tree label = create_artificial_label (UNKNOWN_LOCATION);
2189 *label_p = label;
2192 return build1 (GOTO_EXPR, void_type_node, *label_p);
2195 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
2196 This also involves building a label to jump to and communicating it to
2197 gimplify_loop_expr through gimplify_ctxp->exit_label. */
2199 static enum gimplify_status
2200 gimplify_exit_expr (tree *expr_p)
2202 tree cond = TREE_OPERAND (*expr_p, 0);
2203 tree expr;
2205 expr = build_and_jump (&gimplify_ctxp->exit_label);
2206 expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
2207 *expr_p = expr;
2209 return GS_OK;
2212 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
2213 different from its canonical type, wrap the whole thing inside a
2214 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
2215 type.
2217 The canonical type of a COMPONENT_REF is the type of the field being
2218 referenced--unless the field is a bit-field which can be read directly
2219 in a smaller mode, in which case the canonical type is the
2220 sign-appropriate type corresponding to that mode. */
2222 static void
2223 canonicalize_component_ref (tree *expr_p)
2225 tree expr = *expr_p;
2226 tree type;
2228 gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
2230 if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
2231 type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
2232 else
2233 type = TREE_TYPE (TREE_OPERAND (expr, 1));
2235 /* One could argue that all the stuff below is not necessary for
2236 the non-bitfield case and declare it a FE error if type
2237 adjustment would be needed. */
2238 if (TREE_TYPE (expr) != type)
2240 #ifdef ENABLE_TYPES_CHECKING
2241 tree old_type = TREE_TYPE (expr);
2242 #endif
2243 int type_quals;
2245 /* We need to preserve qualifiers and propagate them from
2246 operand 0. */
2247 type_quals = TYPE_QUALS (type)
2248 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
2249 if (TYPE_QUALS (type) != type_quals)
2250 type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
2252 /* Set the type of the COMPONENT_REF to the underlying type. */
2253 TREE_TYPE (expr) = type;
2255 #ifdef ENABLE_TYPES_CHECKING
2256 /* It is now a FE error, if the conversion from the canonical
2257 type to the original expression type is not useless. */
2258 gcc_assert (useless_type_conversion_p (old_type, type));
2259 #endif
2263 /* If a NOP conversion is changing a pointer to array of foo to a pointer
2264 to foo, embed that change in the ADDR_EXPR by converting
2265 T array[U];
2266 (T *)&array
2268 &array[L]
2269 where L is the lower bound. For simplicity, only do this for constant
2270 lower bound.
2271 The constraint is that the type of &array[L] is trivially convertible
2272 to T *. */
2274 static void
2275 canonicalize_addr_expr (tree *expr_p)
2277 tree expr = *expr_p;
2278 tree addr_expr = TREE_OPERAND (expr, 0);
2279 tree datype, ddatype, pddatype;
2281 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
2282 if (!POINTER_TYPE_P (TREE_TYPE (expr))
2283 || TREE_CODE (addr_expr) != ADDR_EXPR)
2284 return;
2286 /* The addr_expr type should be a pointer to an array. */
2287 datype = TREE_TYPE (TREE_TYPE (addr_expr));
2288 if (TREE_CODE (datype) != ARRAY_TYPE)
2289 return;
2291 /* The pointer to element type shall be trivially convertible to
2292 the expression pointer type. */
2293 ddatype = TREE_TYPE (datype);
2294 pddatype = build_pointer_type (ddatype);
2295 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)),
2296 pddatype))
2297 return;
2299 /* The lower bound and element sizes must be constant. */
2300 if (!TYPE_SIZE_UNIT (ddatype)
2301 || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
2302 || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
2303 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
2304 return;
2306 /* All checks succeeded. Build a new node to merge the cast. */
2307 *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
2308 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
2309 NULL_TREE, NULL_TREE);
2310 *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
2312 /* We can have stripped a required restrict qualifier above. */
2313 if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
2314 *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
2317 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
2318 underneath as appropriate. */
2320 static enum gimplify_status
2321 gimplify_conversion (tree *expr_p)
2323 location_t loc = EXPR_LOCATION (*expr_p);
2324 gcc_assert (CONVERT_EXPR_P (*expr_p));
2326 /* Then strip away all but the outermost conversion. */
2327 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
2329 /* And remove the outermost conversion if it's useless. */
2330 if (tree_ssa_useless_type_conversion (*expr_p))
2331 *expr_p = TREE_OPERAND (*expr_p, 0);
2333 /* If we still have a conversion at the toplevel,
2334 then canonicalize some constructs. */
2335 if (CONVERT_EXPR_P (*expr_p))
2337 tree sub = TREE_OPERAND (*expr_p, 0);
2339 /* If a NOP conversion is changing the type of a COMPONENT_REF
2340 expression, then canonicalize its type now in order to expose more
2341 redundant conversions. */
2342 if (TREE_CODE (sub) == COMPONENT_REF)
2343 canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
2345 /* If a NOP conversion is changing a pointer to array of foo
2346 to a pointer to foo, embed that change in the ADDR_EXPR. */
2347 else if (TREE_CODE (sub) == ADDR_EXPR)
2348 canonicalize_addr_expr (expr_p);
2351 /* If we have a conversion to a non-register type force the
2352 use of a VIEW_CONVERT_EXPR instead. */
2353 if (CONVERT_EXPR_P (*expr_p) && !is_gimple_reg_type (TREE_TYPE (*expr_p)))
2354 *expr_p = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (*expr_p),
2355 TREE_OPERAND (*expr_p, 0));
2357 /* Canonicalize CONVERT_EXPR to NOP_EXPR. */
2358 if (TREE_CODE (*expr_p) == CONVERT_EXPR)
2359 TREE_SET_CODE (*expr_p, NOP_EXPR);
2361 return GS_OK;
2364 /* Nonlocal VLAs seen in the current function. */
2365 static hash_set<tree> *nonlocal_vlas;
2367 /* The VAR_DECLs created for nonlocal VLAs for debug info purposes. */
2368 static tree nonlocal_vla_vars;
2370 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
2371 DECL_VALUE_EXPR, and it's worth re-examining things. */
2373 static enum gimplify_status
2374 gimplify_var_or_parm_decl (tree *expr_p)
2376 tree decl = *expr_p;
2378 /* ??? If this is a local variable, and it has not been seen in any
2379 outer BIND_EXPR, then it's probably the result of a duplicate
2380 declaration, for which we've already issued an error. It would
2381 be really nice if the front end wouldn't leak these at all.
2382 Currently the only known culprit is C++ destructors, as seen
2383 in g++.old-deja/g++.jason/binding.C. */
2384 if (VAR_P (decl)
2385 && !DECL_SEEN_IN_BIND_EXPR_P (decl)
2386 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
2387 && decl_function_context (decl) == current_function_decl)
2389 gcc_assert (seen_error ());
2390 return GS_ERROR;
2393 /* When within an OMP context, notice uses of variables. */
2394 if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
2395 return GS_ALL_DONE;
2397 /* If the decl is an alias for another expression, substitute it now. */
2398 if (DECL_HAS_VALUE_EXPR_P (decl))
2400 tree value_expr = DECL_VALUE_EXPR (decl);
2402 /* For referenced nonlocal VLAs add a decl for debugging purposes
2403 to the current function. */
2404 if (VAR_P (decl)
2405 && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
2406 && nonlocal_vlas != NULL
2407 && TREE_CODE (value_expr) == INDIRECT_REF
2408 && TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
2409 && decl_function_context (decl) != current_function_decl)
2411 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
2412 while (ctx
2413 && (ctx->region_type == ORT_WORKSHARE
2414 || ctx->region_type == ORT_SIMD
2415 || ctx->region_type == ORT_ACC))
2416 ctx = ctx->outer_context;
2417 if (!ctx && !nonlocal_vlas->add (decl))
2419 tree copy = copy_node (decl);
2421 lang_hooks.dup_lang_specific_decl (copy);
2422 SET_DECL_RTL (copy, 0);
2423 TREE_USED (copy) = 1;
2424 DECL_CHAIN (copy) = nonlocal_vla_vars;
2425 nonlocal_vla_vars = copy;
2426 SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
2427 DECL_HAS_VALUE_EXPR_P (copy) = 1;
2431 *expr_p = unshare_expr (value_expr);
2432 return GS_OK;
2435 return GS_ALL_DONE;
2438 /* Recalculate the value of the TREE_SIDE_EFFECTS flag for T. */
2440 static void
2441 recalculate_side_effects (tree t)
2443 enum tree_code code = TREE_CODE (t);
2444 int len = TREE_OPERAND_LENGTH (t);
2445 int i;
2447 switch (TREE_CODE_CLASS (code))
2449 case tcc_expression:
2450 switch (code)
2452 case INIT_EXPR:
2453 case MODIFY_EXPR:
2454 case VA_ARG_EXPR:
2455 case PREDECREMENT_EXPR:
2456 case PREINCREMENT_EXPR:
2457 case POSTDECREMENT_EXPR:
2458 case POSTINCREMENT_EXPR:
2459 /* All of these have side-effects, no matter what their
2460 operands are. */
2461 return;
2463 default:
2464 break;
2466 /* Fall through. */
2468 case tcc_comparison: /* a comparison expression */
2469 case tcc_unary: /* a unary arithmetic expression */
2470 case tcc_binary: /* a binary arithmetic expression */
2471 case tcc_reference: /* a reference */
2472 case tcc_vl_exp: /* a function call */
2473 TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
2474 for (i = 0; i < len; ++i)
2476 tree op = TREE_OPERAND (t, i);
2477 if (op && TREE_SIDE_EFFECTS (op))
2478 TREE_SIDE_EFFECTS (t) = 1;
2480 break;
2482 case tcc_constant:
2483 /* No side-effects. */
2484 return;
2486 default:
2487 gcc_unreachable ();
2491 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
2492 node *EXPR_P.
2494 compound_lval
2495 : min_lval '[' val ']'
2496 | min_lval '.' ID
2497 | compound_lval '[' val ']'
2498 | compound_lval '.' ID
2500 This is not part of the original SIMPLE definition, which separates
2501 array and member references, but it seems reasonable to handle them
2502 together. Also, this way we don't run into problems with union
2503 aliasing; gcc requires that for accesses through a union to alias, the
2504 union reference must be explicit, which was not always the case when we
2505 were splitting up array and member refs.
2507 PRE_P points to the sequence where side effects that must happen before
2508 *EXPR_P should be stored.
2510 POST_P points to the sequence where side effects that must happen after
2511 *EXPR_P should be stored. */
2513 static enum gimplify_status
2514 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2515 fallback_t fallback)
2517 tree *p;
2518 enum gimplify_status ret = GS_ALL_DONE, tret;
2519 int i;
2520 location_t loc = EXPR_LOCATION (*expr_p);
2521 tree expr = *expr_p;
2523 /* Create a stack of the subexpressions so later we can walk them in
2524 order from inner to outer. */
2525 auto_vec<tree, 10> expr_stack;
2527 /* We can handle anything that get_inner_reference can deal with. */
2528 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
2530 restart:
2531 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2532 if (TREE_CODE (*p) == INDIRECT_REF)
2533 *p = fold_indirect_ref_loc (loc, *p);
2535 if (handled_component_p (*p))
2537 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2538 additional COMPONENT_REFs. */
2539 else if ((VAR_P (*p) || TREE_CODE (*p) == PARM_DECL)
2540 && gimplify_var_or_parm_decl (p) == GS_OK)
2541 goto restart;
2542 else
2543 break;
2545 expr_stack.safe_push (*p);
2548 gcc_assert (expr_stack.length ());
2550 /* Now EXPR_STACK is a stack of pointers to all the refs we've
2551 walked through and P points to the innermost expression.
2553 Java requires that we elaborated nodes in source order. That
2554 means we must gimplify the inner expression followed by each of
2555 the indices, in order. But we can't gimplify the inner
2556 expression until we deal with any variable bounds, sizes, or
2557 positions in order to deal with PLACEHOLDER_EXPRs.
2559 So we do this in three steps. First we deal with the annotations
2560 for any variables in the components, then we gimplify the base,
2561 then we gimplify any indices, from left to right. */
2562 for (i = expr_stack.length () - 1; i >= 0; i--)
2564 tree t = expr_stack[i];
2566 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2568 /* Gimplify the low bound and element type size and put them into
2569 the ARRAY_REF. If these values are set, they have already been
2570 gimplified. */
2571 if (TREE_OPERAND (t, 2) == NULL_TREE)
2573 tree low = unshare_expr (array_ref_low_bound (t));
2574 if (!is_gimple_min_invariant (low))
2576 TREE_OPERAND (t, 2) = low;
2577 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2578 post_p, is_gimple_reg,
2579 fb_rvalue);
2580 ret = MIN (ret, tret);
2583 else
2585 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2586 is_gimple_reg, fb_rvalue);
2587 ret = MIN (ret, tret);
2590 if (TREE_OPERAND (t, 3) == NULL_TREE)
2592 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
2593 tree elmt_size = unshare_expr (array_ref_element_size (t));
2594 tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
2596 /* Divide the element size by the alignment of the element
2597 type (above). */
2598 elmt_size
2599 = size_binop_loc (loc, EXACT_DIV_EXPR, elmt_size, factor);
2601 if (!is_gimple_min_invariant (elmt_size))
2603 TREE_OPERAND (t, 3) = elmt_size;
2604 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
2605 post_p, is_gimple_reg,
2606 fb_rvalue);
2607 ret = MIN (ret, tret);
2610 else
2612 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
2613 is_gimple_reg, fb_rvalue);
2614 ret = MIN (ret, tret);
2617 else if (TREE_CODE (t) == COMPONENT_REF)
2619 /* Set the field offset into T and gimplify it. */
2620 if (TREE_OPERAND (t, 2) == NULL_TREE)
2622 tree offset = unshare_expr (component_ref_field_offset (t));
2623 tree field = TREE_OPERAND (t, 1);
2624 tree factor
2625 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
2627 /* Divide the offset by its alignment. */
2628 offset = size_binop_loc (loc, EXACT_DIV_EXPR, offset, factor);
2630 if (!is_gimple_min_invariant (offset))
2632 TREE_OPERAND (t, 2) = offset;
2633 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2634 post_p, is_gimple_reg,
2635 fb_rvalue);
2636 ret = MIN (ret, tret);
2639 else
2641 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2642 is_gimple_reg, fb_rvalue);
2643 ret = MIN (ret, tret);
2648 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2649 so as to match the min_lval predicate. Failure to do so may result
2650 in the creation of large aggregate temporaries. */
2651 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
2652 fallback | fb_lvalue);
2653 ret = MIN (ret, tret);
2655 /* And finally, the indices and operands of ARRAY_REF. During this
2656 loop we also remove any useless conversions. */
2657 for (; expr_stack.length () > 0; )
2659 tree t = expr_stack.pop ();
2661 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2663 /* Gimplify the dimension. */
2664 if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
2666 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2667 is_gimple_val, fb_rvalue);
2668 ret = MIN (ret, tret);
2672 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
2674 /* The innermost expression P may have originally had
2675 TREE_SIDE_EFFECTS set which would have caused all the outer
2676 expressions in *EXPR_P leading to P to also have had
2677 TREE_SIDE_EFFECTS set. */
2678 recalculate_side_effects (t);
2681 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2682 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
2684 canonicalize_component_ref (expr_p);
2687 expr_stack.release ();
2689 gcc_assert (*expr_p == expr || ret != GS_ALL_DONE);
2691 return ret;
2694 /* Gimplify the self modifying expression pointed to by EXPR_P
2695 (++, --, +=, -=).
2697 PRE_P points to the list where side effects that must happen before
2698 *EXPR_P should be stored.
2700 POST_P points to the list where side effects that must happen after
2701 *EXPR_P should be stored.
2703 WANT_VALUE is nonzero iff we want to use the value of this expression
2704 in another expression.
2706 ARITH_TYPE is the type the computation should be performed in. */
2708 enum gimplify_status
2709 gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2710 bool want_value, tree arith_type)
2712 enum tree_code code;
2713 tree lhs, lvalue, rhs, t1;
2714 gimple_seq post = NULL, *orig_post_p = post_p;
2715 bool postfix;
2716 enum tree_code arith_code;
2717 enum gimplify_status ret;
2718 location_t loc = EXPR_LOCATION (*expr_p);
2720 code = TREE_CODE (*expr_p);
2722 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
2723 || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
2725 /* Prefix or postfix? */
2726 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
2727 /* Faster to treat as prefix if result is not used. */
2728 postfix = want_value;
2729 else
2730 postfix = false;
2732 /* For postfix, make sure the inner expression's post side effects
2733 are executed after side effects from this expression. */
2734 if (postfix)
2735 post_p = &post;
2737 /* Add or subtract? */
2738 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2739 arith_code = PLUS_EXPR;
2740 else
2741 arith_code = MINUS_EXPR;
2743 /* Gimplify the LHS into a GIMPLE lvalue. */
2744 lvalue = TREE_OPERAND (*expr_p, 0);
2745 ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
2746 if (ret == GS_ERROR)
2747 return ret;
2749 /* Extract the operands to the arithmetic operation. */
2750 lhs = lvalue;
2751 rhs = TREE_OPERAND (*expr_p, 1);
2753 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2754 that as the result value and in the postqueue operation. */
2755 if (postfix)
2757 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
2758 if (ret == GS_ERROR)
2759 return ret;
2761 lhs = get_initialized_tmp_var (lhs, pre_p, NULL);
2764 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2765 if (POINTER_TYPE_P (TREE_TYPE (lhs)))
2767 rhs = convert_to_ptrofftype_loc (loc, rhs);
2768 if (arith_code == MINUS_EXPR)
2769 rhs = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (rhs), rhs);
2770 t1 = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (*expr_p), lhs, rhs);
2772 else
2773 t1 = fold_convert (TREE_TYPE (*expr_p),
2774 fold_build2 (arith_code, arith_type,
2775 fold_convert (arith_type, lhs),
2776 fold_convert (arith_type, rhs)));
2778 if (postfix)
2780 gimplify_assign (lvalue, t1, pre_p);
2781 gimplify_seq_add_seq (orig_post_p, post);
2782 *expr_p = lhs;
2783 return GS_ALL_DONE;
2785 else
2787 *expr_p = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
2788 return GS_OK;
2792 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2794 static void
2795 maybe_with_size_expr (tree *expr_p)
2797 tree expr = *expr_p;
2798 tree type = TREE_TYPE (expr);
2799 tree size;
2801 /* If we've already wrapped this or the type is error_mark_node, we can't do
2802 anything. */
2803 if (TREE_CODE (expr) == WITH_SIZE_EXPR
2804 || type == error_mark_node)
2805 return;
2807 /* If the size isn't known or is a constant, we have nothing to do. */
2808 size = TYPE_SIZE_UNIT (type);
2809 if (!size || TREE_CODE (size) == INTEGER_CST)
2810 return;
2812 /* Otherwise, make a WITH_SIZE_EXPR. */
2813 size = unshare_expr (size);
2814 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
2815 *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
2818 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2819 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2820 the CALL_EXPR. If ALLOW_SSA is set the actual parameter may be
2821 gimplified to an SSA name. */
2823 enum gimplify_status
2824 gimplify_arg (tree *arg_p, gimple_seq *pre_p, location_t call_location,
2825 bool allow_ssa)
2827 bool (*test) (tree);
2828 fallback_t fb;
2830 /* In general, we allow lvalues for function arguments to avoid
2831 extra overhead of copying large aggregates out of even larger
2832 aggregates into temporaries only to copy the temporaries to
2833 the argument list. Make optimizers happy by pulling out to
2834 temporaries those types that fit in registers. */
2835 if (is_gimple_reg_type (TREE_TYPE (*arg_p)))
2836 test = is_gimple_val, fb = fb_rvalue;
2837 else
2839 test = is_gimple_lvalue, fb = fb_either;
2840 /* Also strip a TARGET_EXPR that would force an extra copy. */
2841 if (TREE_CODE (*arg_p) == TARGET_EXPR)
2843 tree init = TARGET_EXPR_INITIAL (*arg_p);
2844 if (init
2845 && !VOID_TYPE_P (TREE_TYPE (init)))
2846 *arg_p = init;
2850 /* If this is a variable sized type, we must remember the size. */
2851 maybe_with_size_expr (arg_p);
2853 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2854 /* Make sure arguments have the same location as the function call
2855 itself. */
2856 protected_set_expr_location (*arg_p, call_location);
2858 /* There is a sequence point before a function call. Side effects in
2859 the argument list must occur before the actual call. So, when
2860 gimplifying arguments, force gimplify_expr to use an internal
2861 post queue which is then appended to the end of PRE_P. */
2862 return gimplify_expr (arg_p, pre_p, NULL, test, fb, allow_ssa);
2865 /* Don't fold inside offloading or taskreg regions: it can break code by
2866 adding decl references that weren't in the source. We'll do it during
2867 omplower pass instead. */
2869 static bool
2870 maybe_fold_stmt (gimple_stmt_iterator *gsi)
2872 struct gimplify_omp_ctx *ctx;
2873 for (ctx = gimplify_omp_ctxp; ctx; ctx = ctx->outer_context)
2874 if ((ctx->region_type & (ORT_TARGET | ORT_PARALLEL | ORT_TASK)) != 0)
2875 return false;
2876 return fold_stmt (gsi);
2879 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2880 WANT_VALUE is true if the result of the call is desired. */
2882 static enum gimplify_status
2883 gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
2885 tree fndecl, parms, p, fnptrtype;
2886 enum gimplify_status ret;
2887 int i, nargs;
2888 gcall *call;
2889 bool builtin_va_start_p = false;
2890 location_t loc = EXPR_LOCATION (*expr_p);
2892 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2894 /* For reliable diagnostics during inlining, it is necessary that
2895 every call_expr be annotated with file and line. */
2896 if (! EXPR_HAS_LOCATION (*expr_p))
2897 SET_EXPR_LOCATION (*expr_p, input_location);
2899 /* Gimplify internal functions created in the FEs. */
2900 if (CALL_EXPR_FN (*expr_p) == NULL_TREE)
2902 if (want_value)
2903 return GS_ALL_DONE;
2905 nargs = call_expr_nargs (*expr_p);
2906 enum internal_fn ifn = CALL_EXPR_IFN (*expr_p);
2907 auto_vec<tree> vargs (nargs);
2909 for (i = 0; i < nargs; i++)
2911 gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
2912 EXPR_LOCATION (*expr_p));
2913 vargs.quick_push (CALL_EXPR_ARG (*expr_p, i));
2915 gimple *call = gimple_build_call_internal_vec (ifn, vargs);
2916 gimplify_seq_add_stmt (pre_p, call);
2917 return GS_ALL_DONE;
2920 /* This may be a call to a builtin function.
2922 Builtin function calls may be transformed into different
2923 (and more efficient) builtin function calls under certain
2924 circumstances. Unfortunately, gimplification can muck things
2925 up enough that the builtin expanders are not aware that certain
2926 transformations are still valid.
2928 So we attempt transformation/gimplification of the call before
2929 we gimplify the CALL_EXPR. At this time we do not manage to
2930 transform all calls in the same manner as the expanders do, but
2931 we do transform most of them. */
2932 fndecl = get_callee_fndecl (*expr_p);
2933 if (fndecl
2934 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
2935 switch (DECL_FUNCTION_CODE (fndecl))
2937 case BUILT_IN_ALLOCA:
2938 case BUILT_IN_ALLOCA_WITH_ALIGN:
2939 /* If the call has been built for a variable-sized object, then we
2940 want to restore the stack level when the enclosing BIND_EXPR is
2941 exited to reclaim the allocated space; otherwise, we precisely
2942 need to do the opposite and preserve the latest stack level. */
2943 if (CALL_ALLOCA_FOR_VAR_P (*expr_p))
2944 gimplify_ctxp->save_stack = true;
2945 else
2946 gimplify_ctxp->keep_stack = true;
2947 break;
2949 case BUILT_IN_VA_START:
2951 builtin_va_start_p = TRUE;
2952 if (call_expr_nargs (*expr_p) < 2)
2954 error ("too few arguments to function %<va_start%>");
2955 *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2956 return GS_OK;
2959 if (fold_builtin_next_arg (*expr_p, true))
2961 *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2962 return GS_OK;
2964 break;
2967 default:
2970 if (fndecl && DECL_BUILT_IN (fndecl))
2972 tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2973 if (new_tree && new_tree != *expr_p)
2975 /* There was a transformation of this call which computes the
2976 same value, but in a more efficient way. Return and try
2977 again. */
2978 *expr_p = new_tree;
2979 return GS_OK;
2983 /* Remember the original function pointer type. */
2984 fnptrtype = TREE_TYPE (CALL_EXPR_FN (*expr_p));
2986 /* There is a sequence point before the call, so any side effects in
2987 the calling expression must occur before the actual call. Force
2988 gimplify_expr to use an internal post queue. */
2989 ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
2990 is_gimple_call_addr, fb_rvalue);
2992 nargs = call_expr_nargs (*expr_p);
2994 /* Get argument types for verification. */
2995 fndecl = get_callee_fndecl (*expr_p);
2996 parms = NULL_TREE;
2997 if (fndecl)
2998 parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2999 else
3000 parms = TYPE_ARG_TYPES (TREE_TYPE (fnptrtype));
3002 if (fndecl && DECL_ARGUMENTS (fndecl))
3003 p = DECL_ARGUMENTS (fndecl);
3004 else if (parms)
3005 p = parms;
3006 else
3007 p = NULL_TREE;
3008 for (i = 0; i < nargs && p; i++, p = TREE_CHAIN (p))
3011 /* If the last argument is __builtin_va_arg_pack () and it is not
3012 passed as a named argument, decrease the number of CALL_EXPR
3013 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
3014 if (!p
3015 && i < nargs
3016 && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
3018 tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
3019 tree last_arg_fndecl = get_callee_fndecl (last_arg);
3021 if (last_arg_fndecl
3022 && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
3023 && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
3024 && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
3026 tree call = *expr_p;
3028 --nargs;
3029 *expr_p = build_call_array_loc (loc, TREE_TYPE (call),
3030 CALL_EXPR_FN (call),
3031 nargs, CALL_EXPR_ARGP (call));
3033 /* Copy all CALL_EXPR flags, location and block, except
3034 CALL_EXPR_VA_ARG_PACK flag. */
3035 CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
3036 CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
3037 CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
3038 = CALL_EXPR_RETURN_SLOT_OPT (call);
3039 CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
3040 SET_EXPR_LOCATION (*expr_p, EXPR_LOCATION (call));
3042 /* Set CALL_EXPR_VA_ARG_PACK. */
3043 CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
3047 /* If the call returns twice then after building the CFG the call
3048 argument computations will no longer dominate the call because
3049 we add an abnormal incoming edge to the call. So do not use SSA
3050 vars there. */
3051 bool returns_twice = call_expr_flags (*expr_p) & ECF_RETURNS_TWICE;
3053 /* Gimplify the function arguments. */
3054 if (nargs > 0)
3056 for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
3057 PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
3058 PUSH_ARGS_REVERSED ? i-- : i++)
3060 enum gimplify_status t;
3062 /* Avoid gimplifying the second argument to va_start, which needs to
3063 be the plain PARM_DECL. */
3064 if ((i != 1) || !builtin_va_start_p)
3066 t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
3067 EXPR_LOCATION (*expr_p), ! returns_twice);
3069 if (t == GS_ERROR)
3070 ret = GS_ERROR;
3075 /* Gimplify the static chain. */
3076 if (CALL_EXPR_STATIC_CHAIN (*expr_p))
3078 if (fndecl && !DECL_STATIC_CHAIN (fndecl))
3079 CALL_EXPR_STATIC_CHAIN (*expr_p) = NULL;
3080 else
3082 enum gimplify_status t;
3083 t = gimplify_arg (&CALL_EXPR_STATIC_CHAIN (*expr_p), pre_p,
3084 EXPR_LOCATION (*expr_p), ! returns_twice);
3085 if (t == GS_ERROR)
3086 ret = GS_ERROR;
3090 /* Verify the function result. */
3091 if (want_value && fndecl
3092 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype))))
3094 error_at (loc, "using result of function returning %<void%>");
3095 ret = GS_ERROR;
3098 /* Try this again in case gimplification exposed something. */
3099 if (ret != GS_ERROR)
3101 tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
3103 if (new_tree && new_tree != *expr_p)
3105 /* There was a transformation of this call which computes the
3106 same value, but in a more efficient way. Return and try
3107 again. */
3108 *expr_p = new_tree;
3109 return GS_OK;
3112 else
3114 *expr_p = error_mark_node;
3115 return GS_ERROR;
3118 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
3119 decl. This allows us to eliminate redundant or useless
3120 calls to "const" functions. */
3121 if (TREE_CODE (*expr_p) == CALL_EXPR)
3123 int flags = call_expr_flags (*expr_p);
3124 if (flags & (ECF_CONST | ECF_PURE)
3125 /* An infinite loop is considered a side effect. */
3126 && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
3127 TREE_SIDE_EFFECTS (*expr_p) = 0;
3130 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
3131 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
3132 form and delegate the creation of a GIMPLE_CALL to
3133 gimplify_modify_expr. This is always possible because when
3134 WANT_VALUE is true, the caller wants the result of this call into
3135 a temporary, which means that we will emit an INIT_EXPR in
3136 internal_get_tmp_var which will then be handled by
3137 gimplify_modify_expr. */
3138 if (!want_value)
3140 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
3141 have to do is replicate it as a GIMPLE_CALL tuple. */
3142 gimple_stmt_iterator gsi;
3143 call = gimple_build_call_from_tree (*expr_p);
3144 gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
3145 notice_special_calls (call);
3146 gimplify_seq_add_stmt (pre_p, call);
3147 gsi = gsi_last (*pre_p);
3148 maybe_fold_stmt (&gsi);
3149 *expr_p = NULL_TREE;
3151 else
3152 /* Remember the original function type. */
3153 CALL_EXPR_FN (*expr_p) = build1 (NOP_EXPR, fnptrtype,
3154 CALL_EXPR_FN (*expr_p));
3156 return ret;
3159 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
3160 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
3162 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
3163 condition is true or false, respectively. If null, we should generate
3164 our own to skip over the evaluation of this specific expression.
3166 LOCUS is the source location of the COND_EXPR.
3168 This function is the tree equivalent of do_jump.
3170 shortcut_cond_r should only be called by shortcut_cond_expr. */
3172 static tree
3173 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p,
3174 location_t locus)
3176 tree local_label = NULL_TREE;
3177 tree t, expr = NULL;
3179 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
3180 retain the shortcut semantics. Just insert the gotos here;
3181 shortcut_cond_expr will append the real blocks later. */
3182 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
3184 location_t new_locus;
3186 /* Turn if (a && b) into
3188 if (a); else goto no;
3189 if (b) goto yes; else goto no;
3190 (no:) */
3192 if (false_label_p == NULL)
3193 false_label_p = &local_label;
3195 /* Keep the original source location on the first 'if'. */
3196 t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p, locus);
3197 append_to_statement_list (t, &expr);
3199 /* Set the source location of the && on the second 'if'. */
3200 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
3201 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
3202 new_locus);
3203 append_to_statement_list (t, &expr);
3205 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
3207 location_t new_locus;
3209 /* Turn if (a || b) into
3211 if (a) goto yes;
3212 if (b) goto yes; else goto no;
3213 (yes:) */
3215 if (true_label_p == NULL)
3216 true_label_p = &local_label;
3218 /* Keep the original source location on the first 'if'. */
3219 t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL, locus);
3220 append_to_statement_list (t, &expr);
3222 /* Set the source location of the || on the second 'if'. */
3223 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
3224 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
3225 new_locus);
3226 append_to_statement_list (t, &expr);
3228 else if (TREE_CODE (pred) == COND_EXPR
3229 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 1)))
3230 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 2))))
3232 location_t new_locus;
3234 /* As long as we're messing with gotos, turn if (a ? b : c) into
3235 if (a)
3236 if (b) goto yes; else goto no;
3237 else
3238 if (c) goto yes; else goto no;
3240 Don't do this if one of the arms has void type, which can happen
3241 in C++ when the arm is throw. */
3243 /* Keep the original source location on the first 'if'. Set the source
3244 location of the ? on the second 'if'. */
3245 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
3246 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
3247 shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
3248 false_label_p, locus),
3249 shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
3250 false_label_p, new_locus));
3252 else
3254 expr = build3 (COND_EXPR, void_type_node, pred,
3255 build_and_jump (true_label_p),
3256 build_and_jump (false_label_p));
3257 SET_EXPR_LOCATION (expr, locus);
3260 if (local_label)
3262 t = build1 (LABEL_EXPR, void_type_node, local_label);
3263 append_to_statement_list (t, &expr);
3266 return expr;
3269 /* Given a conditional expression EXPR with short-circuit boolean
3270 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
3271 predicate apart into the equivalent sequence of conditionals. */
3273 static tree
3274 shortcut_cond_expr (tree expr)
3276 tree pred = TREE_OPERAND (expr, 0);
3277 tree then_ = TREE_OPERAND (expr, 1);
3278 tree else_ = TREE_OPERAND (expr, 2);
3279 tree true_label, false_label, end_label, t;
3280 tree *true_label_p;
3281 tree *false_label_p;
3282 bool emit_end, emit_false, jump_over_else;
3283 bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
3284 bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
3286 /* First do simple transformations. */
3287 if (!else_se)
3289 /* If there is no 'else', turn
3290 if (a && b) then c
3291 into
3292 if (a) if (b) then c. */
3293 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
3295 /* Keep the original source location on the first 'if'. */
3296 location_t locus = EXPR_LOC_OR_LOC (expr, input_location);
3297 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
3298 /* Set the source location of the && on the second 'if'. */
3299 if (EXPR_HAS_LOCATION (pred))
3300 SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
3301 then_ = shortcut_cond_expr (expr);
3302 then_se = then_ && TREE_SIDE_EFFECTS (then_);
3303 pred = TREE_OPERAND (pred, 0);
3304 expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
3305 SET_EXPR_LOCATION (expr, locus);
3309 if (!then_se)
3311 /* If there is no 'then', turn
3312 if (a || b); else d
3313 into
3314 if (a); else if (b); else d. */
3315 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
3317 /* Keep the original source location on the first 'if'. */
3318 location_t locus = EXPR_LOC_OR_LOC (expr, input_location);
3319 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
3320 /* Set the source location of the || on the second 'if'. */
3321 if (EXPR_HAS_LOCATION (pred))
3322 SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
3323 else_ = shortcut_cond_expr (expr);
3324 else_se = else_ && TREE_SIDE_EFFECTS (else_);
3325 pred = TREE_OPERAND (pred, 0);
3326 expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
3327 SET_EXPR_LOCATION (expr, locus);
3331 /* If we're done, great. */
3332 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
3333 && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
3334 return expr;
3336 /* Otherwise we need to mess with gotos. Change
3337 if (a) c; else d;
3339 if (a); else goto no;
3340 c; goto end;
3341 no: d; end:
3342 and recursively gimplify the condition. */
3344 true_label = false_label = end_label = NULL_TREE;
3346 /* If our arms just jump somewhere, hijack those labels so we don't
3347 generate jumps to jumps. */
3349 if (then_
3350 && TREE_CODE (then_) == GOTO_EXPR
3351 && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
3353 true_label = GOTO_DESTINATION (then_);
3354 then_ = NULL;
3355 then_se = false;
3358 if (else_
3359 && TREE_CODE (else_) == GOTO_EXPR
3360 && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
3362 false_label = GOTO_DESTINATION (else_);
3363 else_ = NULL;
3364 else_se = false;
3367 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
3368 if (true_label)
3369 true_label_p = &true_label;
3370 else
3371 true_label_p = NULL;
3373 /* The 'else' branch also needs a label if it contains interesting code. */
3374 if (false_label || else_se)
3375 false_label_p = &false_label;
3376 else
3377 false_label_p = NULL;
3379 /* If there was nothing else in our arms, just forward the label(s). */
3380 if (!then_se && !else_se)
3381 return shortcut_cond_r (pred, true_label_p, false_label_p,
3382 EXPR_LOC_OR_LOC (expr, input_location));
3384 /* If our last subexpression already has a terminal label, reuse it. */
3385 if (else_se)
3386 t = expr_last (else_);
3387 else if (then_se)
3388 t = expr_last (then_);
3389 else
3390 t = NULL;
3391 if (t && TREE_CODE (t) == LABEL_EXPR)
3392 end_label = LABEL_EXPR_LABEL (t);
3394 /* If we don't care about jumping to the 'else' branch, jump to the end
3395 if the condition is false. */
3396 if (!false_label_p)
3397 false_label_p = &end_label;
3399 /* We only want to emit these labels if we aren't hijacking them. */
3400 emit_end = (end_label == NULL_TREE);
3401 emit_false = (false_label == NULL_TREE);
3403 /* We only emit the jump over the else clause if we have to--if the
3404 then clause may fall through. Otherwise we can wind up with a
3405 useless jump and a useless label at the end of gimplified code,
3406 which will cause us to think that this conditional as a whole
3407 falls through even if it doesn't. If we then inline a function
3408 which ends with such a condition, that can cause us to issue an
3409 inappropriate warning about control reaching the end of a
3410 non-void function. */
3411 jump_over_else = block_may_fallthru (then_);
3413 pred = shortcut_cond_r (pred, true_label_p, false_label_p,
3414 EXPR_LOC_OR_LOC (expr, input_location));
3416 expr = NULL;
3417 append_to_statement_list (pred, &expr);
3419 append_to_statement_list (then_, &expr);
3420 if (else_se)
3422 if (jump_over_else)
3424 tree last = expr_last (expr);
3425 t = build_and_jump (&end_label);
3426 if (EXPR_HAS_LOCATION (last))
3427 SET_EXPR_LOCATION (t, EXPR_LOCATION (last));
3428 append_to_statement_list (t, &expr);
3430 if (emit_false)
3432 t = build1 (LABEL_EXPR, void_type_node, false_label);
3433 append_to_statement_list (t, &expr);
3435 append_to_statement_list (else_, &expr);
3437 if (emit_end && end_label)
3439 t = build1 (LABEL_EXPR, void_type_node, end_label);
3440 append_to_statement_list (t, &expr);
3443 return expr;
3446 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
3448 tree
3449 gimple_boolify (tree expr)
3451 tree type = TREE_TYPE (expr);
3452 location_t loc = EXPR_LOCATION (expr);
3454 if (TREE_CODE (expr) == NE_EXPR
3455 && TREE_CODE (TREE_OPERAND (expr, 0)) == CALL_EXPR
3456 && integer_zerop (TREE_OPERAND (expr, 1)))
3458 tree call = TREE_OPERAND (expr, 0);
3459 tree fn = get_callee_fndecl (call);
3461 /* For __builtin_expect ((long) (x), y) recurse into x as well
3462 if x is truth_value_p. */
3463 if (fn
3464 && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
3465 && DECL_FUNCTION_CODE (fn) == BUILT_IN_EXPECT
3466 && call_expr_nargs (call) == 2)
3468 tree arg = CALL_EXPR_ARG (call, 0);
3469 if (arg)
3471 if (TREE_CODE (arg) == NOP_EXPR
3472 && TREE_TYPE (arg) == TREE_TYPE (call))
3473 arg = TREE_OPERAND (arg, 0);
3474 if (truth_value_p (TREE_CODE (arg)))
3476 arg = gimple_boolify (arg);
3477 CALL_EXPR_ARG (call, 0)
3478 = fold_convert_loc (loc, TREE_TYPE (call), arg);
3484 switch (TREE_CODE (expr))
3486 case TRUTH_AND_EXPR:
3487 case TRUTH_OR_EXPR:
3488 case TRUTH_XOR_EXPR:
3489 case TRUTH_ANDIF_EXPR:
3490 case TRUTH_ORIF_EXPR:
3491 /* Also boolify the arguments of truth exprs. */
3492 TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
3493 /* FALLTHRU */
3495 case TRUTH_NOT_EXPR:
3496 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
3498 /* These expressions always produce boolean results. */
3499 if (TREE_CODE (type) != BOOLEAN_TYPE)
3500 TREE_TYPE (expr) = boolean_type_node;
3501 return expr;
3503 case ANNOTATE_EXPR:
3504 switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)))
3506 case annot_expr_ivdep_kind:
3507 case annot_expr_no_vector_kind:
3508 case annot_expr_vector_kind:
3509 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
3510 if (TREE_CODE (type) != BOOLEAN_TYPE)
3511 TREE_TYPE (expr) = boolean_type_node;
3512 return expr;
3513 default:
3514 gcc_unreachable ();
3517 default:
3518 if (COMPARISON_CLASS_P (expr))
3520 /* There expressions always prduce boolean results. */
3521 if (TREE_CODE (type) != BOOLEAN_TYPE)
3522 TREE_TYPE (expr) = boolean_type_node;
3523 return expr;
3525 /* Other expressions that get here must have boolean values, but
3526 might need to be converted to the appropriate mode. */
3527 if (TREE_CODE (type) == BOOLEAN_TYPE)
3528 return expr;
3529 return fold_convert_loc (loc, boolean_type_node, expr);
3533 /* Given a conditional expression *EXPR_P without side effects, gimplify
3534 its operands. New statements are inserted to PRE_P. */
3536 static enum gimplify_status
3537 gimplify_pure_cond_expr (tree *expr_p, gimple_seq *pre_p)
3539 tree expr = *expr_p, cond;
3540 enum gimplify_status ret, tret;
3541 enum tree_code code;
3543 cond = gimple_boolify (COND_EXPR_COND (expr));
3545 /* We need to handle && and || specially, as their gimplification
3546 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
3547 code = TREE_CODE (cond);
3548 if (code == TRUTH_ANDIF_EXPR)
3549 TREE_SET_CODE (cond, TRUTH_AND_EXPR);
3550 else if (code == TRUTH_ORIF_EXPR)
3551 TREE_SET_CODE (cond, TRUTH_OR_EXPR);
3552 ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
3553 COND_EXPR_COND (*expr_p) = cond;
3555 tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
3556 is_gimple_val, fb_rvalue);
3557 ret = MIN (ret, tret);
3558 tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
3559 is_gimple_val, fb_rvalue);
3561 return MIN (ret, tret);
3564 /* Return true if evaluating EXPR could trap.
3565 EXPR is GENERIC, while tree_could_trap_p can be called
3566 only on GIMPLE. */
3568 static bool
3569 generic_expr_could_trap_p (tree expr)
3571 unsigned i, n;
3573 if (!expr || is_gimple_val (expr))
3574 return false;
3576 if (!EXPR_P (expr) || tree_could_trap_p (expr))
3577 return true;
3579 n = TREE_OPERAND_LENGTH (expr);
3580 for (i = 0; i < n; i++)
3581 if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
3582 return true;
3584 return false;
3587 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3588 into
3590 if (p) if (p)
3591 t1 = a; a;
3592 else or else
3593 t1 = b; b;
3596 The second form is used when *EXPR_P is of type void.
3598 PRE_P points to the list where side effects that must happen before
3599 *EXPR_P should be stored. */
3601 static enum gimplify_status
3602 gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
3604 tree expr = *expr_p;
3605 tree type = TREE_TYPE (expr);
3606 location_t loc = EXPR_LOCATION (expr);
3607 tree tmp, arm1, arm2;
3608 enum gimplify_status ret;
3609 tree label_true, label_false, label_cont;
3610 bool have_then_clause_p, have_else_clause_p;
3611 gcond *cond_stmt;
3612 enum tree_code pred_code;
3613 gimple_seq seq = NULL;
3615 /* If this COND_EXPR has a value, copy the values into a temporary within
3616 the arms. */
3617 if (!VOID_TYPE_P (type))
3619 tree then_ = TREE_OPERAND (expr, 1), else_ = TREE_OPERAND (expr, 2);
3620 tree result;
3622 /* If either an rvalue is ok or we do not require an lvalue, create the
3623 temporary. But we cannot do that if the type is addressable. */
3624 if (((fallback & fb_rvalue) || !(fallback & fb_lvalue))
3625 && !TREE_ADDRESSABLE (type))
3627 if (gimplify_ctxp->allow_rhs_cond_expr
3628 /* If either branch has side effects or could trap, it can't be
3629 evaluated unconditionally. */
3630 && !TREE_SIDE_EFFECTS (then_)
3631 && !generic_expr_could_trap_p (then_)
3632 && !TREE_SIDE_EFFECTS (else_)
3633 && !generic_expr_could_trap_p (else_))
3634 return gimplify_pure_cond_expr (expr_p, pre_p);
3636 tmp = create_tmp_var (type, "iftmp");
3637 result = tmp;
3640 /* Otherwise, only create and copy references to the values. */
3641 else
3643 type = build_pointer_type (type);
3645 if (!VOID_TYPE_P (TREE_TYPE (then_)))
3646 then_ = build_fold_addr_expr_loc (loc, then_);
3648 if (!VOID_TYPE_P (TREE_TYPE (else_)))
3649 else_ = build_fold_addr_expr_loc (loc, else_);
3651 expr
3652 = build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), then_, else_);
3654 tmp = create_tmp_var (type, "iftmp");
3655 result = build_simple_mem_ref_loc (loc, tmp);
3658 /* Build the new then clause, `tmp = then_;'. But don't build the
3659 assignment if the value is void; in C++ it can be if it's a throw. */
3660 if (!VOID_TYPE_P (TREE_TYPE (then_)))
3661 TREE_OPERAND (expr, 1) = build2 (MODIFY_EXPR, type, tmp, then_);
3663 /* Similarly, build the new else clause, `tmp = else_;'. */
3664 if (!VOID_TYPE_P (TREE_TYPE (else_)))
3665 TREE_OPERAND (expr, 2) = build2 (MODIFY_EXPR, type, tmp, else_);
3667 TREE_TYPE (expr) = void_type_node;
3668 recalculate_side_effects (expr);
3670 /* Move the COND_EXPR to the prequeue. */
3671 gimplify_stmt (&expr, pre_p);
3673 *expr_p = result;
3674 return GS_ALL_DONE;
3677 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
3678 STRIP_TYPE_NOPS (TREE_OPERAND (expr, 0));
3679 if (TREE_CODE (TREE_OPERAND (expr, 0)) == COMPOUND_EXPR)
3680 gimplify_compound_expr (&TREE_OPERAND (expr, 0), pre_p, true);
3682 /* Make sure the condition has BOOLEAN_TYPE. */
3683 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
3685 /* Break apart && and || conditions. */
3686 if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
3687 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
3689 expr = shortcut_cond_expr (expr);
3691 if (expr != *expr_p)
3693 *expr_p = expr;
3695 /* We can't rely on gimplify_expr to re-gimplify the expanded
3696 form properly, as cleanups might cause the target labels to be
3697 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3698 set up a conditional context. */
3699 gimple_push_condition ();
3700 gimplify_stmt (expr_p, &seq);
3701 gimple_pop_condition (pre_p);
3702 gimple_seq_add_seq (pre_p, seq);
3704 return GS_ALL_DONE;
3708 /* Now do the normal gimplification. */
3710 /* Gimplify condition. */
3711 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, is_gimple_condexpr,
3712 fb_rvalue);
3713 if (ret == GS_ERROR)
3714 return GS_ERROR;
3715 gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
3717 gimple_push_condition ();
3719 have_then_clause_p = have_else_clause_p = false;
3720 if (TREE_OPERAND (expr, 1) != NULL
3721 && TREE_CODE (TREE_OPERAND (expr, 1)) == GOTO_EXPR
3722 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 1))) == LABEL_DECL
3723 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 1)))
3724 == current_function_decl)
3725 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3726 have different locations, otherwise we end up with incorrect
3727 location information on the branches. */
3728 && (optimize
3729 || !EXPR_HAS_LOCATION (expr)
3730 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 1))
3731 || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 1))))
3733 label_true = GOTO_DESTINATION (TREE_OPERAND (expr, 1));
3734 have_then_clause_p = true;
3736 else
3737 label_true = create_artificial_label (UNKNOWN_LOCATION);
3738 if (TREE_OPERAND (expr, 2) != NULL
3739 && TREE_CODE (TREE_OPERAND (expr, 2)) == GOTO_EXPR
3740 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 2))) == LABEL_DECL
3741 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 2)))
3742 == current_function_decl)
3743 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3744 have different locations, otherwise we end up with incorrect
3745 location information on the branches. */
3746 && (optimize
3747 || !EXPR_HAS_LOCATION (expr)
3748 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 2))
3749 || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 2))))
3751 label_false = GOTO_DESTINATION (TREE_OPERAND (expr, 2));
3752 have_else_clause_p = true;
3754 else
3755 label_false = create_artificial_label (UNKNOWN_LOCATION);
3757 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
3758 &arm2);
3759 cond_stmt = gimple_build_cond (pred_code, arm1, arm2, label_true,
3760 label_false);
3761 gimple_set_no_warning (cond_stmt, TREE_NO_WARNING (COND_EXPR_COND (expr)));
3762 gimplify_seq_add_stmt (&seq, cond_stmt);
3763 gimple_stmt_iterator gsi = gsi_last (seq);
3764 maybe_fold_stmt (&gsi);
3766 label_cont = NULL_TREE;
3767 if (!have_then_clause_p)
3769 /* For if (...) {} else { code; } put label_true after
3770 the else block. */
3771 if (TREE_OPERAND (expr, 1) == NULL_TREE
3772 && !have_else_clause_p
3773 && TREE_OPERAND (expr, 2) != NULL_TREE)
3774 label_cont = label_true;
3775 else
3777 gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
3778 have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
3779 /* For if (...) { code; } else {} or
3780 if (...) { code; } else goto label; or
3781 if (...) { code; return; } else { ... }
3782 label_cont isn't needed. */
3783 if (!have_else_clause_p
3784 && TREE_OPERAND (expr, 2) != NULL_TREE
3785 && gimple_seq_may_fallthru (seq))
3787 gimple *g;
3788 label_cont = create_artificial_label (UNKNOWN_LOCATION);
3790 g = gimple_build_goto (label_cont);
3792 /* GIMPLE_COND's are very low level; they have embedded
3793 gotos. This particular embedded goto should not be marked
3794 with the location of the original COND_EXPR, as it would
3795 correspond to the COND_EXPR's condition, not the ELSE or the
3796 THEN arms. To avoid marking it with the wrong location, flag
3797 it as "no location". */
3798 gimple_set_do_not_emit_location (g);
3800 gimplify_seq_add_stmt (&seq, g);
3804 if (!have_else_clause_p)
3806 gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
3807 have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
3809 if (label_cont)
3810 gimplify_seq_add_stmt (&seq, gimple_build_label (label_cont));
3812 gimple_pop_condition (pre_p);
3813 gimple_seq_add_seq (pre_p, seq);
3815 if (ret == GS_ERROR)
3816 ; /* Do nothing. */
3817 else if (have_then_clause_p || have_else_clause_p)
3818 ret = GS_ALL_DONE;
3819 else
3821 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3822 expr = TREE_OPERAND (expr, 0);
3823 gimplify_stmt (&expr, pre_p);
3826 *expr_p = NULL;
3827 return ret;
3830 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3831 to be marked addressable.
3833 We cannot rely on such an expression being directly markable if a temporary
3834 has been created by the gimplification. In this case, we create another
3835 temporary and initialize it with a copy, which will become a store after we
3836 mark it addressable. This can happen if the front-end passed us something
3837 that it could not mark addressable yet, like a Fortran pass-by-reference
3838 parameter (int) floatvar. */
3840 static void
3841 prepare_gimple_addressable (tree *expr_p, gimple_seq *seq_p)
3843 while (handled_component_p (*expr_p))
3844 expr_p = &TREE_OPERAND (*expr_p, 0);
3845 if (is_gimple_reg (*expr_p))
3847 /* Do not allow an SSA name as the temporary. */
3848 tree var = get_initialized_tmp_var (*expr_p, seq_p, NULL, false);
3849 DECL_GIMPLE_REG_P (var) = 0;
3850 *expr_p = var;
3854 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3855 a call to __builtin_memcpy. */
3857 static enum gimplify_status
3858 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
3859 gimple_seq *seq_p)
3861 tree t, to, to_ptr, from, from_ptr;
3862 gcall *gs;
3863 location_t loc = EXPR_LOCATION (*expr_p);
3865 to = TREE_OPERAND (*expr_p, 0);
3866 from = TREE_OPERAND (*expr_p, 1);
3868 /* Mark the RHS addressable. Beware that it may not be possible to do so
3869 directly if a temporary has been created by the gimplification. */
3870 prepare_gimple_addressable (&from, seq_p);
3872 mark_addressable (from);
3873 from_ptr = build_fold_addr_expr_loc (loc, from);
3874 gimplify_arg (&from_ptr, seq_p, loc);
3876 mark_addressable (to);
3877 to_ptr = build_fold_addr_expr_loc (loc, to);
3878 gimplify_arg (&to_ptr, seq_p, loc);
3880 t = builtin_decl_implicit (BUILT_IN_MEMCPY);
3882 gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
3884 if (want_value)
3886 /* tmp = memcpy() */
3887 t = create_tmp_var (TREE_TYPE (to_ptr));
3888 gimple_call_set_lhs (gs, t);
3889 gimplify_seq_add_stmt (seq_p, gs);
3891 *expr_p = build_simple_mem_ref (t);
3892 return GS_ALL_DONE;
3895 gimplify_seq_add_stmt (seq_p, gs);
3896 *expr_p = NULL;
3897 return GS_ALL_DONE;
3900 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3901 a call to __builtin_memset. In this case we know that the RHS is
3902 a CONSTRUCTOR with an empty element list. */
3904 static enum gimplify_status
3905 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
3906 gimple_seq *seq_p)
3908 tree t, from, to, to_ptr;
3909 gcall *gs;
3910 location_t loc = EXPR_LOCATION (*expr_p);
3912 /* Assert our assumptions, to abort instead of producing wrong code
3913 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3914 not be immediately exposed. */
3915 from = TREE_OPERAND (*expr_p, 1);
3916 if (TREE_CODE (from) == WITH_SIZE_EXPR)
3917 from = TREE_OPERAND (from, 0);
3919 gcc_assert (TREE_CODE (from) == CONSTRUCTOR
3920 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from)));
3922 /* Now proceed. */
3923 to = TREE_OPERAND (*expr_p, 0);
3925 to_ptr = build_fold_addr_expr_loc (loc, to);
3926 gimplify_arg (&to_ptr, seq_p, loc);
3927 t = builtin_decl_implicit (BUILT_IN_MEMSET);
3929 gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
3931 if (want_value)
3933 /* tmp = memset() */
3934 t = create_tmp_var (TREE_TYPE (to_ptr));
3935 gimple_call_set_lhs (gs, t);
3936 gimplify_seq_add_stmt (seq_p, gs);
3938 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3939 return GS_ALL_DONE;
3942 gimplify_seq_add_stmt (seq_p, gs);
3943 *expr_p = NULL;
3944 return GS_ALL_DONE;
3947 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3948 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3949 assignment. Return non-null if we detect a potential overlap. */
3951 struct gimplify_init_ctor_preeval_data
3953 /* The base decl of the lhs object. May be NULL, in which case we
3954 have to assume the lhs is indirect. */
3955 tree lhs_base_decl;
3957 /* The alias set of the lhs object. */
3958 alias_set_type lhs_alias_set;
3961 static tree
3962 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
3964 struct gimplify_init_ctor_preeval_data *data
3965 = (struct gimplify_init_ctor_preeval_data *) xdata;
3966 tree t = *tp;
3968 /* If we find the base object, obviously we have overlap. */
3969 if (data->lhs_base_decl == t)
3970 return t;
3972 /* If the constructor component is indirect, determine if we have a
3973 potential overlap with the lhs. The only bits of information we
3974 have to go on at this point are addressability and alias sets. */
3975 if ((INDIRECT_REF_P (t)
3976 || TREE_CODE (t) == MEM_REF)
3977 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3978 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
3979 return t;
3981 /* If the constructor component is a call, determine if it can hide a
3982 potential overlap with the lhs through an INDIRECT_REF like above.
3983 ??? Ugh - this is completely broken. In fact this whole analysis
3984 doesn't look conservative. */
3985 if (TREE_CODE (t) == CALL_EXPR)
3987 tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
3989 for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
3990 if (POINTER_TYPE_P (TREE_VALUE (type))
3991 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3992 && alias_sets_conflict_p (data->lhs_alias_set,
3993 get_alias_set
3994 (TREE_TYPE (TREE_VALUE (type)))))
3995 return t;
3998 if (IS_TYPE_OR_DECL_P (t))
3999 *walk_subtrees = 0;
4000 return NULL;
4003 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
4004 force values that overlap with the lhs (as described by *DATA)
4005 into temporaries. */
4007 static void
4008 gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
4009 struct gimplify_init_ctor_preeval_data *data)
4011 enum gimplify_status one;
4013 /* If the value is constant, then there's nothing to pre-evaluate. */
4014 if (TREE_CONSTANT (*expr_p))
4016 /* Ensure it does not have side effects, it might contain a reference to
4017 the object we're initializing. */
4018 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
4019 return;
4022 /* If the type has non-trivial constructors, we can't pre-evaluate. */
4023 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
4024 return;
4026 /* Recurse for nested constructors. */
4027 if (TREE_CODE (*expr_p) == CONSTRUCTOR)
4029 unsigned HOST_WIDE_INT ix;
4030 constructor_elt *ce;
4031 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (*expr_p);
4033 FOR_EACH_VEC_SAFE_ELT (v, ix, ce)
4034 gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
4036 return;
4039 /* If this is a variable sized type, we must remember the size. */
4040 maybe_with_size_expr (expr_p);
4042 /* Gimplify the constructor element to something appropriate for the rhs
4043 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
4044 the gimplifier will consider this a store to memory. Doing this
4045 gimplification now means that we won't have to deal with complicated
4046 language-specific trees, nor trees like SAVE_EXPR that can induce
4047 exponential search behavior. */
4048 one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
4049 if (one == GS_ERROR)
4051 *expr_p = NULL;
4052 return;
4055 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
4056 with the lhs, since "a = { .x=a }" doesn't make sense. This will
4057 always be true for all scalars, since is_gimple_mem_rhs insists on a
4058 temporary variable for them. */
4059 if (DECL_P (*expr_p))
4060 return;
4062 /* If this is of variable size, we have no choice but to assume it doesn't
4063 overlap since we can't make a temporary for it. */
4064 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
4065 return;
4067 /* Otherwise, we must search for overlap ... */
4068 if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
4069 return;
4071 /* ... and if found, force the value into a temporary. */
4072 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
4075 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
4076 a RANGE_EXPR in a CONSTRUCTOR for an array.
4078 var = lower;
4079 loop_entry:
4080 object[var] = value;
4081 if (var == upper)
4082 goto loop_exit;
4083 var = var + 1;
4084 goto loop_entry;
4085 loop_exit:
4087 We increment var _after_ the loop exit check because we might otherwise
4088 fail if upper == TYPE_MAX_VALUE (type for upper).
4090 Note that we never have to deal with SAVE_EXPRs here, because this has
4091 already been taken care of for us, in gimplify_init_ctor_preeval(). */
4093 static void gimplify_init_ctor_eval (tree, vec<constructor_elt, va_gc> *,
4094 gimple_seq *, bool);
4096 static void
4097 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
4098 tree value, tree array_elt_type,
4099 gimple_seq *pre_p, bool cleared)
4101 tree loop_entry_label, loop_exit_label, fall_thru_label;
4102 tree var, var_type, cref, tmp;
4104 loop_entry_label = create_artificial_label (UNKNOWN_LOCATION);
4105 loop_exit_label = create_artificial_label (UNKNOWN_LOCATION);
4106 fall_thru_label = create_artificial_label (UNKNOWN_LOCATION);
4108 /* Create and initialize the index variable. */
4109 var_type = TREE_TYPE (upper);
4110 var = create_tmp_var (var_type);
4111 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
4113 /* Add the loop entry label. */
4114 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
4116 /* Build the reference. */
4117 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
4118 var, NULL_TREE, NULL_TREE);
4120 /* If we are a constructor, just call gimplify_init_ctor_eval to do
4121 the store. Otherwise just assign value to the reference. */
4123 if (TREE_CODE (value) == CONSTRUCTOR)
4124 /* NB we might have to call ourself recursively through
4125 gimplify_init_ctor_eval if the value is a constructor. */
4126 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
4127 pre_p, cleared);
4128 else
4129 gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
4131 /* We exit the loop when the index var is equal to the upper bound. */
4132 gimplify_seq_add_stmt (pre_p,
4133 gimple_build_cond (EQ_EXPR, var, upper,
4134 loop_exit_label, fall_thru_label));
4136 gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
4138 /* Otherwise, increment the index var... */
4139 tmp = build2 (PLUS_EXPR, var_type, var,
4140 fold_convert (var_type, integer_one_node));
4141 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
4143 /* ...and jump back to the loop entry. */
4144 gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
4146 /* Add the loop exit label. */
4147 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
4150 /* Return true if FDECL is accessing a field that is zero sized. */
4152 static bool
4153 zero_sized_field_decl (const_tree fdecl)
4155 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
4156 && integer_zerop (DECL_SIZE (fdecl)))
4157 return true;
4158 return false;
4161 /* Return true if TYPE is zero sized. */
4163 static bool
4164 zero_sized_type (const_tree type)
4166 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
4167 && integer_zerop (TYPE_SIZE (type)))
4168 return true;
4169 return false;
4172 /* A subroutine of gimplify_init_constructor. Generate individual
4173 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
4174 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
4175 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
4176 zeroed first. */
4178 static void
4179 gimplify_init_ctor_eval (tree object, vec<constructor_elt, va_gc> *elts,
4180 gimple_seq *pre_p, bool cleared)
4182 tree array_elt_type = NULL;
4183 unsigned HOST_WIDE_INT ix;
4184 tree purpose, value;
4186 if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
4187 array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
4189 FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
4191 tree cref;
4193 /* NULL values are created above for gimplification errors. */
4194 if (value == NULL)
4195 continue;
4197 if (cleared && initializer_zerop (value))
4198 continue;
4200 /* ??? Here's to hoping the front end fills in all of the indices,
4201 so we don't have to figure out what's missing ourselves. */
4202 gcc_assert (purpose);
4204 /* Skip zero-sized fields, unless value has side-effects. This can
4205 happen with calls to functions returning a zero-sized type, which
4206 we shouldn't discard. As a number of downstream passes don't
4207 expect sets of zero-sized fields, we rely on the gimplification of
4208 the MODIFY_EXPR we make below to drop the assignment statement. */
4209 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
4210 continue;
4212 /* If we have a RANGE_EXPR, we have to build a loop to assign the
4213 whole range. */
4214 if (TREE_CODE (purpose) == RANGE_EXPR)
4216 tree lower = TREE_OPERAND (purpose, 0);
4217 tree upper = TREE_OPERAND (purpose, 1);
4219 /* If the lower bound is equal to upper, just treat it as if
4220 upper was the index. */
4221 if (simple_cst_equal (lower, upper))
4222 purpose = upper;
4223 else
4225 gimplify_init_ctor_eval_range (object, lower, upper, value,
4226 array_elt_type, pre_p, cleared);
4227 continue;
4231 if (array_elt_type)
4233 /* Do not use bitsizetype for ARRAY_REF indices. */
4234 if (TYPE_DOMAIN (TREE_TYPE (object)))
4235 purpose
4236 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
4237 purpose);
4238 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
4239 purpose, NULL_TREE, NULL_TREE);
4241 else
4243 gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
4244 cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
4245 unshare_expr (object), purpose, NULL_TREE);
4248 if (TREE_CODE (value) == CONSTRUCTOR
4249 && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
4250 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
4251 pre_p, cleared);
4252 else
4254 tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
4255 gimplify_and_add (init, pre_p);
4256 ggc_free (init);
4261 /* Return the appropriate RHS predicate for this LHS. */
4263 gimple_predicate
4264 rhs_predicate_for (tree lhs)
4266 if (is_gimple_reg (lhs))
4267 return is_gimple_reg_rhs_or_call;
4268 else
4269 return is_gimple_mem_rhs_or_call;
4272 /* Return the initial guess for an appropriate RHS predicate for this LHS,
4273 before the LHS has been gimplified. */
4275 static gimple_predicate
4276 initial_rhs_predicate_for (tree lhs)
4278 if (is_gimple_reg_type (TREE_TYPE (lhs)))
4279 return is_gimple_reg_rhs_or_call;
4280 else
4281 return is_gimple_mem_rhs_or_call;
4284 /* Gimplify a C99 compound literal expression. This just means adding
4285 the DECL_EXPR before the current statement and using its anonymous
4286 decl instead. */
4288 static enum gimplify_status
4289 gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p,
4290 bool (*gimple_test_f) (tree),
4291 fallback_t fallback)
4293 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
4294 tree decl = DECL_EXPR_DECL (decl_s);
4295 tree init = DECL_INITIAL (decl);
4296 /* Mark the decl as addressable if the compound literal
4297 expression is addressable now, otherwise it is marked too late
4298 after we gimplify the initialization expression. */
4299 if (TREE_ADDRESSABLE (*expr_p))
4300 TREE_ADDRESSABLE (decl) = 1;
4301 /* Otherwise, if we don't need an lvalue and have a literal directly
4302 substitute it. Check if it matches the gimple predicate, as
4303 otherwise we'd generate a new temporary, and we can as well just
4304 use the decl we already have. */
4305 else if (!TREE_ADDRESSABLE (decl)
4306 && init
4307 && (fallback & fb_lvalue) == 0
4308 && gimple_test_f (init))
4310 *expr_p = init;
4311 return GS_OK;
4314 /* Preliminarily mark non-addressed complex variables as eligible
4315 for promotion to gimple registers. We'll transform their uses
4316 as we find them. */
4317 if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
4318 || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
4319 && !TREE_THIS_VOLATILE (decl)
4320 && !needs_to_live_in_memory (decl))
4321 DECL_GIMPLE_REG_P (decl) = 1;
4323 /* If the decl is not addressable, then it is being used in some
4324 expression or on the right hand side of a statement, and it can
4325 be put into a readonly data section. */
4326 if (!TREE_ADDRESSABLE (decl) && (fallback & fb_lvalue) == 0)
4327 TREE_READONLY (decl) = 1;
4329 /* This decl isn't mentioned in the enclosing block, so add it to the
4330 list of temps. FIXME it seems a bit of a kludge to say that
4331 anonymous artificial vars aren't pushed, but everything else is. */
4332 if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
4333 gimple_add_tmp_var (decl);
4335 gimplify_and_add (decl_s, pre_p);
4336 *expr_p = decl;
4337 return GS_OK;
4340 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
4341 return a new CONSTRUCTOR if something changed. */
4343 static tree
4344 optimize_compound_literals_in_ctor (tree orig_ctor)
4346 tree ctor = orig_ctor;
4347 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ctor);
4348 unsigned int idx, num = vec_safe_length (elts);
4350 for (idx = 0; idx < num; idx++)
4352 tree value = (*elts)[idx].value;
4353 tree newval = value;
4354 if (TREE_CODE (value) == CONSTRUCTOR)
4355 newval = optimize_compound_literals_in_ctor (value);
4356 else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
4358 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (value);
4359 tree decl = DECL_EXPR_DECL (decl_s);
4360 tree init = DECL_INITIAL (decl);
4362 if (!TREE_ADDRESSABLE (value)
4363 && !TREE_ADDRESSABLE (decl)
4364 && init
4365 && TREE_CODE (init) == CONSTRUCTOR)
4366 newval = optimize_compound_literals_in_ctor (init);
4368 if (newval == value)
4369 continue;
4371 if (ctor == orig_ctor)
4373 ctor = copy_node (orig_ctor);
4374 CONSTRUCTOR_ELTS (ctor) = vec_safe_copy (elts);
4375 elts = CONSTRUCTOR_ELTS (ctor);
4377 (*elts)[idx].value = newval;
4379 return ctor;
4382 /* A subroutine of gimplify_modify_expr. Break out elements of a
4383 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
4385 Note that we still need to clear any elements that don't have explicit
4386 initializers, so if not all elements are initialized we keep the
4387 original MODIFY_EXPR, we just remove all of the constructor elements.
4389 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
4390 GS_ERROR if we would have to create a temporary when gimplifying
4391 this constructor. Otherwise, return GS_OK.
4393 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
4395 static enum gimplify_status
4396 gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
4397 bool want_value, bool notify_temp_creation)
4399 tree object, ctor, type;
4400 enum gimplify_status ret;
4401 vec<constructor_elt, va_gc> *elts;
4403 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR);
4405 if (!notify_temp_creation)
4407 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
4408 is_gimple_lvalue, fb_lvalue);
4409 if (ret == GS_ERROR)
4410 return ret;
4413 object = TREE_OPERAND (*expr_p, 0);
4414 ctor = TREE_OPERAND (*expr_p, 1) =
4415 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p, 1));
4416 type = TREE_TYPE (ctor);
4417 elts = CONSTRUCTOR_ELTS (ctor);
4418 ret = GS_ALL_DONE;
4420 switch (TREE_CODE (type))
4422 case RECORD_TYPE:
4423 case UNION_TYPE:
4424 case QUAL_UNION_TYPE:
4425 case ARRAY_TYPE:
4427 struct gimplify_init_ctor_preeval_data preeval_data;
4428 HOST_WIDE_INT num_ctor_elements, num_nonzero_elements;
4429 bool cleared, complete_p, valid_const_initializer;
4431 /* Aggregate types must lower constructors to initialization of
4432 individual elements. The exception is that a CONSTRUCTOR node
4433 with no elements indicates zero-initialization of the whole. */
4434 if (vec_safe_is_empty (elts))
4436 if (notify_temp_creation)
4437 return GS_OK;
4438 break;
4441 /* Fetch information about the constructor to direct later processing.
4442 We might want to make static versions of it in various cases, and
4443 can only do so if it known to be a valid constant initializer. */
4444 valid_const_initializer
4445 = categorize_ctor_elements (ctor, &num_nonzero_elements,
4446 &num_ctor_elements, &complete_p);
4448 /* If a const aggregate variable is being initialized, then it
4449 should never be a lose to promote the variable to be static. */
4450 if (valid_const_initializer
4451 && num_nonzero_elements > 1
4452 && TREE_READONLY (object)
4453 && VAR_P (object)
4454 && (flag_merge_constants >= 2 || !TREE_ADDRESSABLE (object)))
4456 if (notify_temp_creation)
4457 return GS_ERROR;
4458 DECL_INITIAL (object) = ctor;
4459 TREE_STATIC (object) = 1;
4460 if (!DECL_NAME (object))
4461 DECL_NAME (object) = create_tmp_var_name ("C");
4462 walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
4464 /* ??? C++ doesn't automatically append a .<number> to the
4465 assembler name, and even when it does, it looks at FE private
4466 data structures to figure out what that number should be,
4467 which are not set for this variable. I suppose this is
4468 important for local statics for inline functions, which aren't
4469 "local" in the object file sense. So in order to get a unique
4470 TU-local symbol, we must invoke the lhd version now. */
4471 lhd_set_decl_assembler_name (object);
4473 *expr_p = NULL_TREE;
4474 break;
4477 /* If there are "lots" of initialized elements, even discounting
4478 those that are not address constants (and thus *must* be
4479 computed at runtime), then partition the constructor into
4480 constant and non-constant parts. Block copy the constant
4481 parts in, then generate code for the non-constant parts. */
4482 /* TODO. There's code in cp/typeck.c to do this. */
4484 if (int_size_in_bytes (TREE_TYPE (ctor)) < 0)
4485 /* store_constructor will ignore the clearing of variable-sized
4486 objects. Initializers for such objects must explicitly set
4487 every field that needs to be set. */
4488 cleared = false;
4489 else if (!complete_p && !CONSTRUCTOR_NO_CLEARING (ctor))
4490 /* If the constructor isn't complete, clear the whole object
4491 beforehand, unless CONSTRUCTOR_NO_CLEARING is set on it.
4493 ??? This ought not to be needed. For any element not present
4494 in the initializer, we should simply set them to zero. Except
4495 we'd need to *find* the elements that are not present, and that
4496 requires trickery to avoid quadratic compile-time behavior in
4497 large cases or excessive memory use in small cases. */
4498 cleared = true;
4499 else if (num_ctor_elements - num_nonzero_elements
4500 > CLEAR_RATIO (optimize_function_for_speed_p (cfun))
4501 && num_nonzero_elements < num_ctor_elements / 4)
4502 /* If there are "lots" of zeros, it's more efficient to clear
4503 the memory and then set the nonzero elements. */
4504 cleared = true;
4505 else
4506 cleared = false;
4508 /* If there are "lots" of initialized elements, and all of them
4509 are valid address constants, then the entire initializer can
4510 be dropped to memory, and then memcpy'd out. Don't do this
4511 for sparse arrays, though, as it's more efficient to follow
4512 the standard CONSTRUCTOR behavior of memset followed by
4513 individual element initialization. Also don't do this for small
4514 all-zero initializers (which aren't big enough to merit
4515 clearing), and don't try to make bitwise copies of
4516 TREE_ADDRESSABLE types.
4518 We cannot apply such transformation when compiling chkp static
4519 initializer because creation of initializer image in the memory
4520 will require static initialization of bounds for it. It should
4521 result in another gimplification of similar initializer and we
4522 may fall into infinite loop. */
4523 if (valid_const_initializer
4524 && !(cleared || num_nonzero_elements == 0)
4525 && !TREE_ADDRESSABLE (type)
4526 && (!current_function_decl
4527 || !lookup_attribute ("chkp ctor",
4528 DECL_ATTRIBUTES (current_function_decl))))
4530 HOST_WIDE_INT size = int_size_in_bytes (type);
4531 unsigned int align;
4533 /* ??? We can still get unbounded array types, at least
4534 from the C++ front end. This seems wrong, but attempt
4535 to work around it for now. */
4536 if (size < 0)
4538 size = int_size_in_bytes (TREE_TYPE (object));
4539 if (size >= 0)
4540 TREE_TYPE (ctor) = type = TREE_TYPE (object);
4543 /* Find the maximum alignment we can assume for the object. */
4544 /* ??? Make use of DECL_OFFSET_ALIGN. */
4545 if (DECL_P (object))
4546 align = DECL_ALIGN (object);
4547 else
4548 align = TYPE_ALIGN (type);
4550 /* Do a block move either if the size is so small as to make
4551 each individual move a sub-unit move on average, or if it
4552 is so large as to make individual moves inefficient. */
4553 if (size > 0
4554 && num_nonzero_elements > 1
4555 && (size < num_nonzero_elements
4556 || !can_move_by_pieces (size, align)))
4558 if (notify_temp_creation)
4559 return GS_ERROR;
4561 walk_tree (&ctor, force_labels_r, NULL, NULL);
4562 ctor = tree_output_constant_def (ctor);
4563 if (!useless_type_conversion_p (type, TREE_TYPE (ctor)))
4564 ctor = build1 (VIEW_CONVERT_EXPR, type, ctor);
4565 TREE_OPERAND (*expr_p, 1) = ctor;
4567 /* This is no longer an assignment of a CONSTRUCTOR, but
4568 we still may have processing to do on the LHS. So
4569 pretend we didn't do anything here to let that happen. */
4570 return GS_UNHANDLED;
4574 /* If the target is volatile, we have non-zero elements and more than
4575 one field to assign, initialize the target from a temporary. */
4576 if (TREE_THIS_VOLATILE (object)
4577 && !TREE_ADDRESSABLE (type)
4578 && num_nonzero_elements > 0
4579 && vec_safe_length (elts) > 1)
4581 tree temp = create_tmp_var (TYPE_MAIN_VARIANT (type));
4582 TREE_OPERAND (*expr_p, 0) = temp;
4583 *expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
4584 *expr_p,
4585 build2 (MODIFY_EXPR, void_type_node,
4586 object, temp));
4587 return GS_OK;
4590 if (notify_temp_creation)
4591 return GS_OK;
4593 /* If there are nonzero elements and if needed, pre-evaluate to capture
4594 elements overlapping with the lhs into temporaries. We must do this
4595 before clearing to fetch the values before they are zeroed-out. */
4596 if (num_nonzero_elements > 0 && TREE_CODE (*expr_p) != INIT_EXPR)
4598 preeval_data.lhs_base_decl = get_base_address (object);
4599 if (!DECL_P (preeval_data.lhs_base_decl))
4600 preeval_data.lhs_base_decl = NULL;
4601 preeval_data.lhs_alias_set = get_alias_set (object);
4603 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
4604 pre_p, post_p, &preeval_data);
4607 bool ctor_has_side_effects_p
4608 = TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1));
4610 if (cleared)
4612 /* Zap the CONSTRUCTOR element list, which simplifies this case.
4613 Note that we still have to gimplify, in order to handle the
4614 case of variable sized types. Avoid shared tree structures. */
4615 CONSTRUCTOR_ELTS (ctor) = NULL;
4616 TREE_SIDE_EFFECTS (ctor) = 0;
4617 object = unshare_expr (object);
4618 gimplify_stmt (expr_p, pre_p);
4621 /* If we have not block cleared the object, or if there are nonzero
4622 elements in the constructor, or if the constructor has side effects,
4623 add assignments to the individual scalar fields of the object. */
4624 if (!cleared
4625 || num_nonzero_elements > 0
4626 || ctor_has_side_effects_p)
4627 gimplify_init_ctor_eval (object, elts, pre_p, cleared);
4629 *expr_p = NULL_TREE;
4631 break;
4633 case COMPLEX_TYPE:
4635 tree r, i;
4637 if (notify_temp_creation)
4638 return GS_OK;
4640 /* Extract the real and imaginary parts out of the ctor. */
4641 gcc_assert (elts->length () == 2);
4642 r = (*elts)[0].value;
4643 i = (*elts)[1].value;
4644 if (r == NULL || i == NULL)
4646 tree zero = build_zero_cst (TREE_TYPE (type));
4647 if (r == NULL)
4648 r = zero;
4649 if (i == NULL)
4650 i = zero;
4653 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
4654 represent creation of a complex value. */
4655 if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
4657 ctor = build_complex (type, r, i);
4658 TREE_OPERAND (*expr_p, 1) = ctor;
4660 else
4662 ctor = build2 (COMPLEX_EXPR, type, r, i);
4663 TREE_OPERAND (*expr_p, 1) = ctor;
4664 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1),
4665 pre_p,
4666 post_p,
4667 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
4668 fb_rvalue);
4671 break;
4673 case VECTOR_TYPE:
4675 unsigned HOST_WIDE_INT ix;
4676 constructor_elt *ce;
4678 if (notify_temp_creation)
4679 return GS_OK;
4681 /* Go ahead and simplify constant constructors to VECTOR_CST. */
4682 if (TREE_CONSTANT (ctor))
4684 bool constant_p = true;
4685 tree value;
4687 /* Even when ctor is constant, it might contain non-*_CST
4688 elements, such as addresses or trapping values like
4689 1.0/0.0 - 1.0/0.0. Such expressions don't belong
4690 in VECTOR_CST nodes. */
4691 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
4692 if (!CONSTANT_CLASS_P (value))
4694 constant_p = false;
4695 break;
4698 if (constant_p)
4700 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
4701 break;
4704 TREE_CONSTANT (ctor) = 0;
4707 /* Vector types use CONSTRUCTOR all the way through gimple
4708 compilation as a general initializer. */
4709 FOR_EACH_VEC_SAFE_ELT (elts, ix, ce)
4711 enum gimplify_status tret;
4712 tret = gimplify_expr (&ce->value, pre_p, post_p, is_gimple_val,
4713 fb_rvalue);
4714 if (tret == GS_ERROR)
4715 ret = GS_ERROR;
4716 else if (TREE_STATIC (ctor)
4717 && !initializer_constant_valid_p (ce->value,
4718 TREE_TYPE (ce->value)))
4719 TREE_STATIC (ctor) = 0;
4721 if (!is_gimple_reg (TREE_OPERAND (*expr_p, 0)))
4722 TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
4724 break;
4726 default:
4727 /* So how did we get a CONSTRUCTOR for a scalar type? */
4728 gcc_unreachable ();
4731 if (ret == GS_ERROR)
4732 return GS_ERROR;
4733 else if (want_value)
4735 *expr_p = object;
4736 return GS_OK;
4738 else
4740 /* If we have gimplified both sides of the initializer but have
4741 not emitted an assignment, do so now. */
4742 if (*expr_p)
4744 tree lhs = TREE_OPERAND (*expr_p, 0);
4745 tree rhs = TREE_OPERAND (*expr_p, 1);
4746 gassign *init = gimple_build_assign (lhs, rhs);
4747 gimplify_seq_add_stmt (pre_p, init);
4748 *expr_p = NULL;
4751 return GS_ALL_DONE;
4755 /* Given a pointer value OP0, return a simplified version of an
4756 indirection through OP0, or NULL_TREE if no simplification is
4757 possible. This may only be applied to a rhs of an expression.
4758 Note that the resulting type may be different from the type pointed
4759 to in the sense that it is still compatible from the langhooks
4760 point of view. */
4762 static tree
4763 gimple_fold_indirect_ref_rhs (tree t)
4765 return gimple_fold_indirect_ref (t);
4768 /* Subroutine of gimplify_modify_expr to do simplifications of
4769 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4770 something changes. */
4772 static enum gimplify_status
4773 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p,
4774 gimple_seq *pre_p, gimple_seq *post_p,
4775 bool want_value)
4777 enum gimplify_status ret = GS_UNHANDLED;
4778 bool changed;
4782 changed = false;
4783 switch (TREE_CODE (*from_p))
4785 case VAR_DECL:
4786 /* If we're assigning from a read-only variable initialized with
4787 a constructor, do the direct assignment from the constructor,
4788 but only if neither source nor target are volatile since this
4789 latter assignment might end up being done on a per-field basis. */
4790 if (DECL_INITIAL (*from_p)
4791 && TREE_READONLY (*from_p)
4792 && !TREE_THIS_VOLATILE (*from_p)
4793 && !TREE_THIS_VOLATILE (*to_p)
4794 && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
4796 tree old_from = *from_p;
4797 enum gimplify_status subret;
4799 /* Move the constructor into the RHS. */
4800 *from_p = unshare_expr (DECL_INITIAL (*from_p));
4802 /* Let's see if gimplify_init_constructor will need to put
4803 it in memory. */
4804 subret = gimplify_init_constructor (expr_p, NULL, NULL,
4805 false, true);
4806 if (subret == GS_ERROR)
4808 /* If so, revert the change. */
4809 *from_p = old_from;
4811 else
4813 ret = GS_OK;
4814 changed = true;
4817 break;
4818 case INDIRECT_REF:
4820 /* If we have code like
4822 *(const A*)(A*)&x
4824 where the type of "x" is a (possibly cv-qualified variant
4825 of "A"), treat the entire expression as identical to "x".
4826 This kind of code arises in C++ when an object is bound
4827 to a const reference, and if "x" is a TARGET_EXPR we want
4828 to take advantage of the optimization below. */
4829 bool volatile_p = TREE_THIS_VOLATILE (*from_p);
4830 tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
4831 if (t)
4833 if (TREE_THIS_VOLATILE (t) != volatile_p)
4835 if (DECL_P (t))
4836 t = build_simple_mem_ref_loc (EXPR_LOCATION (*from_p),
4837 build_fold_addr_expr (t));
4838 if (REFERENCE_CLASS_P (t))
4839 TREE_THIS_VOLATILE (t) = volatile_p;
4841 *from_p = t;
4842 ret = GS_OK;
4843 changed = true;
4845 break;
4848 case TARGET_EXPR:
4850 /* If we are initializing something from a TARGET_EXPR, strip the
4851 TARGET_EXPR and initialize it directly, if possible. This can't
4852 be done if the initializer is void, since that implies that the
4853 temporary is set in some non-trivial way.
4855 ??? What about code that pulls out the temp and uses it
4856 elsewhere? I think that such code never uses the TARGET_EXPR as
4857 an initializer. If I'm wrong, we'll die because the temp won't
4858 have any RTL. In that case, I guess we'll need to replace
4859 references somehow. */
4860 tree init = TARGET_EXPR_INITIAL (*from_p);
4862 if (init
4863 && !VOID_TYPE_P (TREE_TYPE (init)))
4865 *from_p = init;
4866 ret = GS_OK;
4867 changed = true;
4870 break;
4872 case COMPOUND_EXPR:
4873 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4874 caught. */
4875 gimplify_compound_expr (from_p, pre_p, true);
4876 ret = GS_OK;
4877 changed = true;
4878 break;
4880 case CONSTRUCTOR:
4881 /* If we already made some changes, let the front end have a
4882 crack at this before we break it down. */
4883 if (ret != GS_UNHANDLED)
4884 break;
4885 /* If we're initializing from a CONSTRUCTOR, break this into
4886 individual MODIFY_EXPRs. */
4887 return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
4888 false);
4890 case COND_EXPR:
4891 /* If we're assigning to a non-register type, push the assignment
4892 down into the branches. This is mandatory for ADDRESSABLE types,
4893 since we cannot generate temporaries for such, but it saves a
4894 copy in other cases as well. */
4895 if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
4897 /* This code should mirror the code in gimplify_cond_expr. */
4898 enum tree_code code = TREE_CODE (*expr_p);
4899 tree cond = *from_p;
4900 tree result = *to_p;
4902 ret = gimplify_expr (&result, pre_p, post_p,
4903 is_gimple_lvalue, fb_lvalue);
4904 if (ret != GS_ERROR)
4905 ret = GS_OK;
4907 if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
4908 TREE_OPERAND (cond, 1)
4909 = build2 (code, void_type_node, result,
4910 TREE_OPERAND (cond, 1));
4911 if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
4912 TREE_OPERAND (cond, 2)
4913 = build2 (code, void_type_node, unshare_expr (result),
4914 TREE_OPERAND (cond, 2));
4916 TREE_TYPE (cond) = void_type_node;
4917 recalculate_side_effects (cond);
4919 if (want_value)
4921 gimplify_and_add (cond, pre_p);
4922 *expr_p = unshare_expr (result);
4924 else
4925 *expr_p = cond;
4926 return ret;
4928 break;
4930 case CALL_EXPR:
4931 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4932 return slot so that we don't generate a temporary. */
4933 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
4934 && aggregate_value_p (*from_p, *from_p))
4936 bool use_target;
4938 if (!(rhs_predicate_for (*to_p))(*from_p))
4939 /* If we need a temporary, *to_p isn't accurate. */
4940 use_target = false;
4941 /* It's OK to use the return slot directly unless it's an NRV. */
4942 else if (TREE_CODE (*to_p) == RESULT_DECL
4943 && DECL_NAME (*to_p) == NULL_TREE
4944 && needs_to_live_in_memory (*to_p))
4945 use_target = true;
4946 else if (is_gimple_reg_type (TREE_TYPE (*to_p))
4947 || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
4948 /* Don't force regs into memory. */
4949 use_target = false;
4950 else if (TREE_CODE (*expr_p) == INIT_EXPR)
4951 /* It's OK to use the target directly if it's being
4952 initialized. */
4953 use_target = true;
4954 else if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (*to_p)))
4955 != INTEGER_CST)
4956 /* Always use the target and thus RSO for variable-sized types.
4957 GIMPLE cannot deal with a variable-sized assignment
4958 embedded in a call statement. */
4959 use_target = true;
4960 else if (TREE_CODE (*to_p) != SSA_NAME
4961 && (!is_gimple_variable (*to_p)
4962 || needs_to_live_in_memory (*to_p)))
4963 /* Don't use the original target if it's already addressable;
4964 if its address escapes, and the called function uses the
4965 NRV optimization, a conforming program could see *to_p
4966 change before the called function returns; see c++/19317.
4967 When optimizing, the return_slot pass marks more functions
4968 as safe after we have escape info. */
4969 use_target = false;
4970 else
4971 use_target = true;
4973 if (use_target)
4975 CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
4976 mark_addressable (*to_p);
4979 break;
4981 case WITH_SIZE_EXPR:
4982 /* Likewise for calls that return an aggregate of non-constant size,
4983 since we would not be able to generate a temporary at all. */
4984 if (TREE_CODE (TREE_OPERAND (*from_p, 0)) == CALL_EXPR)
4986 *from_p = TREE_OPERAND (*from_p, 0);
4987 /* We don't change ret in this case because the
4988 WITH_SIZE_EXPR might have been added in
4989 gimplify_modify_expr, so returning GS_OK would lead to an
4990 infinite loop. */
4991 changed = true;
4993 break;
4995 /* If we're initializing from a container, push the initialization
4996 inside it. */
4997 case CLEANUP_POINT_EXPR:
4998 case BIND_EXPR:
4999 case STATEMENT_LIST:
5001 tree wrap = *from_p;
5002 tree t;
5004 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
5005 fb_lvalue);
5006 if (ret != GS_ERROR)
5007 ret = GS_OK;
5009 t = voidify_wrapper_expr (wrap, *expr_p);
5010 gcc_assert (t == *expr_p);
5012 if (want_value)
5014 gimplify_and_add (wrap, pre_p);
5015 *expr_p = unshare_expr (*to_p);
5017 else
5018 *expr_p = wrap;
5019 return GS_OK;
5022 case COMPOUND_LITERAL_EXPR:
5024 tree complit = TREE_OPERAND (*expr_p, 1);
5025 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (complit);
5026 tree decl = DECL_EXPR_DECL (decl_s);
5027 tree init = DECL_INITIAL (decl);
5029 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
5030 into struct T x = { 0, 1, 2 } if the address of the
5031 compound literal has never been taken. */
5032 if (!TREE_ADDRESSABLE (complit)
5033 && !TREE_ADDRESSABLE (decl)
5034 && init)
5036 *expr_p = copy_node (*expr_p);
5037 TREE_OPERAND (*expr_p, 1) = init;
5038 return GS_OK;
5042 default:
5043 break;
5046 while (changed);
5048 return ret;
5052 /* Return true if T looks like a valid GIMPLE statement. */
5054 static bool
5055 is_gimple_stmt (tree t)
5057 const enum tree_code code = TREE_CODE (t);
5059 switch (code)
5061 case NOP_EXPR:
5062 /* The only valid NOP_EXPR is the empty statement. */
5063 return IS_EMPTY_STMT (t);
5065 case BIND_EXPR:
5066 case COND_EXPR:
5067 /* These are only valid if they're void. */
5068 return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
5070 case SWITCH_EXPR:
5071 case GOTO_EXPR:
5072 case RETURN_EXPR:
5073 case LABEL_EXPR:
5074 case CASE_LABEL_EXPR:
5075 case TRY_CATCH_EXPR:
5076 case TRY_FINALLY_EXPR:
5077 case EH_FILTER_EXPR:
5078 case CATCH_EXPR:
5079 case ASM_EXPR:
5080 case STATEMENT_LIST:
5081 case OACC_PARALLEL:
5082 case OACC_KERNELS:
5083 case OACC_DATA:
5084 case OACC_HOST_DATA:
5085 case OACC_DECLARE:
5086 case OACC_UPDATE:
5087 case OACC_ENTER_DATA:
5088 case OACC_EXIT_DATA:
5089 case OACC_CACHE:
5090 case OMP_PARALLEL:
5091 case OMP_FOR:
5092 case OMP_SIMD:
5093 case CILK_SIMD:
5094 case OMP_DISTRIBUTE:
5095 case OACC_LOOP:
5096 case OMP_SECTIONS:
5097 case OMP_SECTION:
5098 case OMP_SINGLE:
5099 case OMP_MASTER:
5100 case OMP_TASKGROUP:
5101 case OMP_ORDERED:
5102 case OMP_CRITICAL:
5103 case OMP_TASK:
5104 case OMP_TARGET:
5105 case OMP_TARGET_DATA:
5106 case OMP_TARGET_UPDATE:
5107 case OMP_TARGET_ENTER_DATA:
5108 case OMP_TARGET_EXIT_DATA:
5109 case OMP_TASKLOOP:
5110 case OMP_TEAMS:
5111 /* These are always void. */
5112 return true;
5114 case CALL_EXPR:
5115 case MODIFY_EXPR:
5116 case PREDICT_EXPR:
5117 /* These are valid regardless of their type. */
5118 return true;
5120 default:
5121 return false;
5126 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
5127 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
5128 DECL_GIMPLE_REG_P set.
5130 IMPORTANT NOTE: This promotion is performed by introducing a load of the
5131 other, unmodified part of the complex object just before the total store.
5132 As a consequence, if the object is still uninitialized, an undefined value
5133 will be loaded into a register, which may result in a spurious exception
5134 if the register is floating-point and the value happens to be a signaling
5135 NaN for example. Then the fully-fledged complex operations lowering pass
5136 followed by a DCE pass are necessary in order to fix things up. */
5138 static enum gimplify_status
5139 gimplify_modify_expr_complex_part (tree *expr_p, gimple_seq *pre_p,
5140 bool want_value)
5142 enum tree_code code, ocode;
5143 tree lhs, rhs, new_rhs, other, realpart, imagpart;
5145 lhs = TREE_OPERAND (*expr_p, 0);
5146 rhs = TREE_OPERAND (*expr_p, 1);
5147 code = TREE_CODE (lhs);
5148 lhs = TREE_OPERAND (lhs, 0);
5150 ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR;
5151 other = build1 (ocode, TREE_TYPE (rhs), lhs);
5152 TREE_NO_WARNING (other) = 1;
5153 other = get_formal_tmp_var (other, pre_p);
5155 realpart = code == REALPART_EXPR ? rhs : other;
5156 imagpart = code == REALPART_EXPR ? other : rhs;
5158 if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart))
5159 new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart);
5160 else
5161 new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
5163 gimplify_seq_add_stmt (pre_p, gimple_build_assign (lhs, new_rhs));
5164 *expr_p = (want_value) ? rhs : NULL_TREE;
5166 return GS_ALL_DONE;
5169 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
5171 modify_expr
5172 : varname '=' rhs
5173 | '*' ID '=' rhs
5175 PRE_P points to the list where side effects that must happen before
5176 *EXPR_P should be stored.
5178 POST_P points to the list where side effects that must happen after
5179 *EXPR_P should be stored.
5181 WANT_VALUE is nonzero iff we want to use the value of this expression
5182 in another expression. */
5184 static enum gimplify_status
5185 gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
5186 bool want_value)
5188 tree *from_p = &TREE_OPERAND (*expr_p, 1);
5189 tree *to_p = &TREE_OPERAND (*expr_p, 0);
5190 enum gimplify_status ret = GS_UNHANDLED;
5191 gimple *assign;
5192 location_t loc = EXPR_LOCATION (*expr_p);
5193 gimple_stmt_iterator gsi;
5195 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
5196 || TREE_CODE (*expr_p) == INIT_EXPR);
5198 /* Trying to simplify a clobber using normal logic doesn't work,
5199 so handle it here. */
5200 if (TREE_CLOBBER_P (*from_p))
5202 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
5203 if (ret == GS_ERROR)
5204 return ret;
5205 gcc_assert (!want_value
5206 && (VAR_P (*to_p) || TREE_CODE (*to_p) == MEM_REF));
5207 gimplify_seq_add_stmt (pre_p, gimple_build_assign (*to_p, *from_p));
5208 *expr_p = NULL;
5209 return GS_ALL_DONE;
5212 /* Insert pointer conversions required by the middle-end that are not
5213 required by the frontend. This fixes middle-end type checking for
5214 for example gcc.dg/redecl-6.c. */
5215 if (POINTER_TYPE_P (TREE_TYPE (*to_p)))
5217 STRIP_USELESS_TYPE_CONVERSION (*from_p);
5218 if (!useless_type_conversion_p (TREE_TYPE (*to_p), TREE_TYPE (*from_p)))
5219 *from_p = fold_convert_loc (loc, TREE_TYPE (*to_p), *from_p);
5222 /* See if any simplifications can be done based on what the RHS is. */
5223 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
5224 want_value);
5225 if (ret != GS_UNHANDLED)
5226 return ret;
5228 /* For zero sized types only gimplify the left hand side and right hand
5229 side as statements and throw away the assignment. Do this after
5230 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
5231 types properly. */
5232 if (zero_sized_type (TREE_TYPE (*from_p)) && !want_value)
5234 gimplify_stmt (from_p, pre_p);
5235 gimplify_stmt (to_p, pre_p);
5236 *expr_p = NULL_TREE;
5237 return GS_ALL_DONE;
5240 /* If the value being copied is of variable width, compute the length
5241 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
5242 before gimplifying any of the operands so that we can resolve any
5243 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
5244 the size of the expression to be copied, not of the destination, so
5245 that is what we must do here. */
5246 maybe_with_size_expr (from_p);
5248 /* As a special case, we have to temporarily allow for assignments
5249 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
5250 a toplevel statement, when gimplifying the GENERIC expression
5251 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
5252 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
5254 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
5255 prevent gimplify_expr from trying to create a new temporary for
5256 foo's LHS, we tell it that it should only gimplify until it
5257 reaches the CALL_EXPR. On return from gimplify_expr, the newly
5258 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
5259 and all we need to do here is set 'a' to be its LHS. */
5261 /* Gimplify the RHS first for C++17 and bug 71104. */
5262 gimple_predicate initial_pred = initial_rhs_predicate_for (*to_p);
5263 ret = gimplify_expr (from_p, pre_p, post_p, initial_pred, fb_rvalue);
5264 if (ret == GS_ERROR)
5265 return ret;
5267 /* Then gimplify the LHS. */
5268 /* If we gimplified the RHS to a CALL_EXPR and that call may return
5269 twice we have to make sure to gimplify into non-SSA as otherwise
5270 the abnormal edge added later will make those defs not dominate
5271 their uses.
5272 ??? Technically this applies only to the registers used in the
5273 resulting non-register *TO_P. */
5274 bool saved_into_ssa = gimplify_ctxp->into_ssa;
5275 if (saved_into_ssa
5276 && TREE_CODE (*from_p) == CALL_EXPR
5277 && call_expr_flags (*from_p) & ECF_RETURNS_TWICE)
5278 gimplify_ctxp->into_ssa = false;
5279 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
5280 gimplify_ctxp->into_ssa = saved_into_ssa;
5281 if (ret == GS_ERROR)
5282 return ret;
5284 /* Now that the LHS is gimplified, re-gimplify the RHS if our initial
5285 guess for the predicate was wrong. */
5286 gimple_predicate final_pred = rhs_predicate_for (*to_p);
5287 if (final_pred != initial_pred)
5289 ret = gimplify_expr (from_p, pre_p, post_p, final_pred, fb_rvalue);
5290 if (ret == GS_ERROR)
5291 return ret;
5294 /* In case of va_arg internal fn wrappped in a WITH_SIZE_EXPR, add the type
5295 size as argument to the call. */
5296 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
5298 tree call = TREE_OPERAND (*from_p, 0);
5299 tree vlasize = TREE_OPERAND (*from_p, 1);
5301 if (TREE_CODE (call) == CALL_EXPR
5302 && CALL_EXPR_IFN (call) == IFN_VA_ARG)
5304 int nargs = call_expr_nargs (call);
5305 tree type = TREE_TYPE (call);
5306 tree ap = CALL_EXPR_ARG (call, 0);
5307 tree tag = CALL_EXPR_ARG (call, 1);
5308 tree aptag = CALL_EXPR_ARG (call, 2);
5309 tree newcall = build_call_expr_internal_loc (EXPR_LOCATION (call),
5310 IFN_VA_ARG, type,
5311 nargs + 1, ap, tag,
5312 aptag, vlasize);
5313 TREE_OPERAND (*from_p, 0) = newcall;
5317 /* Now see if the above changed *from_p to something we handle specially. */
5318 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
5319 want_value);
5320 if (ret != GS_UNHANDLED)
5321 return ret;
5323 /* If we've got a variable sized assignment between two lvalues (i.e. does
5324 not involve a call), then we can make things a bit more straightforward
5325 by converting the assignment to memcpy or memset. */
5326 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
5328 tree from = TREE_OPERAND (*from_p, 0);
5329 tree size = TREE_OPERAND (*from_p, 1);
5331 if (TREE_CODE (from) == CONSTRUCTOR)
5332 return gimplify_modify_expr_to_memset (expr_p, size, want_value, pre_p);
5334 if (is_gimple_addressable (from))
5336 *from_p = from;
5337 return gimplify_modify_expr_to_memcpy (expr_p, size, want_value,
5338 pre_p);
5342 /* Transform partial stores to non-addressable complex variables into
5343 total stores. This allows us to use real instead of virtual operands
5344 for these variables, which improves optimization. */
5345 if ((TREE_CODE (*to_p) == REALPART_EXPR
5346 || TREE_CODE (*to_p) == IMAGPART_EXPR)
5347 && is_gimple_reg (TREE_OPERAND (*to_p, 0)))
5348 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
5350 /* Try to alleviate the effects of the gimplification creating artificial
5351 temporaries (see for example is_gimple_reg_rhs) on the debug info, but
5352 make sure not to create DECL_DEBUG_EXPR links across functions. */
5353 if (!gimplify_ctxp->into_ssa
5354 && VAR_P (*from_p)
5355 && DECL_IGNORED_P (*from_p)
5356 && DECL_P (*to_p)
5357 && !DECL_IGNORED_P (*to_p)
5358 && decl_function_context (*to_p) == current_function_decl)
5360 if (!DECL_NAME (*from_p) && DECL_NAME (*to_p))
5361 DECL_NAME (*from_p)
5362 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p)));
5363 DECL_HAS_DEBUG_EXPR_P (*from_p) = 1;
5364 SET_DECL_DEBUG_EXPR (*from_p, *to_p);
5367 if (want_value && TREE_THIS_VOLATILE (*to_p))
5368 *from_p = get_initialized_tmp_var (*from_p, pre_p, post_p);
5370 if (TREE_CODE (*from_p) == CALL_EXPR)
5372 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
5373 instead of a GIMPLE_ASSIGN. */
5374 gcall *call_stmt;
5375 if (CALL_EXPR_FN (*from_p) == NULL_TREE)
5377 /* Gimplify internal functions created in the FEs. */
5378 int nargs = call_expr_nargs (*from_p), i;
5379 enum internal_fn ifn = CALL_EXPR_IFN (*from_p);
5380 auto_vec<tree> vargs (nargs);
5382 for (i = 0; i < nargs; i++)
5384 gimplify_arg (&CALL_EXPR_ARG (*from_p, i), pre_p,
5385 EXPR_LOCATION (*from_p));
5386 vargs.quick_push (CALL_EXPR_ARG (*from_p, i));
5388 call_stmt = gimple_build_call_internal_vec (ifn, vargs);
5389 gimple_set_location (call_stmt, EXPR_LOCATION (*expr_p));
5391 else
5393 tree fnptrtype = TREE_TYPE (CALL_EXPR_FN (*from_p));
5394 CALL_EXPR_FN (*from_p) = TREE_OPERAND (CALL_EXPR_FN (*from_p), 0);
5395 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p));
5396 tree fndecl = get_callee_fndecl (*from_p);
5397 if (fndecl
5398 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
5399 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT
5400 && call_expr_nargs (*from_p) == 3)
5401 call_stmt = gimple_build_call_internal (IFN_BUILTIN_EXPECT, 3,
5402 CALL_EXPR_ARG (*from_p, 0),
5403 CALL_EXPR_ARG (*from_p, 1),
5404 CALL_EXPR_ARG (*from_p, 2));
5405 else
5407 call_stmt = gimple_build_call_from_tree (*from_p);
5408 gimple_call_set_fntype (call_stmt, TREE_TYPE (fnptrtype));
5411 notice_special_calls (call_stmt);
5412 if (!gimple_call_noreturn_p (call_stmt) || !should_remove_lhs_p (*to_p))
5413 gimple_call_set_lhs (call_stmt, *to_p);
5414 else if (TREE_CODE (*to_p) == SSA_NAME)
5415 /* The above is somewhat premature, avoid ICEing later for a
5416 SSA name w/o a definition. We may have uses in the GIMPLE IL.
5417 ??? This doesn't make it a default-def. */
5418 SSA_NAME_DEF_STMT (*to_p) = gimple_build_nop ();
5419 assign = call_stmt;
5421 else
5423 assign = gimple_build_assign (*to_p, *from_p);
5424 gimple_set_location (assign, EXPR_LOCATION (*expr_p));
5425 if (COMPARISON_CLASS_P (*from_p))
5426 gimple_set_no_warning (assign, TREE_NO_WARNING (*from_p));
5429 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
5431 /* We should have got an SSA name from the start. */
5432 gcc_assert (TREE_CODE (*to_p) == SSA_NAME
5433 || ! gimple_in_ssa_p (cfun));
5436 gimplify_seq_add_stmt (pre_p, assign);
5437 gsi = gsi_last (*pre_p);
5438 maybe_fold_stmt (&gsi);
5440 if (want_value)
5442 *expr_p = TREE_THIS_VOLATILE (*to_p) ? *from_p : unshare_expr (*to_p);
5443 return GS_OK;
5445 else
5446 *expr_p = NULL;
5448 return GS_ALL_DONE;
5451 /* Gimplify a comparison between two variable-sized objects. Do this
5452 with a call to BUILT_IN_MEMCMP. */
5454 static enum gimplify_status
5455 gimplify_variable_sized_compare (tree *expr_p)
5457 location_t loc = EXPR_LOCATION (*expr_p);
5458 tree op0 = TREE_OPERAND (*expr_p, 0);
5459 tree op1 = TREE_OPERAND (*expr_p, 1);
5460 tree t, arg, dest, src, expr;
5462 arg = TYPE_SIZE_UNIT (TREE_TYPE (op0));
5463 arg = unshare_expr (arg);
5464 arg = SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg, op0);
5465 src = build_fold_addr_expr_loc (loc, op1);
5466 dest = build_fold_addr_expr_loc (loc, op0);
5467 t = builtin_decl_implicit (BUILT_IN_MEMCMP);
5468 t = build_call_expr_loc (loc, t, 3, dest, src, arg);
5470 expr
5471 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
5472 SET_EXPR_LOCATION (expr, loc);
5473 *expr_p = expr;
5475 return GS_OK;
5478 /* Gimplify a comparison between two aggregate objects of integral scalar
5479 mode as a comparison between the bitwise equivalent scalar values. */
5481 static enum gimplify_status
5482 gimplify_scalar_mode_aggregate_compare (tree *expr_p)
5484 location_t loc = EXPR_LOCATION (*expr_p);
5485 tree op0 = TREE_OPERAND (*expr_p, 0);
5486 tree op1 = TREE_OPERAND (*expr_p, 1);
5488 tree type = TREE_TYPE (op0);
5489 tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1);
5491 op0 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op0);
5492 op1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op1);
5494 *expr_p
5495 = fold_build2_loc (loc, TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
5497 return GS_OK;
5500 /* Gimplify an expression sequence. This function gimplifies each
5501 expression and rewrites the original expression with the last
5502 expression of the sequence in GIMPLE form.
5504 PRE_P points to the list where the side effects for all the
5505 expressions in the sequence will be emitted.
5507 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
5509 static enum gimplify_status
5510 gimplify_compound_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
5512 tree t = *expr_p;
5516 tree *sub_p = &TREE_OPERAND (t, 0);
5518 if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
5519 gimplify_compound_expr (sub_p, pre_p, false);
5520 else
5521 gimplify_stmt (sub_p, pre_p);
5523 t = TREE_OPERAND (t, 1);
5525 while (TREE_CODE (t) == COMPOUND_EXPR);
5527 *expr_p = t;
5528 if (want_value)
5529 return GS_OK;
5530 else
5532 gimplify_stmt (expr_p, pre_p);
5533 return GS_ALL_DONE;
5537 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
5538 gimplify. After gimplification, EXPR_P will point to a new temporary
5539 that holds the original value of the SAVE_EXPR node.
5541 PRE_P points to the list where side effects that must happen before
5542 *EXPR_P should be stored. */
5544 static enum gimplify_status
5545 gimplify_save_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5547 enum gimplify_status ret = GS_ALL_DONE;
5548 tree val;
5550 gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
5551 val = TREE_OPERAND (*expr_p, 0);
5553 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
5554 if (!SAVE_EXPR_RESOLVED_P (*expr_p))
5556 /* The operand may be a void-valued expression such as SAVE_EXPRs
5557 generated by the Java frontend for class initialization. It is
5558 being executed only for its side-effects. */
5559 if (TREE_TYPE (val) == void_type_node)
5561 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5562 is_gimple_stmt, fb_none);
5563 val = NULL;
5565 else
5566 /* The temporary may not be an SSA name as later abnormal and EH
5567 control flow may invalidate use/def domination. */
5568 val = get_initialized_tmp_var (val, pre_p, post_p, false);
5570 TREE_OPERAND (*expr_p, 0) = val;
5571 SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
5574 *expr_p = val;
5576 return ret;
5579 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
5581 unary_expr
5582 : ...
5583 | '&' varname
5586 PRE_P points to the list where side effects that must happen before
5587 *EXPR_P should be stored.
5589 POST_P points to the list where side effects that must happen after
5590 *EXPR_P should be stored. */
5592 static enum gimplify_status
5593 gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5595 tree expr = *expr_p;
5596 tree op0 = TREE_OPERAND (expr, 0);
5597 enum gimplify_status ret;
5598 location_t loc = EXPR_LOCATION (*expr_p);
5600 switch (TREE_CODE (op0))
5602 case INDIRECT_REF:
5603 do_indirect_ref:
5604 /* Check if we are dealing with an expression of the form '&*ptr'.
5605 While the front end folds away '&*ptr' into 'ptr', these
5606 expressions may be generated internally by the compiler (e.g.,
5607 builtins like __builtin_va_end). */
5608 /* Caution: the silent array decomposition semantics we allow for
5609 ADDR_EXPR means we can't always discard the pair. */
5610 /* Gimplification of the ADDR_EXPR operand may drop
5611 cv-qualification conversions, so make sure we add them if
5612 needed. */
5614 tree op00 = TREE_OPERAND (op0, 0);
5615 tree t_expr = TREE_TYPE (expr);
5616 tree t_op00 = TREE_TYPE (op00);
5618 if (!useless_type_conversion_p (t_expr, t_op00))
5619 op00 = fold_convert_loc (loc, TREE_TYPE (expr), op00);
5620 *expr_p = op00;
5621 ret = GS_OK;
5623 break;
5625 case VIEW_CONVERT_EXPR:
5626 /* Take the address of our operand and then convert it to the type of
5627 this ADDR_EXPR.
5629 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
5630 all clear. The impact of this transformation is even less clear. */
5632 /* If the operand is a useless conversion, look through it. Doing so
5633 guarantees that the ADDR_EXPR and its operand will remain of the
5634 same type. */
5635 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
5636 op0 = TREE_OPERAND (op0, 0);
5638 *expr_p = fold_convert_loc (loc, TREE_TYPE (expr),
5639 build_fold_addr_expr_loc (loc,
5640 TREE_OPERAND (op0, 0)));
5641 ret = GS_OK;
5642 break;
5644 case MEM_REF:
5645 if (integer_zerop (TREE_OPERAND (op0, 1)))
5646 goto do_indirect_ref;
5648 /* fall through */
5650 default:
5651 /* If we see a call to a declared builtin or see its address
5652 being taken (we can unify those cases here) then we can mark
5653 the builtin for implicit generation by GCC. */
5654 if (TREE_CODE (op0) == FUNCTION_DECL
5655 && DECL_BUILT_IN_CLASS (op0) == BUILT_IN_NORMAL
5656 && builtin_decl_declared_p (DECL_FUNCTION_CODE (op0)))
5657 set_builtin_decl_implicit_p (DECL_FUNCTION_CODE (op0), true);
5659 /* We use fb_either here because the C frontend sometimes takes
5660 the address of a call that returns a struct; see
5661 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
5662 the implied temporary explicit. */
5664 /* Make the operand addressable. */
5665 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
5666 is_gimple_addressable, fb_either);
5667 if (ret == GS_ERROR)
5668 break;
5670 /* Then mark it. Beware that it may not be possible to do so directly
5671 if a temporary has been created by the gimplification. */
5672 prepare_gimple_addressable (&TREE_OPERAND (expr, 0), pre_p);
5674 op0 = TREE_OPERAND (expr, 0);
5676 /* For various reasons, the gimplification of the expression
5677 may have made a new INDIRECT_REF. */
5678 if (TREE_CODE (op0) == INDIRECT_REF)
5679 goto do_indirect_ref;
5681 mark_addressable (TREE_OPERAND (expr, 0));
5683 /* The FEs may end up building ADDR_EXPRs early on a decl with
5684 an incomplete type. Re-build ADDR_EXPRs in canonical form
5685 here. */
5686 if (!types_compatible_p (TREE_TYPE (op0), TREE_TYPE (TREE_TYPE (expr))))
5687 *expr_p = build_fold_addr_expr (op0);
5689 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
5690 recompute_tree_invariant_for_addr_expr (*expr_p);
5692 /* If we re-built the ADDR_EXPR add a conversion to the original type
5693 if required. */
5694 if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
5695 *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
5697 break;
5700 return ret;
5703 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
5704 value; output operands should be a gimple lvalue. */
5706 static enum gimplify_status
5707 gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5709 tree expr;
5710 int noutputs;
5711 const char **oconstraints;
5712 int i;
5713 tree link;
5714 const char *constraint;
5715 bool allows_mem, allows_reg, is_inout;
5716 enum gimplify_status ret, tret;
5717 gasm *stmt;
5718 vec<tree, va_gc> *inputs;
5719 vec<tree, va_gc> *outputs;
5720 vec<tree, va_gc> *clobbers;
5721 vec<tree, va_gc> *labels;
5722 tree link_next;
5724 expr = *expr_p;
5725 noutputs = list_length (ASM_OUTPUTS (expr));
5726 oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
5728 inputs = NULL;
5729 outputs = NULL;
5730 clobbers = NULL;
5731 labels = NULL;
5733 ret = GS_ALL_DONE;
5734 link_next = NULL_TREE;
5735 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = link_next)
5737 bool ok;
5738 size_t constraint_len;
5740 link_next = TREE_CHAIN (link);
5742 oconstraints[i]
5743 = constraint
5744 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
5745 constraint_len = strlen (constraint);
5746 if (constraint_len == 0)
5747 continue;
5749 ok = parse_output_constraint (&constraint, i, 0, 0,
5750 &allows_mem, &allows_reg, &is_inout);
5751 if (!ok)
5753 ret = GS_ERROR;
5754 is_inout = false;
5757 if (!allows_reg && allows_mem)
5758 mark_addressable (TREE_VALUE (link));
5760 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
5761 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
5762 fb_lvalue | fb_mayfail);
5763 if (tret == GS_ERROR)
5765 error ("invalid lvalue in asm output %d", i);
5766 ret = tret;
5769 /* If the constraint does not allow memory make sure we gimplify
5770 it to a register if it is not already but its base is. This
5771 happens for complex and vector components. */
5772 if (!allows_mem)
5774 tree op = TREE_VALUE (link);
5775 if (! is_gimple_val (op)
5776 && is_gimple_reg_type (TREE_TYPE (op))
5777 && is_gimple_reg (get_base_address (op)))
5779 tree tem = create_tmp_reg (TREE_TYPE (op));
5780 tree ass;
5781 if (is_inout)
5783 ass = build2 (MODIFY_EXPR, TREE_TYPE (tem),
5784 tem, unshare_expr (op));
5785 gimplify_and_add (ass, pre_p);
5787 ass = build2 (MODIFY_EXPR, TREE_TYPE (tem), op, tem);
5788 gimplify_and_add (ass, post_p);
5790 TREE_VALUE (link) = tem;
5791 tret = GS_OK;
5795 vec_safe_push (outputs, link);
5796 TREE_CHAIN (link) = NULL_TREE;
5798 if (is_inout)
5800 /* An input/output operand. To give the optimizers more
5801 flexibility, split it into separate input and output
5802 operands. */
5803 tree input;
5804 /* Buffer big enough to format a 32-bit UINT_MAX into. */
5805 char buf[11];
5807 /* Turn the in/out constraint into an output constraint. */
5808 char *p = xstrdup (constraint);
5809 p[0] = '=';
5810 TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
5812 /* And add a matching input constraint. */
5813 if (allows_reg)
5815 sprintf (buf, "%u", i);
5817 /* If there are multiple alternatives in the constraint,
5818 handle each of them individually. Those that allow register
5819 will be replaced with operand number, the others will stay
5820 unchanged. */
5821 if (strchr (p, ',') != NULL)
5823 size_t len = 0, buflen = strlen (buf);
5824 char *beg, *end, *str, *dst;
5826 for (beg = p + 1;;)
5828 end = strchr (beg, ',');
5829 if (end == NULL)
5830 end = strchr (beg, '\0');
5831 if ((size_t) (end - beg) < buflen)
5832 len += buflen + 1;
5833 else
5834 len += end - beg + 1;
5835 if (*end)
5836 beg = end + 1;
5837 else
5838 break;
5841 str = (char *) alloca (len);
5842 for (beg = p + 1, dst = str;;)
5844 const char *tem;
5845 bool mem_p, reg_p, inout_p;
5847 end = strchr (beg, ',');
5848 if (end)
5849 *end = '\0';
5850 beg[-1] = '=';
5851 tem = beg - 1;
5852 parse_output_constraint (&tem, i, 0, 0,
5853 &mem_p, &reg_p, &inout_p);
5854 if (dst != str)
5855 *dst++ = ',';
5856 if (reg_p)
5858 memcpy (dst, buf, buflen);
5859 dst += buflen;
5861 else
5863 if (end)
5864 len = end - beg;
5865 else
5866 len = strlen (beg);
5867 memcpy (dst, beg, len);
5868 dst += len;
5870 if (end)
5871 beg = end + 1;
5872 else
5873 break;
5875 *dst = '\0';
5876 input = build_string (dst - str, str);
5878 else
5879 input = build_string (strlen (buf), buf);
5881 else
5882 input = build_string (constraint_len - 1, constraint + 1);
5884 free (p);
5886 input = build_tree_list (build_tree_list (NULL_TREE, input),
5887 unshare_expr (TREE_VALUE (link)));
5888 ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
5892 link_next = NULL_TREE;
5893 for (link = ASM_INPUTS (expr); link; ++i, link = link_next)
5895 link_next = TREE_CHAIN (link);
5896 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
5897 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
5898 oconstraints, &allows_mem, &allows_reg);
5900 /* If we can't make copies, we can only accept memory. */
5901 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link))))
5903 if (allows_mem)
5904 allows_reg = 0;
5905 else
5907 error ("impossible constraint in %<asm%>");
5908 error ("non-memory input %d must stay in memory", i);
5909 return GS_ERROR;
5913 /* If the operand is a memory input, it should be an lvalue. */
5914 if (!allows_reg && allows_mem)
5916 tree inputv = TREE_VALUE (link);
5917 STRIP_NOPS (inputv);
5918 if (TREE_CODE (inputv) == PREDECREMENT_EXPR
5919 || TREE_CODE (inputv) == PREINCREMENT_EXPR
5920 || TREE_CODE (inputv) == POSTDECREMENT_EXPR
5921 || TREE_CODE (inputv) == POSTINCREMENT_EXPR
5922 || TREE_CODE (inputv) == MODIFY_EXPR)
5923 TREE_VALUE (link) = error_mark_node;
5924 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
5925 is_gimple_lvalue, fb_lvalue | fb_mayfail);
5926 if (tret != GS_ERROR)
5928 /* Unlike output operands, memory inputs are not guaranteed
5929 to be lvalues by the FE, and while the expressions are
5930 marked addressable there, if it is e.g. a statement
5931 expression, temporaries in it might not end up being
5932 addressable. They might be already used in the IL and thus
5933 it is too late to make them addressable now though. */
5934 tree x = TREE_VALUE (link);
5935 while (handled_component_p (x))
5936 x = TREE_OPERAND (x, 0);
5937 if (TREE_CODE (x) == MEM_REF
5938 && TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
5939 x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
5940 if ((VAR_P (x)
5941 || TREE_CODE (x) == PARM_DECL
5942 || TREE_CODE (x) == RESULT_DECL)
5943 && !TREE_ADDRESSABLE (x)
5944 && is_gimple_reg (x))
5946 warning_at (EXPR_LOC_OR_LOC (TREE_VALUE (link),
5947 input_location), 0,
5948 "memory input %d is not directly addressable",
5950 prepare_gimple_addressable (&TREE_VALUE (link), pre_p);
5953 mark_addressable (TREE_VALUE (link));
5954 if (tret == GS_ERROR)
5956 error_at (EXPR_LOC_OR_LOC (TREE_VALUE (link), input_location),
5957 "memory input %d is not directly addressable", i);
5958 ret = tret;
5961 else
5963 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
5964 is_gimple_asm_val, fb_rvalue);
5965 if (tret == GS_ERROR)
5966 ret = tret;
5969 TREE_CHAIN (link) = NULL_TREE;
5970 vec_safe_push (inputs, link);
5973 link_next = NULL_TREE;
5974 for (link = ASM_CLOBBERS (expr); link; ++i, link = link_next)
5976 link_next = TREE_CHAIN (link);
5977 TREE_CHAIN (link) = NULL_TREE;
5978 vec_safe_push (clobbers, link);
5981 link_next = NULL_TREE;
5982 for (link = ASM_LABELS (expr); link; ++i, link = link_next)
5984 link_next = TREE_CHAIN (link);
5985 TREE_CHAIN (link) = NULL_TREE;
5986 vec_safe_push (labels, link);
5989 /* Do not add ASMs with errors to the gimple IL stream. */
5990 if (ret != GS_ERROR)
5992 stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
5993 inputs, outputs, clobbers, labels);
5995 gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr) || noutputs == 0);
5996 gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
5998 gimplify_seq_add_stmt (pre_p, stmt);
6001 return ret;
6004 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
6005 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
6006 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
6007 return to this function.
6009 FIXME should we complexify the prequeue handling instead? Or use flags
6010 for all the cleanups and let the optimizer tighten them up? The current
6011 code seems pretty fragile; it will break on a cleanup within any
6012 non-conditional nesting. But any such nesting would be broken, anyway;
6013 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
6014 and continues out of it. We can do that at the RTL level, though, so
6015 having an optimizer to tighten up try/finally regions would be a Good
6016 Thing. */
6018 static enum gimplify_status
6019 gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
6021 gimple_stmt_iterator iter;
6022 gimple_seq body_sequence = NULL;
6024 tree temp = voidify_wrapper_expr (*expr_p, NULL);
6026 /* We only care about the number of conditions between the innermost
6027 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
6028 any cleanups collected outside the CLEANUP_POINT_EXPR. */
6029 int old_conds = gimplify_ctxp->conditions;
6030 gimple_seq old_cleanups = gimplify_ctxp->conditional_cleanups;
6031 bool old_in_cleanup_point_expr = gimplify_ctxp->in_cleanup_point_expr;
6032 gimplify_ctxp->conditions = 0;
6033 gimplify_ctxp->conditional_cleanups = NULL;
6034 gimplify_ctxp->in_cleanup_point_expr = true;
6036 gimplify_stmt (&TREE_OPERAND (*expr_p, 0), &body_sequence);
6038 gimplify_ctxp->conditions = old_conds;
6039 gimplify_ctxp->conditional_cleanups = old_cleanups;
6040 gimplify_ctxp->in_cleanup_point_expr = old_in_cleanup_point_expr;
6042 for (iter = gsi_start (body_sequence); !gsi_end_p (iter); )
6044 gimple *wce = gsi_stmt (iter);
6046 if (gimple_code (wce) == GIMPLE_WITH_CLEANUP_EXPR)
6048 if (gsi_one_before_end_p (iter))
6050 /* Note that gsi_insert_seq_before and gsi_remove do not
6051 scan operands, unlike some other sequence mutators. */
6052 if (!gimple_wce_cleanup_eh_only (wce))
6053 gsi_insert_seq_before_without_update (&iter,
6054 gimple_wce_cleanup (wce),
6055 GSI_SAME_STMT);
6056 gsi_remove (&iter, true);
6057 break;
6059 else
6061 gtry *gtry;
6062 gimple_seq seq;
6063 enum gimple_try_flags kind;
6065 if (gimple_wce_cleanup_eh_only (wce))
6066 kind = GIMPLE_TRY_CATCH;
6067 else
6068 kind = GIMPLE_TRY_FINALLY;
6069 seq = gsi_split_seq_after (iter);
6071 gtry = gimple_build_try (seq, gimple_wce_cleanup (wce), kind);
6072 /* Do not use gsi_replace here, as it may scan operands.
6073 We want to do a simple structural modification only. */
6074 gsi_set_stmt (&iter, gtry);
6075 iter = gsi_start (gtry->eval);
6078 else
6079 gsi_next (&iter);
6082 gimplify_seq_add_seq (pre_p, body_sequence);
6083 if (temp)
6085 *expr_p = temp;
6086 return GS_OK;
6088 else
6090 *expr_p = NULL;
6091 return GS_ALL_DONE;
6095 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
6096 is the cleanup action required. EH_ONLY is true if the cleanup should
6097 only be executed if an exception is thrown, not on normal exit. */
6099 static void
6100 gimple_push_cleanup (tree var, tree cleanup, bool eh_only, gimple_seq *pre_p)
6102 gimple *wce;
6103 gimple_seq cleanup_stmts = NULL;
6105 /* Errors can result in improperly nested cleanups. Which results in
6106 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
6107 if (seen_error ())
6108 return;
6110 if (gimple_conditional_context ())
6112 /* If we're in a conditional context, this is more complex. We only
6113 want to run the cleanup if we actually ran the initialization that
6114 necessitates it, but we want to run it after the end of the
6115 conditional context. So we wrap the try/finally around the
6116 condition and use a flag to determine whether or not to actually
6117 run the destructor. Thus
6119 test ? f(A()) : 0
6121 becomes (approximately)
6123 flag = 0;
6124 try {
6125 if (test) { A::A(temp); flag = 1; val = f(temp); }
6126 else { val = 0; }
6127 } finally {
6128 if (flag) A::~A(temp);
6132 tree flag = create_tmp_var (boolean_type_node, "cleanup");
6133 gassign *ffalse = gimple_build_assign (flag, boolean_false_node);
6134 gassign *ftrue = gimple_build_assign (flag, boolean_true_node);
6136 cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
6137 gimplify_stmt (&cleanup, &cleanup_stmts);
6138 wce = gimple_build_wce (cleanup_stmts);
6140 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, ffalse);
6141 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, wce);
6142 gimplify_seq_add_stmt (pre_p, ftrue);
6144 /* Because of this manipulation, and the EH edges that jump
6145 threading cannot redirect, the temporary (VAR) will appear
6146 to be used uninitialized. Don't warn. */
6147 TREE_NO_WARNING (var) = 1;
6149 else
6151 gimplify_stmt (&cleanup, &cleanup_stmts);
6152 wce = gimple_build_wce (cleanup_stmts);
6153 gimple_wce_set_cleanup_eh_only (wce, eh_only);
6154 gimplify_seq_add_stmt (pre_p, wce);
6158 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
6160 static enum gimplify_status
6161 gimplify_target_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
6163 tree targ = *expr_p;
6164 tree temp = TARGET_EXPR_SLOT (targ);
6165 tree init = TARGET_EXPR_INITIAL (targ);
6166 enum gimplify_status ret;
6168 if (init)
6170 tree cleanup = NULL_TREE;
6172 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
6173 to the temps list. Handle also variable length TARGET_EXPRs. */
6174 if (TREE_CODE (DECL_SIZE (temp)) != INTEGER_CST)
6176 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp)))
6177 gimplify_type_sizes (TREE_TYPE (temp), pre_p);
6178 gimplify_vla_decl (temp, pre_p);
6180 else
6181 gimple_add_tmp_var (temp);
6183 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
6184 expression is supposed to initialize the slot. */
6185 if (VOID_TYPE_P (TREE_TYPE (init)))
6186 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
6187 else
6189 tree init_expr = build2 (INIT_EXPR, void_type_node, temp, init);
6190 init = init_expr;
6191 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
6192 init = NULL;
6193 ggc_free (init_expr);
6195 if (ret == GS_ERROR)
6197 /* PR c++/28266 Make sure this is expanded only once. */
6198 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
6199 return GS_ERROR;
6201 if (init)
6202 gimplify_and_add (init, pre_p);
6204 /* If needed, push the cleanup for the temp. */
6205 if (TARGET_EXPR_CLEANUP (targ))
6207 if (CLEANUP_EH_ONLY (targ))
6208 gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
6209 CLEANUP_EH_ONLY (targ), pre_p);
6210 else
6211 cleanup = TARGET_EXPR_CLEANUP (targ);
6214 /* Add a clobber for the temporary going out of scope, like
6215 gimplify_bind_expr. */
6216 if (gimplify_ctxp->in_cleanup_point_expr
6217 && needs_to_live_in_memory (temp)
6218 && flag_stack_reuse == SR_ALL)
6220 tree clobber = build_constructor (TREE_TYPE (temp),
6221 NULL);
6222 TREE_THIS_VOLATILE (clobber) = true;
6223 clobber = build2 (MODIFY_EXPR, TREE_TYPE (temp), temp, clobber);
6224 if (cleanup)
6225 cleanup = build2 (COMPOUND_EXPR, void_type_node, cleanup,
6226 clobber);
6227 else
6228 cleanup = clobber;
6231 if (cleanup)
6232 gimple_push_cleanup (temp, cleanup, false, pre_p);
6234 /* Only expand this once. */
6235 TREE_OPERAND (targ, 3) = init;
6236 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
6238 else
6239 /* We should have expanded this before. */
6240 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
6242 *expr_p = temp;
6243 return GS_OK;
6246 /* Gimplification of expression trees. */
6248 /* Gimplify an expression which appears at statement context. The
6249 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
6250 NULL, a new sequence is allocated.
6252 Return true if we actually added a statement to the queue. */
6254 bool
6255 gimplify_stmt (tree *stmt_p, gimple_seq *seq_p)
6257 gimple_seq_node last;
6259 last = gimple_seq_last (*seq_p);
6260 gimplify_expr (stmt_p, seq_p, NULL, is_gimple_stmt, fb_none);
6261 return last != gimple_seq_last (*seq_p);
6264 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
6265 to CTX. If entries already exist, force them to be some flavor of private.
6266 If there is no enclosing parallel, do nothing. */
6268 void
6269 omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl)
6271 splay_tree_node n;
6273 if (decl == NULL || !DECL_P (decl) || ctx->region_type == ORT_NONE)
6274 return;
6278 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
6279 if (n != NULL)
6281 if (n->value & GOVD_SHARED)
6282 n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
6283 else if (n->value & GOVD_MAP)
6284 n->value |= GOVD_MAP_TO_ONLY;
6285 else
6286 return;
6288 else if ((ctx->region_type & ORT_TARGET) != 0)
6290 if (ctx->target_map_scalars_firstprivate)
6291 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
6292 else
6293 omp_add_variable (ctx, decl, GOVD_MAP | GOVD_MAP_TO_ONLY);
6295 else if (ctx->region_type != ORT_WORKSHARE
6296 && ctx->region_type != ORT_SIMD
6297 && ctx->region_type != ORT_ACC
6298 && !(ctx->region_type & ORT_TARGET_DATA))
6299 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
6301 ctx = ctx->outer_context;
6303 while (ctx);
6306 /* Similarly for each of the type sizes of TYPE. */
6308 static void
6309 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type)
6311 if (type == NULL || type == error_mark_node)
6312 return;
6313 type = TYPE_MAIN_VARIANT (type);
6315 if (ctx->privatized_types->add (type))
6316 return;
6318 switch (TREE_CODE (type))
6320 case INTEGER_TYPE:
6321 case ENUMERAL_TYPE:
6322 case BOOLEAN_TYPE:
6323 case REAL_TYPE:
6324 case FIXED_POINT_TYPE:
6325 omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type));
6326 omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type));
6327 break;
6329 case ARRAY_TYPE:
6330 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
6331 omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type));
6332 break;
6334 case RECORD_TYPE:
6335 case UNION_TYPE:
6336 case QUAL_UNION_TYPE:
6338 tree field;
6339 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
6340 if (TREE_CODE (field) == FIELD_DECL)
6342 omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
6343 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
6346 break;
6348 case POINTER_TYPE:
6349 case REFERENCE_TYPE:
6350 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
6351 break;
6353 default:
6354 break;
6357 omp_firstprivatize_variable (ctx, TYPE_SIZE (type));
6358 omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type));
6359 lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type);
6362 /* Add an entry for DECL in the OMP context CTX with FLAGS. */
6364 static void
6365 omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
6367 splay_tree_node n;
6368 unsigned int nflags;
6369 tree t;
6371 if (error_operand_p (decl) || ctx->region_type == ORT_NONE)
6372 return;
6374 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
6375 there are constructors involved somewhere. */
6376 if (TREE_ADDRESSABLE (TREE_TYPE (decl))
6377 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
6378 flags |= GOVD_SEEN;
6380 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
6381 if (n != NULL && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
6383 /* We shouldn't be re-adding the decl with the same data
6384 sharing class. */
6385 gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
6386 nflags = n->value | flags;
6387 /* The only combination of data sharing classes we should see is
6388 FIRSTPRIVATE and LASTPRIVATE. However, OpenACC permits
6389 reduction variables to be used in data sharing clauses. */
6390 gcc_assert ((ctx->region_type & ORT_ACC) != 0
6391 || ((nflags & GOVD_DATA_SHARE_CLASS)
6392 == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE))
6393 || (flags & GOVD_DATA_SHARE_CLASS) == 0);
6394 n->value = nflags;
6395 return;
6398 /* When adding a variable-sized variable, we have to handle all sorts
6399 of additional bits of data: the pointer replacement variable, and
6400 the parameters of the type. */
6401 if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
6403 /* Add the pointer replacement variable as PRIVATE if the variable
6404 replacement is private, else FIRSTPRIVATE since we'll need the
6405 address of the original variable either for SHARED, or for the
6406 copy into or out of the context. */
6407 if (!(flags & GOVD_LOCAL))
6409 if (flags & GOVD_MAP)
6410 nflags = GOVD_MAP | GOVD_MAP_TO_ONLY | GOVD_EXPLICIT;
6411 else if (flags & GOVD_PRIVATE)
6412 nflags = GOVD_PRIVATE;
6413 else if ((ctx->region_type & (ORT_TARGET | ORT_TARGET_DATA)) != 0
6414 && (flags & GOVD_FIRSTPRIVATE))
6415 nflags = GOVD_PRIVATE | GOVD_EXPLICIT;
6416 else
6417 nflags = GOVD_FIRSTPRIVATE;
6418 nflags |= flags & GOVD_SEEN;
6419 t = DECL_VALUE_EXPR (decl);
6420 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
6421 t = TREE_OPERAND (t, 0);
6422 gcc_assert (DECL_P (t));
6423 omp_add_variable (ctx, t, nflags);
6426 /* Add all of the variable and type parameters (which should have
6427 been gimplified to a formal temporary) as FIRSTPRIVATE. */
6428 omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
6429 omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
6430 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
6432 /* The variable-sized variable itself is never SHARED, only some form
6433 of PRIVATE. The sharing would take place via the pointer variable
6434 which we remapped above. */
6435 if (flags & GOVD_SHARED)
6436 flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
6437 | (flags & (GOVD_SEEN | GOVD_EXPLICIT));
6439 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
6440 alloca statement we generate for the variable, so make sure it
6441 is available. This isn't automatically needed for the SHARED
6442 case, since we won't be allocating local storage then.
6443 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
6444 in this case omp_notice_variable will be called later
6445 on when it is gimplified. */
6446 else if (! (flags & (GOVD_LOCAL | GOVD_MAP))
6447 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl))))
6448 omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
6450 else if ((flags & (GOVD_MAP | GOVD_LOCAL)) == 0
6451 && lang_hooks.decls.omp_privatize_by_reference (decl))
6453 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
6455 /* Similar to the direct variable sized case above, we'll need the
6456 size of references being privatized. */
6457 if ((flags & GOVD_SHARED) == 0)
6459 t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
6460 if (DECL_P (t))
6461 omp_notice_variable (ctx, t, true);
6465 if (n != NULL)
6466 n->value |= flags;
6467 else
6468 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
6470 /* For reductions clauses in OpenACC loop directives, by default create a
6471 copy clause on the enclosing parallel construct for carrying back the
6472 results. */
6473 if (ctx->region_type == ORT_ACC && (flags & GOVD_REDUCTION))
6475 struct gimplify_omp_ctx *outer_ctx = ctx->outer_context;
6476 while (outer_ctx)
6478 n = splay_tree_lookup (outer_ctx->variables, (splay_tree_key)decl);
6479 if (n != NULL)
6481 /* Ignore local variables and explicitly declared clauses. */
6482 if (n->value & (GOVD_LOCAL | GOVD_EXPLICIT))
6483 break;
6484 else if (outer_ctx->region_type == ORT_ACC_KERNELS)
6486 /* According to the OpenACC spec, such a reduction variable
6487 should already have a copy map on a kernels construct,
6488 verify that here. */
6489 gcc_assert (!(n->value & GOVD_FIRSTPRIVATE)
6490 && (n->value & GOVD_MAP));
6492 else if (outer_ctx->region_type == ORT_ACC_PARALLEL)
6494 /* Remove firstprivate and make it a copy map. */
6495 n->value &= ~GOVD_FIRSTPRIVATE;
6496 n->value |= GOVD_MAP;
6499 else if (outer_ctx->region_type == ORT_ACC_PARALLEL)
6501 splay_tree_insert (outer_ctx->variables, (splay_tree_key)decl,
6502 GOVD_MAP | GOVD_SEEN);
6503 break;
6505 outer_ctx = outer_ctx->outer_context;
6510 /* Notice a threadprivate variable DECL used in OMP context CTX.
6511 This just prints out diagnostics about threadprivate variable uses
6512 in untied tasks. If DECL2 is non-NULL, prevent this warning
6513 on that variable. */
6515 static bool
6516 omp_notice_threadprivate_variable (struct gimplify_omp_ctx *ctx, tree decl,
6517 tree decl2)
6519 splay_tree_node n;
6520 struct gimplify_omp_ctx *octx;
6522 for (octx = ctx; octx; octx = octx->outer_context)
6523 if ((octx->region_type & ORT_TARGET) != 0)
6525 n = splay_tree_lookup (octx->variables, (splay_tree_key)decl);
6526 if (n == NULL)
6528 error ("threadprivate variable %qE used in target region",
6529 DECL_NAME (decl));
6530 error_at (octx->location, "enclosing target region");
6531 splay_tree_insert (octx->variables, (splay_tree_key)decl, 0);
6533 if (decl2)
6534 splay_tree_insert (octx->variables, (splay_tree_key)decl2, 0);
6537 if (ctx->region_type != ORT_UNTIED_TASK)
6538 return false;
6539 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
6540 if (n == NULL)
6542 error ("threadprivate variable %qE used in untied task",
6543 DECL_NAME (decl));
6544 error_at (ctx->location, "enclosing task");
6545 splay_tree_insert (ctx->variables, (splay_tree_key)decl, 0);
6547 if (decl2)
6548 splay_tree_insert (ctx->variables, (splay_tree_key)decl2, 0);
6549 return false;
6552 /* Return true if global var DECL is device resident. */
6554 static bool
6555 device_resident_p (tree decl)
6557 tree attr = lookup_attribute ("oacc declare target", DECL_ATTRIBUTES (decl));
6559 if (!attr)
6560 return false;
6562 for (tree t = TREE_VALUE (attr); t; t = TREE_PURPOSE (t))
6564 tree c = TREE_VALUE (t);
6565 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_DEVICE_RESIDENT)
6566 return true;
6569 return false;
6572 /* Determine outer default flags for DECL mentioned in an OMP region
6573 but not declared in an enclosing clause.
6575 ??? Some compiler-generated variables (like SAVE_EXPRs) could be
6576 remapped firstprivate instead of shared. To some extent this is
6577 addressed in omp_firstprivatize_type_sizes, but not
6578 effectively. */
6580 static unsigned
6581 omp_default_clause (struct gimplify_omp_ctx *ctx, tree decl,
6582 bool in_code, unsigned flags)
6584 enum omp_clause_default_kind default_kind = ctx->default_kind;
6585 enum omp_clause_default_kind kind;
6587 kind = lang_hooks.decls.omp_predetermined_sharing (decl);
6588 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
6589 default_kind = kind;
6591 switch (default_kind)
6593 case OMP_CLAUSE_DEFAULT_NONE:
6595 const char *rtype;
6597 if (ctx->region_type & ORT_PARALLEL)
6598 rtype = "parallel";
6599 else if (ctx->region_type & ORT_TASK)
6600 rtype = "task";
6601 else if (ctx->region_type & ORT_TEAMS)
6602 rtype = "teams";
6603 else
6604 gcc_unreachable ();
6606 error ("%qE not specified in enclosing %s",
6607 DECL_NAME (lang_hooks.decls.omp_report_decl (decl)), rtype);
6608 error_at (ctx->location, "enclosing %s", rtype);
6610 /* FALLTHRU */
6611 case OMP_CLAUSE_DEFAULT_SHARED:
6612 flags |= GOVD_SHARED;
6613 break;
6614 case OMP_CLAUSE_DEFAULT_PRIVATE:
6615 flags |= GOVD_PRIVATE;
6616 break;
6617 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
6618 flags |= GOVD_FIRSTPRIVATE;
6619 break;
6620 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
6621 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
6622 gcc_assert ((ctx->region_type & ORT_TASK) != 0);
6623 if (struct gimplify_omp_ctx *octx = ctx->outer_context)
6625 omp_notice_variable (octx, decl, in_code);
6626 for (; octx; octx = octx->outer_context)
6628 splay_tree_node n2;
6630 n2 = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
6631 if ((octx->region_type & (ORT_TARGET_DATA | ORT_TARGET)) != 0
6632 && (n2 == NULL || (n2->value & GOVD_DATA_SHARE_CLASS) == 0))
6633 continue;
6634 if (n2 && (n2->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED)
6636 flags |= GOVD_FIRSTPRIVATE;
6637 goto found_outer;
6639 if ((octx->region_type & (ORT_PARALLEL | ORT_TEAMS)) != 0)
6641 flags |= GOVD_SHARED;
6642 goto found_outer;
6647 if (TREE_CODE (decl) == PARM_DECL
6648 || (!is_global_var (decl)
6649 && DECL_CONTEXT (decl) == current_function_decl))
6650 flags |= GOVD_FIRSTPRIVATE;
6651 else
6652 flags |= GOVD_SHARED;
6653 found_outer:
6654 break;
6656 default:
6657 gcc_unreachable ();
6660 return flags;
6664 /* Determine outer default flags for DECL mentioned in an OACC region
6665 but not declared in an enclosing clause. */
6667 static unsigned
6668 oacc_default_clause (struct gimplify_omp_ctx *ctx, tree decl, unsigned flags)
6670 const char *rkind;
6671 bool on_device = false;
6672 tree type = TREE_TYPE (decl);
6674 if (lang_hooks.decls.omp_privatize_by_reference (decl))
6675 type = TREE_TYPE (type);
6677 if ((ctx->region_type & (ORT_ACC_PARALLEL | ORT_ACC_KERNELS)) != 0
6678 && is_global_var (decl)
6679 && device_resident_p (decl))
6681 on_device = true;
6682 flags |= GOVD_MAP_TO_ONLY;
6685 switch (ctx->region_type)
6687 default:
6688 gcc_unreachable ();
6690 case ORT_ACC_KERNELS:
6691 /* Scalars are default 'copy' under kernels, non-scalars are default
6692 'present_or_copy'. */
6693 flags |= GOVD_MAP;
6694 if (!AGGREGATE_TYPE_P (type))
6695 flags |= GOVD_MAP_FORCE;
6697 rkind = "kernels";
6698 break;
6700 case ORT_ACC_PARALLEL:
6702 if (on_device || AGGREGATE_TYPE_P (type))
6703 /* Aggregates default to 'present_or_copy'. */
6704 flags |= GOVD_MAP;
6705 else
6706 /* Scalars default to 'firstprivate'. */
6707 flags |= GOVD_FIRSTPRIVATE;
6708 rkind = "parallel";
6710 break;
6713 if (DECL_ARTIFICIAL (decl))
6714 ; /* We can get compiler-generated decls, and should not complain
6715 about them. */
6716 else if (ctx->default_kind == OMP_CLAUSE_DEFAULT_NONE)
6718 error ("%qE not specified in enclosing OpenACC %qs construct",
6719 DECL_NAME (lang_hooks.decls.omp_report_decl (decl)), rkind);
6720 inform (ctx->location, "enclosing OpenACC %qs construct", rkind);
6722 else
6723 gcc_checking_assert (ctx->default_kind == OMP_CLAUSE_DEFAULT_SHARED);
6725 return flags;
6728 /* Record the fact that DECL was used within the OMP context CTX.
6729 IN_CODE is true when real code uses DECL, and false when we should
6730 merely emit default(none) errors. Return true if DECL is going to
6731 be remapped and thus DECL shouldn't be gimplified into its
6732 DECL_VALUE_EXPR (if any). */
6734 static bool
6735 omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
6737 splay_tree_node n;
6738 unsigned flags = in_code ? GOVD_SEEN : 0;
6739 bool ret = false, shared;
6741 if (error_operand_p (decl))
6742 return false;
6744 if (ctx->region_type == ORT_NONE)
6745 return lang_hooks.decls.omp_disregard_value_expr (decl, false);
6747 if (is_global_var (decl))
6749 /* Threadprivate variables are predetermined. */
6750 if (DECL_THREAD_LOCAL_P (decl))
6751 return omp_notice_threadprivate_variable (ctx, decl, NULL_TREE);
6753 if (DECL_HAS_VALUE_EXPR_P (decl))
6755 tree value = get_base_address (DECL_VALUE_EXPR (decl));
6757 if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
6758 return omp_notice_threadprivate_variable (ctx, decl, value);
6761 if (gimplify_omp_ctxp->outer_context == NULL
6762 && VAR_P (decl)
6763 && get_oacc_fn_attrib (current_function_decl))
6765 location_t loc = DECL_SOURCE_LOCATION (decl);
6767 if (lookup_attribute ("omp declare target link",
6768 DECL_ATTRIBUTES (decl)))
6770 error_at (loc,
6771 "%qE with %<link%> clause used in %<routine%> function",
6772 DECL_NAME (decl));
6773 return false;
6775 else if (!lookup_attribute ("omp declare target",
6776 DECL_ATTRIBUTES (decl)))
6778 error_at (loc,
6779 "%qE requires a %<declare%> directive for use "
6780 "in a %<routine%> function", DECL_NAME (decl));
6781 return false;
6786 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
6787 if ((ctx->region_type & ORT_TARGET) != 0)
6789 ret = lang_hooks.decls.omp_disregard_value_expr (decl, true);
6790 if (n == NULL)
6792 unsigned nflags = flags;
6793 if (ctx->target_map_pointers_as_0len_arrays
6794 || ctx->target_map_scalars_firstprivate)
6796 bool is_declare_target = false;
6797 bool is_scalar = false;
6798 if (is_global_var (decl)
6799 && varpool_node::get_create (decl)->offloadable)
6801 struct gimplify_omp_ctx *octx;
6802 for (octx = ctx->outer_context;
6803 octx; octx = octx->outer_context)
6805 n = splay_tree_lookup (octx->variables,
6806 (splay_tree_key)decl);
6807 if (n
6808 && (n->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED
6809 && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
6810 break;
6812 is_declare_target = octx == NULL;
6814 if (!is_declare_target && ctx->target_map_scalars_firstprivate)
6816 tree type = TREE_TYPE (decl);
6817 if (TREE_CODE (type) == REFERENCE_TYPE)
6818 type = TREE_TYPE (type);
6819 if (TREE_CODE (type) == COMPLEX_TYPE)
6820 type = TREE_TYPE (type);
6821 if (INTEGRAL_TYPE_P (type)
6822 || SCALAR_FLOAT_TYPE_P (type)
6823 || TREE_CODE (type) == POINTER_TYPE)
6824 is_scalar = true;
6826 if (is_declare_target)
6828 else if (ctx->target_map_pointers_as_0len_arrays
6829 && (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
6830 || (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE
6831 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl)))
6832 == POINTER_TYPE)))
6833 nflags |= GOVD_MAP | GOVD_MAP_0LEN_ARRAY;
6834 else if (is_scalar)
6835 nflags |= GOVD_FIRSTPRIVATE;
6838 struct gimplify_omp_ctx *octx = ctx->outer_context;
6839 if ((ctx->region_type & ORT_ACC) && octx)
6841 /* Look in outer OpenACC contexts, to see if there's a
6842 data attribute for this variable. */
6843 omp_notice_variable (octx, decl, in_code);
6845 for (; octx; octx = octx->outer_context)
6847 if (!(octx->region_type & (ORT_TARGET_DATA | ORT_TARGET)))
6848 break;
6849 splay_tree_node n2
6850 = splay_tree_lookup (octx->variables,
6851 (splay_tree_key) decl);
6852 if (n2)
6854 if (octx->region_type == ORT_ACC_HOST_DATA)
6855 error ("variable %qE declared in enclosing "
6856 "%<host_data%> region", DECL_NAME (decl));
6857 nflags |= GOVD_MAP;
6858 if (octx->region_type == ORT_ACC_DATA
6859 && (n2->value & GOVD_MAP_0LEN_ARRAY))
6860 nflags |= GOVD_MAP_0LEN_ARRAY;
6861 goto found_outer;
6867 tree type = TREE_TYPE (decl);
6869 if (nflags == flags
6870 && gimplify_omp_ctxp->target_firstprivatize_array_bases
6871 && lang_hooks.decls.omp_privatize_by_reference (decl))
6872 type = TREE_TYPE (type);
6873 if (nflags == flags
6874 && !lang_hooks.types.omp_mappable_type (type))
6876 error ("%qD referenced in target region does not have "
6877 "a mappable type", decl);
6878 nflags |= GOVD_MAP | GOVD_EXPLICIT;
6880 else if (nflags == flags)
6882 if ((ctx->region_type & ORT_ACC) != 0)
6883 nflags = oacc_default_clause (ctx, decl, flags);
6884 else
6885 nflags |= GOVD_MAP;
6888 found_outer:
6889 omp_add_variable (ctx, decl, nflags);
6891 else
6893 /* If nothing changed, there's nothing left to do. */
6894 if ((n->value & flags) == flags)
6895 return ret;
6896 flags |= n->value;
6897 n->value = flags;
6899 goto do_outer;
6902 if (n == NULL)
6904 if (ctx->region_type == ORT_WORKSHARE
6905 || ctx->region_type == ORT_SIMD
6906 || ctx->region_type == ORT_ACC
6907 || (ctx->region_type & ORT_TARGET_DATA) != 0)
6908 goto do_outer;
6910 flags = omp_default_clause (ctx, decl, in_code, flags);
6912 if ((flags & GOVD_PRIVATE)
6913 && lang_hooks.decls.omp_private_outer_ref (decl))
6914 flags |= GOVD_PRIVATE_OUTER_REF;
6916 omp_add_variable (ctx, decl, flags);
6918 shared = (flags & GOVD_SHARED) != 0;
6919 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
6920 goto do_outer;
6923 if ((n->value & (GOVD_SEEN | GOVD_LOCAL)) == 0
6924 && (flags & (GOVD_SEEN | GOVD_LOCAL)) == GOVD_SEEN
6925 && DECL_SIZE (decl))
6927 if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
6929 splay_tree_node n2;
6930 tree t = DECL_VALUE_EXPR (decl);
6931 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
6932 t = TREE_OPERAND (t, 0);
6933 gcc_assert (DECL_P (t));
6934 n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
6935 n2->value |= GOVD_SEEN;
6937 else if (lang_hooks.decls.omp_privatize_by_reference (decl)
6938 && TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)))
6939 && (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl))))
6940 != INTEGER_CST))
6942 splay_tree_node n2;
6943 tree t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
6944 gcc_assert (DECL_P (t));
6945 n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
6946 if (n2)
6947 n2->value |= GOVD_SEEN;
6951 shared = ((flags | n->value) & GOVD_SHARED) != 0;
6952 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
6954 /* If nothing changed, there's nothing left to do. */
6955 if ((n->value & flags) == flags)
6956 return ret;
6957 flags |= n->value;
6958 n->value = flags;
6960 do_outer:
6961 /* If the variable is private in the current context, then we don't
6962 need to propagate anything to an outer context. */
6963 if ((flags & GOVD_PRIVATE) && !(flags & GOVD_PRIVATE_OUTER_REF))
6964 return ret;
6965 if ((flags & (GOVD_LINEAR | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
6966 == (GOVD_LINEAR | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
6967 return ret;
6968 if ((flags & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
6969 | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
6970 == (GOVD_LASTPRIVATE | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
6971 return ret;
6972 if (ctx->outer_context
6973 && omp_notice_variable (ctx->outer_context, decl, in_code))
6974 return true;
6975 return ret;
6978 /* Verify that DECL is private within CTX. If there's specific information
6979 to the contrary in the innermost scope, generate an error. */
6981 static bool
6982 omp_is_private (struct gimplify_omp_ctx *ctx, tree decl, int simd)
6984 splay_tree_node n;
6986 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
6987 if (n != NULL)
6989 if (n->value & GOVD_SHARED)
6991 if (ctx == gimplify_omp_ctxp)
6993 if (simd)
6994 error ("iteration variable %qE is predetermined linear",
6995 DECL_NAME (decl));
6996 else
6997 error ("iteration variable %qE should be private",
6998 DECL_NAME (decl));
6999 n->value = GOVD_PRIVATE;
7000 return true;
7002 else
7003 return false;
7005 else if ((n->value & GOVD_EXPLICIT) != 0
7006 && (ctx == gimplify_omp_ctxp
7007 || (ctx->region_type == ORT_COMBINED_PARALLEL
7008 && gimplify_omp_ctxp->outer_context == ctx)))
7010 if ((n->value & GOVD_FIRSTPRIVATE) != 0)
7011 error ("iteration variable %qE should not be firstprivate",
7012 DECL_NAME (decl));
7013 else if ((n->value & GOVD_REDUCTION) != 0)
7014 error ("iteration variable %qE should not be reduction",
7015 DECL_NAME (decl));
7016 else if (simd == 0 && (n->value & GOVD_LINEAR) != 0)
7017 error ("iteration variable %qE should not be linear",
7018 DECL_NAME (decl));
7019 else if (simd == 1 && (n->value & GOVD_LASTPRIVATE) != 0)
7020 error ("iteration variable %qE should not be lastprivate",
7021 DECL_NAME (decl));
7022 else if (simd && (n->value & GOVD_PRIVATE) != 0)
7023 error ("iteration variable %qE should not be private",
7024 DECL_NAME (decl));
7025 else if (simd == 2 && (n->value & GOVD_LINEAR) != 0)
7026 error ("iteration variable %qE is predetermined linear",
7027 DECL_NAME (decl));
7029 return (ctx == gimplify_omp_ctxp
7030 || (ctx->region_type == ORT_COMBINED_PARALLEL
7031 && gimplify_omp_ctxp->outer_context == ctx));
7034 if (ctx->region_type != ORT_WORKSHARE
7035 && ctx->region_type != ORT_SIMD
7036 && ctx->region_type != ORT_ACC)
7037 return false;
7038 else if (ctx->outer_context)
7039 return omp_is_private (ctx->outer_context, decl, simd);
7040 return false;
7043 /* Return true if DECL is private within a parallel region
7044 that binds to the current construct's context or in parallel
7045 region's REDUCTION clause. */
7047 static bool
7048 omp_check_private (struct gimplify_omp_ctx *ctx, tree decl, bool copyprivate)
7050 splay_tree_node n;
7054 ctx = ctx->outer_context;
7055 if (ctx == NULL)
7057 if (is_global_var (decl))
7058 return false;
7060 /* References might be private, but might be shared too,
7061 when checking for copyprivate, assume they might be
7062 private, otherwise assume they might be shared. */
7063 if (copyprivate)
7064 return true;
7066 if (lang_hooks.decls.omp_privatize_by_reference (decl))
7067 return false;
7069 /* Treat C++ privatized non-static data members outside
7070 of the privatization the same. */
7071 if (omp_member_access_dummy_var (decl))
7072 return false;
7074 return true;
7077 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
7079 if ((ctx->region_type & (ORT_TARGET | ORT_TARGET_DATA)) != 0
7080 && (n == NULL || (n->value & GOVD_DATA_SHARE_CLASS) == 0))
7081 continue;
7083 if (n != NULL)
7085 if ((n->value & GOVD_LOCAL) != 0
7086 && omp_member_access_dummy_var (decl))
7087 return false;
7088 return (n->value & GOVD_SHARED) == 0;
7091 while (ctx->region_type == ORT_WORKSHARE
7092 || ctx->region_type == ORT_SIMD
7093 || ctx->region_type == ORT_ACC);
7094 return false;
7097 /* Return true if the CTX is combined with distribute and thus
7098 lastprivate can't be supported. */
7100 static bool
7101 omp_no_lastprivate (struct gimplify_omp_ctx *ctx)
7105 if (ctx->outer_context == NULL)
7106 return false;
7107 ctx = ctx->outer_context;
7108 switch (ctx->region_type)
7110 case ORT_WORKSHARE:
7111 if (!ctx->combined_loop)
7112 return false;
7113 if (ctx->distribute)
7114 return lang_GNU_Fortran ();
7115 break;
7116 case ORT_COMBINED_PARALLEL:
7117 break;
7118 case ORT_COMBINED_TEAMS:
7119 return lang_GNU_Fortran ();
7120 default:
7121 return false;
7124 while (1);
7127 /* Callback for walk_tree to find a DECL_EXPR for the given DECL. */
7129 static tree
7130 find_decl_expr (tree *tp, int *walk_subtrees, void *data)
7132 tree t = *tp;
7134 /* If this node has been visited, unmark it and keep looking. */
7135 if (TREE_CODE (t) == DECL_EXPR && DECL_EXPR_DECL (t) == (tree) data)
7136 return t;
7138 if (IS_TYPE_OR_DECL_P (t))
7139 *walk_subtrees = 0;
7140 return NULL_TREE;
7143 /* Scan the OMP clauses in *LIST_P, installing mappings into a new
7144 and previous omp contexts. */
7146 static void
7147 gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
7148 enum omp_region_type region_type,
7149 enum tree_code code)
7151 struct gimplify_omp_ctx *ctx, *outer_ctx;
7152 tree c;
7153 hash_map<tree, tree> *struct_map_to_clause = NULL;
7154 tree *prev_list_p = NULL;
7156 ctx = new_omp_context (region_type);
7157 outer_ctx = ctx->outer_context;
7158 if (code == OMP_TARGET && !lang_GNU_Fortran ())
7160 ctx->target_map_pointers_as_0len_arrays = true;
7161 /* FIXME: For Fortran we want to set this too, when
7162 the Fortran FE is updated to OpenMP 4.5. */
7163 ctx->target_map_scalars_firstprivate = true;
7165 if (!lang_GNU_Fortran ())
7166 switch (code)
7168 case OMP_TARGET:
7169 case OMP_TARGET_DATA:
7170 case OMP_TARGET_ENTER_DATA:
7171 case OMP_TARGET_EXIT_DATA:
7172 case OACC_HOST_DATA:
7173 ctx->target_firstprivatize_array_bases = true;
7174 default:
7175 break;
7178 while ((c = *list_p) != NULL)
7180 bool remove = false;
7181 bool notice_outer = true;
7182 const char *check_non_private = NULL;
7183 unsigned int flags;
7184 tree decl;
7186 switch (OMP_CLAUSE_CODE (c))
7188 case OMP_CLAUSE_PRIVATE:
7189 flags = GOVD_PRIVATE | GOVD_EXPLICIT;
7190 if (lang_hooks.decls.omp_private_outer_ref (OMP_CLAUSE_DECL (c)))
7192 flags |= GOVD_PRIVATE_OUTER_REF;
7193 OMP_CLAUSE_PRIVATE_OUTER_REF (c) = 1;
7195 else
7196 notice_outer = false;
7197 goto do_add;
7198 case OMP_CLAUSE_SHARED:
7199 flags = GOVD_SHARED | GOVD_EXPLICIT;
7200 goto do_add;
7201 case OMP_CLAUSE_FIRSTPRIVATE:
7202 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
7203 check_non_private = "firstprivate";
7204 goto do_add;
7205 case OMP_CLAUSE_LASTPRIVATE:
7206 flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
7207 check_non_private = "lastprivate";
7208 decl = OMP_CLAUSE_DECL (c);
7209 if (omp_no_lastprivate (ctx))
7211 notice_outer = false;
7212 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
7214 else if (error_operand_p (decl))
7215 goto do_add;
7216 else if (outer_ctx
7217 && (outer_ctx->region_type == ORT_COMBINED_PARALLEL
7218 || outer_ctx->region_type == ORT_COMBINED_TEAMS)
7219 && splay_tree_lookup (outer_ctx->variables,
7220 (splay_tree_key) decl) == NULL)
7222 omp_add_variable (outer_ctx, decl, GOVD_SHARED | GOVD_SEEN);
7223 if (outer_ctx->outer_context)
7224 omp_notice_variable (outer_ctx->outer_context, decl, true);
7226 else if (outer_ctx
7227 && (outer_ctx->region_type & ORT_TASK) != 0
7228 && outer_ctx->combined_loop
7229 && splay_tree_lookup (outer_ctx->variables,
7230 (splay_tree_key) decl) == NULL)
7232 omp_add_variable (outer_ctx, decl, GOVD_LASTPRIVATE | GOVD_SEEN);
7233 if (outer_ctx->outer_context)
7234 omp_notice_variable (outer_ctx->outer_context, decl, true);
7236 else if (outer_ctx
7237 && (outer_ctx->region_type == ORT_WORKSHARE
7238 || outer_ctx->region_type == ORT_ACC)
7239 && outer_ctx->combined_loop
7240 && splay_tree_lookup (outer_ctx->variables,
7241 (splay_tree_key) decl) == NULL
7242 && !omp_check_private (outer_ctx, decl, false))
7244 omp_add_variable (outer_ctx, decl, GOVD_LASTPRIVATE | GOVD_SEEN);
7245 if (outer_ctx->outer_context
7246 && (outer_ctx->outer_context->region_type
7247 == ORT_COMBINED_PARALLEL)
7248 && splay_tree_lookup (outer_ctx->outer_context->variables,
7249 (splay_tree_key) decl) == NULL)
7251 struct gimplify_omp_ctx *octx = outer_ctx->outer_context;
7252 omp_add_variable (octx, decl, GOVD_SHARED | GOVD_SEEN);
7253 if (octx->outer_context)
7254 omp_notice_variable (octx->outer_context, decl, true);
7256 else if (outer_ctx->outer_context)
7257 omp_notice_variable (outer_ctx->outer_context, decl, true);
7259 goto do_add;
7260 case OMP_CLAUSE_REDUCTION:
7261 flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
7262 /* OpenACC permits reductions on private variables. */
7263 if (!(region_type & ORT_ACC))
7264 check_non_private = "reduction";
7265 decl = OMP_CLAUSE_DECL (c);
7266 if (TREE_CODE (decl) == MEM_REF)
7268 tree type = TREE_TYPE (decl);
7269 if (gimplify_expr (&TYPE_MAX_VALUE (TYPE_DOMAIN (type)), pre_p,
7270 NULL, is_gimple_val, fb_rvalue, false)
7271 == GS_ERROR)
7273 remove = true;
7274 break;
7276 tree v = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
7277 if (DECL_P (v))
7279 omp_firstprivatize_variable (ctx, v);
7280 omp_notice_variable (ctx, v, true);
7282 decl = TREE_OPERAND (decl, 0);
7283 if (TREE_CODE (decl) == POINTER_PLUS_EXPR)
7285 if (gimplify_expr (&TREE_OPERAND (decl, 1), pre_p,
7286 NULL, is_gimple_val, fb_rvalue, false)
7287 == GS_ERROR)
7289 remove = true;
7290 break;
7292 v = TREE_OPERAND (decl, 1);
7293 if (DECL_P (v))
7295 omp_firstprivatize_variable (ctx, v);
7296 omp_notice_variable (ctx, v, true);
7298 decl = TREE_OPERAND (decl, 0);
7300 if (TREE_CODE (decl) == ADDR_EXPR
7301 || TREE_CODE (decl) == INDIRECT_REF)
7302 decl = TREE_OPERAND (decl, 0);
7304 goto do_add_decl;
7305 case OMP_CLAUSE_LINEAR:
7306 if (gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c), pre_p, NULL,
7307 is_gimple_val, fb_rvalue) == GS_ERROR)
7309 remove = true;
7310 break;
7312 else
7314 if (code == OMP_SIMD
7315 && !OMP_CLAUSE_LINEAR_NO_COPYIN (c))
7317 struct gimplify_omp_ctx *octx = outer_ctx;
7318 if (octx
7319 && octx->region_type == ORT_WORKSHARE
7320 && octx->combined_loop
7321 && !octx->distribute)
7323 if (octx->outer_context
7324 && (octx->outer_context->region_type
7325 == ORT_COMBINED_PARALLEL))
7326 octx = octx->outer_context->outer_context;
7327 else
7328 octx = octx->outer_context;
7330 if (octx
7331 && octx->region_type == ORT_WORKSHARE
7332 && octx->combined_loop
7333 && octx->distribute
7334 && !lang_GNU_Fortran ())
7336 error_at (OMP_CLAUSE_LOCATION (c),
7337 "%<linear%> clause for variable other than "
7338 "loop iterator specified on construct "
7339 "combined with %<distribute%>");
7340 remove = true;
7341 break;
7344 /* For combined #pragma omp parallel for simd, need to put
7345 lastprivate and perhaps firstprivate too on the
7346 parallel. Similarly for #pragma omp for simd. */
7347 struct gimplify_omp_ctx *octx = outer_ctx;
7348 decl = NULL_TREE;
7349 if (omp_no_lastprivate (ctx))
7350 OMP_CLAUSE_LINEAR_NO_COPYOUT (c) = 1;
7353 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c)
7354 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
7355 break;
7356 decl = OMP_CLAUSE_DECL (c);
7357 if (error_operand_p (decl))
7359 decl = NULL_TREE;
7360 break;
7362 flags = GOVD_SEEN;
7363 if (!OMP_CLAUSE_LINEAR_NO_COPYIN (c))
7364 flags |= GOVD_FIRSTPRIVATE;
7365 if (!OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
7366 flags |= GOVD_LASTPRIVATE;
7367 if (octx
7368 && octx->region_type == ORT_WORKSHARE
7369 && octx->combined_loop)
7371 if (octx->outer_context
7372 && (octx->outer_context->region_type
7373 == ORT_COMBINED_PARALLEL))
7374 octx = octx->outer_context;
7375 else if (omp_check_private (octx, decl, false))
7376 break;
7378 else if (octx
7379 && (octx->region_type & ORT_TASK) != 0
7380 && octx->combined_loop)
7382 else if (octx
7383 && octx->region_type == ORT_COMBINED_PARALLEL
7384 && ctx->region_type == ORT_WORKSHARE
7385 && octx == outer_ctx)
7386 flags = GOVD_SEEN | GOVD_SHARED;
7387 else if (octx
7388 && octx->region_type == ORT_COMBINED_TEAMS)
7389 flags = GOVD_SEEN | GOVD_SHARED;
7390 else if (octx
7391 && octx->region_type == ORT_COMBINED_TARGET)
7393 flags &= ~GOVD_LASTPRIVATE;
7394 if (flags == GOVD_SEEN)
7395 break;
7397 else
7398 break;
7399 splay_tree_node on
7400 = splay_tree_lookup (octx->variables,
7401 (splay_tree_key) decl);
7402 if (on && (on->value & GOVD_DATA_SHARE_CLASS) != 0)
7404 octx = NULL;
7405 break;
7407 omp_add_variable (octx, decl, flags);
7408 if (octx->outer_context == NULL)
7409 break;
7410 octx = octx->outer_context;
7412 while (1);
7413 if (octx
7414 && decl
7415 && (!OMP_CLAUSE_LINEAR_NO_COPYIN (c)
7416 || !OMP_CLAUSE_LINEAR_NO_COPYOUT (c)))
7417 omp_notice_variable (octx, decl, true);
7419 flags = GOVD_LINEAR | GOVD_EXPLICIT;
7420 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c)
7421 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
7423 notice_outer = false;
7424 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
7426 goto do_add;
7428 case OMP_CLAUSE_MAP:
7429 decl = OMP_CLAUSE_DECL (c);
7430 if (error_operand_p (decl))
7431 remove = true;
7432 switch (code)
7434 case OMP_TARGET:
7435 break;
7436 case OACC_DATA:
7437 if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
7438 break;
7439 /* FALLTHRU */
7440 case OMP_TARGET_DATA:
7441 case OMP_TARGET_ENTER_DATA:
7442 case OMP_TARGET_EXIT_DATA:
7443 case OACC_ENTER_DATA:
7444 case OACC_EXIT_DATA:
7445 case OACC_HOST_DATA:
7446 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER
7447 || (OMP_CLAUSE_MAP_KIND (c)
7448 == GOMP_MAP_FIRSTPRIVATE_REFERENCE))
7449 /* For target {,enter ,exit }data only the array slice is
7450 mapped, but not the pointer to it. */
7451 remove = true;
7452 break;
7453 default:
7454 break;
7456 if (remove)
7457 break;
7458 if (DECL_P (decl) && outer_ctx && (region_type & ORT_ACC))
7460 struct gimplify_omp_ctx *octx;
7461 for (octx = outer_ctx; octx; octx = octx->outer_context)
7463 if (octx->region_type != ORT_ACC_HOST_DATA)
7464 break;
7465 splay_tree_node n2
7466 = splay_tree_lookup (octx->variables,
7467 (splay_tree_key) decl);
7468 if (n2)
7469 error_at (OMP_CLAUSE_LOCATION (c), "variable %qE "
7470 "declared in enclosing %<host_data%> region",
7471 DECL_NAME (decl));
7474 if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
7475 OMP_CLAUSE_SIZE (c) = DECL_P (decl) ? DECL_SIZE_UNIT (decl)
7476 : TYPE_SIZE_UNIT (TREE_TYPE (decl));
7477 if (gimplify_expr (&OMP_CLAUSE_SIZE (c), pre_p,
7478 NULL, is_gimple_val, fb_rvalue) == GS_ERROR)
7480 remove = true;
7481 break;
7483 else if ((OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER
7484 || (OMP_CLAUSE_MAP_KIND (c)
7485 == GOMP_MAP_FIRSTPRIVATE_REFERENCE))
7486 && TREE_CODE (OMP_CLAUSE_SIZE (c)) != INTEGER_CST)
7488 OMP_CLAUSE_SIZE (c)
7489 = get_initialized_tmp_var (OMP_CLAUSE_SIZE (c), pre_p, NULL,
7490 false);
7491 omp_add_variable (ctx, OMP_CLAUSE_SIZE (c),
7492 GOVD_FIRSTPRIVATE | GOVD_SEEN);
7494 if (!DECL_P (decl))
7496 tree d = decl, *pd;
7497 if (TREE_CODE (d) == ARRAY_REF)
7499 while (TREE_CODE (d) == ARRAY_REF)
7500 d = TREE_OPERAND (d, 0);
7501 if (TREE_CODE (d) == COMPONENT_REF
7502 && TREE_CODE (TREE_TYPE (d)) == ARRAY_TYPE)
7503 decl = d;
7505 pd = &OMP_CLAUSE_DECL (c);
7506 if (d == decl
7507 && TREE_CODE (decl) == INDIRECT_REF
7508 && TREE_CODE (TREE_OPERAND (decl, 0)) == COMPONENT_REF
7509 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl, 0)))
7510 == REFERENCE_TYPE))
7512 pd = &TREE_OPERAND (decl, 0);
7513 decl = TREE_OPERAND (decl, 0);
7515 if (TREE_CODE (decl) == COMPONENT_REF)
7517 while (TREE_CODE (decl) == COMPONENT_REF)
7518 decl = TREE_OPERAND (decl, 0);
7519 if (TREE_CODE (decl) == INDIRECT_REF
7520 && DECL_P (TREE_OPERAND (decl, 0))
7521 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl, 0)))
7522 == REFERENCE_TYPE))
7523 decl = TREE_OPERAND (decl, 0);
7525 if (gimplify_expr (pd, pre_p, NULL, is_gimple_lvalue, fb_lvalue)
7526 == GS_ERROR)
7528 remove = true;
7529 break;
7531 if (DECL_P (decl))
7533 if (error_operand_p (decl))
7535 remove = true;
7536 break;
7539 tree stype = TREE_TYPE (decl);
7540 if (TREE_CODE (stype) == REFERENCE_TYPE)
7541 stype = TREE_TYPE (stype);
7542 if (TYPE_SIZE_UNIT (stype) == NULL
7543 || TREE_CODE (TYPE_SIZE_UNIT (stype)) != INTEGER_CST)
7545 error_at (OMP_CLAUSE_LOCATION (c),
7546 "mapping field %qE of variable length "
7547 "structure", OMP_CLAUSE_DECL (c));
7548 remove = true;
7549 break;
7552 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_POINTER)
7554 /* Error recovery. */
7555 if (prev_list_p == NULL)
7557 remove = true;
7558 break;
7560 if (OMP_CLAUSE_CHAIN (*prev_list_p) != c)
7562 tree ch = OMP_CLAUSE_CHAIN (*prev_list_p);
7563 if (ch == NULL_TREE || OMP_CLAUSE_CHAIN (ch) != c)
7565 remove = true;
7566 break;
7571 tree offset;
7572 HOST_WIDE_INT bitsize, bitpos;
7573 machine_mode mode;
7574 int unsignedp, reversep, volatilep = 0;
7575 tree base = OMP_CLAUSE_DECL (c);
7576 while (TREE_CODE (base) == ARRAY_REF)
7577 base = TREE_OPERAND (base, 0);
7578 if (TREE_CODE (base) == INDIRECT_REF)
7579 base = TREE_OPERAND (base, 0);
7580 base = get_inner_reference (base, &bitsize, &bitpos, &offset,
7581 &mode, &unsignedp, &reversep,
7582 &volatilep);
7583 tree orig_base = base;
7584 if ((TREE_CODE (base) == INDIRECT_REF
7585 || (TREE_CODE (base) == MEM_REF
7586 && integer_zerop (TREE_OPERAND (base, 1))))
7587 && DECL_P (TREE_OPERAND (base, 0))
7588 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0)))
7589 == REFERENCE_TYPE))
7590 base = TREE_OPERAND (base, 0);
7591 gcc_assert (base == decl
7592 && (offset == NULL_TREE
7593 || TREE_CODE (offset) == INTEGER_CST));
7595 splay_tree_node n
7596 = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
7597 bool ptr = (OMP_CLAUSE_MAP_KIND (c)
7598 == GOMP_MAP_ALWAYS_POINTER);
7599 if (n == NULL || (n->value & GOVD_MAP) == 0)
7601 tree l = build_omp_clause (OMP_CLAUSE_LOCATION (c),
7602 OMP_CLAUSE_MAP);
7603 OMP_CLAUSE_SET_MAP_KIND (l, GOMP_MAP_STRUCT);
7604 if (orig_base != base)
7605 OMP_CLAUSE_DECL (l) = unshare_expr (orig_base);
7606 else
7607 OMP_CLAUSE_DECL (l) = decl;
7608 OMP_CLAUSE_SIZE (l) = size_int (1);
7609 if (struct_map_to_clause == NULL)
7610 struct_map_to_clause = new hash_map<tree, tree>;
7611 struct_map_to_clause->put (decl, l);
7612 if (ptr)
7614 enum gomp_map_kind mkind
7615 = code == OMP_TARGET_EXIT_DATA
7616 ? GOMP_MAP_RELEASE : GOMP_MAP_ALLOC;
7617 tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
7618 OMP_CLAUSE_MAP);
7619 OMP_CLAUSE_SET_MAP_KIND (c2, mkind);
7620 OMP_CLAUSE_DECL (c2)
7621 = unshare_expr (OMP_CLAUSE_DECL (c));
7622 OMP_CLAUSE_CHAIN (c2) = *prev_list_p;
7623 OMP_CLAUSE_SIZE (c2)
7624 = TYPE_SIZE_UNIT (ptr_type_node);
7625 OMP_CLAUSE_CHAIN (l) = c2;
7626 if (OMP_CLAUSE_CHAIN (*prev_list_p) != c)
7628 tree c4 = OMP_CLAUSE_CHAIN (*prev_list_p);
7629 tree c3
7630 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
7631 OMP_CLAUSE_MAP);
7632 OMP_CLAUSE_SET_MAP_KIND (c3, mkind);
7633 OMP_CLAUSE_DECL (c3)
7634 = unshare_expr (OMP_CLAUSE_DECL (c4));
7635 OMP_CLAUSE_SIZE (c3)
7636 = TYPE_SIZE_UNIT (ptr_type_node);
7637 OMP_CLAUSE_CHAIN (c3) = *prev_list_p;
7638 OMP_CLAUSE_CHAIN (c2) = c3;
7640 *prev_list_p = l;
7641 prev_list_p = NULL;
7643 else
7645 OMP_CLAUSE_CHAIN (l) = c;
7646 *list_p = l;
7647 list_p = &OMP_CLAUSE_CHAIN (l);
7649 if (orig_base != base && code == OMP_TARGET)
7651 tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
7652 OMP_CLAUSE_MAP);
7653 enum gomp_map_kind mkind
7654 = GOMP_MAP_FIRSTPRIVATE_REFERENCE;
7655 OMP_CLAUSE_SET_MAP_KIND (c2, mkind);
7656 OMP_CLAUSE_DECL (c2) = decl;
7657 OMP_CLAUSE_SIZE (c2) = size_zero_node;
7658 OMP_CLAUSE_CHAIN (c2) = OMP_CLAUSE_CHAIN (l);
7659 OMP_CLAUSE_CHAIN (l) = c2;
7661 flags = GOVD_MAP | GOVD_EXPLICIT;
7662 if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c)) || ptr)
7663 flags |= GOVD_SEEN;
7664 goto do_add_decl;
7666 else
7668 tree *osc = struct_map_to_clause->get (decl);
7669 tree *sc = NULL, *scp = NULL;
7670 if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c)) || ptr)
7671 n->value |= GOVD_SEEN;
7672 offset_int o1, o2;
7673 if (offset)
7674 o1 = wi::to_offset (offset);
7675 else
7676 o1 = 0;
7677 if (bitpos)
7678 o1 = o1 + bitpos / BITS_PER_UNIT;
7679 sc = &OMP_CLAUSE_CHAIN (*osc);
7680 if (*sc != c
7681 && (OMP_CLAUSE_MAP_KIND (*sc)
7682 == GOMP_MAP_FIRSTPRIVATE_REFERENCE))
7683 sc = &OMP_CLAUSE_CHAIN (*sc);
7684 for (; *sc != c; sc = &OMP_CLAUSE_CHAIN (*sc))
7685 if (ptr && sc == prev_list_p)
7686 break;
7687 else if (TREE_CODE (OMP_CLAUSE_DECL (*sc))
7688 != COMPONENT_REF
7689 && (TREE_CODE (OMP_CLAUSE_DECL (*sc))
7690 != INDIRECT_REF)
7691 && (TREE_CODE (OMP_CLAUSE_DECL (*sc))
7692 != ARRAY_REF))
7693 break;
7694 else
7696 tree offset2;
7697 HOST_WIDE_INT bitsize2, bitpos2;
7698 base = OMP_CLAUSE_DECL (*sc);
7699 if (TREE_CODE (base) == ARRAY_REF)
7701 while (TREE_CODE (base) == ARRAY_REF)
7702 base = TREE_OPERAND (base, 0);
7703 if (TREE_CODE (base) != COMPONENT_REF
7704 || (TREE_CODE (TREE_TYPE (base))
7705 != ARRAY_TYPE))
7706 break;
7708 else if (TREE_CODE (base) == INDIRECT_REF
7709 && (TREE_CODE (TREE_OPERAND (base, 0))
7710 == COMPONENT_REF)
7711 && (TREE_CODE (TREE_TYPE
7712 (TREE_OPERAND (base, 0)))
7713 == REFERENCE_TYPE))
7714 base = TREE_OPERAND (base, 0);
7715 base = get_inner_reference (base, &bitsize2,
7716 &bitpos2, &offset2,
7717 &mode, &unsignedp,
7718 &reversep, &volatilep);
7719 if ((TREE_CODE (base) == INDIRECT_REF
7720 || (TREE_CODE (base) == MEM_REF
7721 && integer_zerop (TREE_OPERAND (base,
7722 1))))
7723 && DECL_P (TREE_OPERAND (base, 0))
7724 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base,
7725 0)))
7726 == REFERENCE_TYPE))
7727 base = TREE_OPERAND (base, 0);
7728 if (base != decl)
7729 break;
7730 if (scp)
7731 continue;
7732 gcc_assert (offset == NULL_TREE
7733 || TREE_CODE (offset) == INTEGER_CST);
7734 tree d1 = OMP_CLAUSE_DECL (*sc);
7735 tree d2 = OMP_CLAUSE_DECL (c);
7736 while (TREE_CODE (d1) == ARRAY_REF)
7737 d1 = TREE_OPERAND (d1, 0);
7738 while (TREE_CODE (d2) == ARRAY_REF)
7739 d2 = TREE_OPERAND (d2, 0);
7740 if (TREE_CODE (d1) == INDIRECT_REF)
7741 d1 = TREE_OPERAND (d1, 0);
7742 if (TREE_CODE (d2) == INDIRECT_REF)
7743 d2 = TREE_OPERAND (d2, 0);
7744 while (TREE_CODE (d1) == COMPONENT_REF)
7745 if (TREE_CODE (d2) == COMPONENT_REF
7746 && TREE_OPERAND (d1, 1)
7747 == TREE_OPERAND (d2, 1))
7749 d1 = TREE_OPERAND (d1, 0);
7750 d2 = TREE_OPERAND (d2, 0);
7752 else
7753 break;
7754 if (d1 == d2)
7756 error_at (OMP_CLAUSE_LOCATION (c),
7757 "%qE appears more than once in map "
7758 "clauses", OMP_CLAUSE_DECL (c));
7759 remove = true;
7760 break;
7762 if (offset2)
7763 o2 = wi::to_offset (offset2);
7764 else
7765 o2 = 0;
7766 if (bitpos2)
7767 o2 = o2 + bitpos2 / BITS_PER_UNIT;
7768 if (wi::ltu_p (o1, o2)
7769 || (wi::eq_p (o1, o2) && bitpos < bitpos2))
7771 if (ptr)
7772 scp = sc;
7773 else
7774 break;
7777 if (remove)
7778 break;
7779 OMP_CLAUSE_SIZE (*osc)
7780 = size_binop (PLUS_EXPR, OMP_CLAUSE_SIZE (*osc),
7781 size_one_node);
7782 if (ptr)
7784 tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
7785 OMP_CLAUSE_MAP);
7786 tree cl = NULL_TREE;
7787 enum gomp_map_kind mkind
7788 = code == OMP_TARGET_EXIT_DATA
7789 ? GOMP_MAP_RELEASE : GOMP_MAP_ALLOC;
7790 OMP_CLAUSE_SET_MAP_KIND (c2, mkind);
7791 OMP_CLAUSE_DECL (c2)
7792 = unshare_expr (OMP_CLAUSE_DECL (c));
7793 OMP_CLAUSE_CHAIN (c2) = scp ? *scp : *prev_list_p;
7794 OMP_CLAUSE_SIZE (c2)
7795 = TYPE_SIZE_UNIT (ptr_type_node);
7796 cl = scp ? *prev_list_p : c2;
7797 if (OMP_CLAUSE_CHAIN (*prev_list_p) != c)
7799 tree c4 = OMP_CLAUSE_CHAIN (*prev_list_p);
7800 tree c3
7801 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
7802 OMP_CLAUSE_MAP);
7803 OMP_CLAUSE_SET_MAP_KIND (c3, mkind);
7804 OMP_CLAUSE_DECL (c3)
7805 = unshare_expr (OMP_CLAUSE_DECL (c4));
7806 OMP_CLAUSE_SIZE (c3)
7807 = TYPE_SIZE_UNIT (ptr_type_node);
7808 OMP_CLAUSE_CHAIN (c3) = *prev_list_p;
7809 if (!scp)
7810 OMP_CLAUSE_CHAIN (c2) = c3;
7811 else
7812 cl = c3;
7814 if (scp)
7815 *scp = c2;
7816 if (sc == prev_list_p)
7818 *sc = cl;
7819 prev_list_p = NULL;
7821 else
7823 *prev_list_p = OMP_CLAUSE_CHAIN (c);
7824 list_p = prev_list_p;
7825 prev_list_p = NULL;
7826 OMP_CLAUSE_CHAIN (c) = *sc;
7827 *sc = cl;
7828 continue;
7831 else if (*sc != c)
7833 *list_p = OMP_CLAUSE_CHAIN (c);
7834 OMP_CLAUSE_CHAIN (c) = *sc;
7835 *sc = c;
7836 continue;
7840 if (!remove
7841 && OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_ALWAYS_POINTER
7842 && OMP_CLAUSE_CHAIN (c)
7843 && OMP_CLAUSE_CODE (OMP_CLAUSE_CHAIN (c)) == OMP_CLAUSE_MAP
7844 && (OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (c))
7845 == GOMP_MAP_ALWAYS_POINTER))
7846 prev_list_p = list_p;
7847 break;
7849 flags = GOVD_MAP | GOVD_EXPLICIT;
7850 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_TO
7851 || OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_TOFROM)
7852 flags |= GOVD_MAP_ALWAYS_TO;
7853 goto do_add;
7855 case OMP_CLAUSE_DEPEND:
7856 if (OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SINK
7857 || OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SOURCE)
7859 /* Nothing to do. OMP_CLAUSE_DECL will be lowered in
7860 omp-low.c. */
7861 break;
7863 if (TREE_CODE (OMP_CLAUSE_DECL (c)) == COMPOUND_EXPR)
7865 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (c), 0), pre_p,
7866 NULL, is_gimple_val, fb_rvalue);
7867 OMP_CLAUSE_DECL (c) = TREE_OPERAND (OMP_CLAUSE_DECL (c), 1);
7869 if (error_operand_p (OMP_CLAUSE_DECL (c)))
7871 remove = true;
7872 break;
7874 OMP_CLAUSE_DECL (c) = build_fold_addr_expr (OMP_CLAUSE_DECL (c));
7875 if (gimplify_expr (&OMP_CLAUSE_DECL (c), pre_p, NULL,
7876 is_gimple_val, fb_rvalue) == GS_ERROR)
7878 remove = true;
7879 break;
7881 break;
7883 case OMP_CLAUSE_TO:
7884 case OMP_CLAUSE_FROM:
7885 case OMP_CLAUSE__CACHE_:
7886 decl = OMP_CLAUSE_DECL (c);
7887 if (error_operand_p (decl))
7889 remove = true;
7890 break;
7892 if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
7893 OMP_CLAUSE_SIZE (c) = DECL_P (decl) ? DECL_SIZE_UNIT (decl)
7894 : TYPE_SIZE_UNIT (TREE_TYPE (decl));
7895 if (gimplify_expr (&OMP_CLAUSE_SIZE (c), pre_p,
7896 NULL, is_gimple_val, fb_rvalue) == GS_ERROR)
7898 remove = true;
7899 break;
7901 if (!DECL_P (decl))
7903 if (gimplify_expr (&OMP_CLAUSE_DECL (c), pre_p,
7904 NULL, is_gimple_lvalue, fb_lvalue)
7905 == GS_ERROR)
7907 remove = true;
7908 break;
7910 break;
7912 goto do_notice;
7914 case OMP_CLAUSE_USE_DEVICE_PTR:
7915 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
7916 goto do_add;
7917 case OMP_CLAUSE_IS_DEVICE_PTR:
7918 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
7919 goto do_add;
7921 do_add:
7922 decl = OMP_CLAUSE_DECL (c);
7923 do_add_decl:
7924 if (error_operand_p (decl))
7926 remove = true;
7927 break;
7929 if (DECL_NAME (decl) == NULL_TREE && (flags & GOVD_SHARED) == 0)
7931 tree t = omp_member_access_dummy_var (decl);
7932 if (t)
7934 tree v = DECL_VALUE_EXPR (decl);
7935 DECL_NAME (decl) = DECL_NAME (TREE_OPERAND (v, 1));
7936 if (outer_ctx)
7937 omp_notice_variable (outer_ctx, t, true);
7940 if (code == OACC_DATA
7941 && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
7942 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
7943 flags |= GOVD_MAP_0LEN_ARRAY;
7944 omp_add_variable (ctx, decl, flags);
7945 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
7946 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
7948 omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
7949 GOVD_LOCAL | GOVD_SEEN);
7950 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c)
7951 && walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c),
7952 find_decl_expr,
7953 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c),
7954 NULL) == NULL_TREE)
7955 omp_add_variable (ctx,
7956 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c),
7957 GOVD_LOCAL | GOVD_SEEN);
7958 gimplify_omp_ctxp = ctx;
7959 push_gimplify_context ();
7961 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = NULL;
7962 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = NULL;
7964 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c),
7965 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
7966 pop_gimplify_context
7967 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c)));
7968 push_gimplify_context ();
7969 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c),
7970 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c));
7971 pop_gimplify_context
7972 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c)));
7973 OMP_CLAUSE_REDUCTION_INIT (c) = NULL_TREE;
7974 OMP_CLAUSE_REDUCTION_MERGE (c) = NULL_TREE;
7976 gimplify_omp_ctxp = outer_ctx;
7978 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
7979 && OMP_CLAUSE_LASTPRIVATE_STMT (c))
7981 gimplify_omp_ctxp = ctx;
7982 push_gimplify_context ();
7983 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c)) != BIND_EXPR)
7985 tree bind = build3 (BIND_EXPR, void_type_node, NULL,
7986 NULL, NULL);
7987 TREE_SIDE_EFFECTS (bind) = 1;
7988 BIND_EXPR_BODY (bind) = OMP_CLAUSE_LASTPRIVATE_STMT (c);
7989 OMP_CLAUSE_LASTPRIVATE_STMT (c) = bind;
7991 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c),
7992 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
7993 pop_gimplify_context
7994 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c)));
7995 OMP_CLAUSE_LASTPRIVATE_STMT (c) = NULL_TREE;
7997 gimplify_omp_ctxp = outer_ctx;
7999 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
8000 && OMP_CLAUSE_LINEAR_STMT (c))
8002 gimplify_omp_ctxp = ctx;
8003 push_gimplify_context ();
8004 if (TREE_CODE (OMP_CLAUSE_LINEAR_STMT (c)) != BIND_EXPR)
8006 tree bind = build3 (BIND_EXPR, void_type_node, NULL,
8007 NULL, NULL);
8008 TREE_SIDE_EFFECTS (bind) = 1;
8009 BIND_EXPR_BODY (bind) = OMP_CLAUSE_LINEAR_STMT (c);
8010 OMP_CLAUSE_LINEAR_STMT (c) = bind;
8012 gimplify_and_add (OMP_CLAUSE_LINEAR_STMT (c),
8013 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c));
8014 pop_gimplify_context
8015 (gimple_seq_first_stmt (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c)));
8016 OMP_CLAUSE_LINEAR_STMT (c) = NULL_TREE;
8018 gimplify_omp_ctxp = outer_ctx;
8020 if (notice_outer)
8021 goto do_notice;
8022 break;
8024 case OMP_CLAUSE_COPYIN:
8025 case OMP_CLAUSE_COPYPRIVATE:
8026 decl = OMP_CLAUSE_DECL (c);
8027 if (error_operand_p (decl))
8029 remove = true;
8030 break;
8032 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_COPYPRIVATE
8033 && !remove
8034 && !omp_check_private (ctx, decl, true))
8036 remove = true;
8037 if (is_global_var (decl))
8039 if (DECL_THREAD_LOCAL_P (decl))
8040 remove = false;
8041 else if (DECL_HAS_VALUE_EXPR_P (decl))
8043 tree value = get_base_address (DECL_VALUE_EXPR (decl));
8045 if (value
8046 && DECL_P (value)
8047 && DECL_THREAD_LOCAL_P (value))
8048 remove = false;
8051 if (remove)
8052 error_at (OMP_CLAUSE_LOCATION (c),
8053 "copyprivate variable %qE is not threadprivate"
8054 " or private in outer context", DECL_NAME (decl));
8056 do_notice:
8057 if (outer_ctx)
8058 omp_notice_variable (outer_ctx, decl, true);
8059 if (check_non_private
8060 && region_type == ORT_WORKSHARE
8061 && (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_REDUCTION
8062 || decl == OMP_CLAUSE_DECL (c)
8063 || (TREE_CODE (OMP_CLAUSE_DECL (c)) == MEM_REF
8064 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c), 0))
8065 == ADDR_EXPR
8066 || (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c), 0))
8067 == POINTER_PLUS_EXPR
8068 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND
8069 (OMP_CLAUSE_DECL (c), 0), 0))
8070 == ADDR_EXPR)))))
8071 && omp_check_private (ctx, decl, false))
8073 error ("%s variable %qE is private in outer context",
8074 check_non_private, DECL_NAME (decl));
8075 remove = true;
8077 break;
8079 case OMP_CLAUSE_IF:
8080 if (OMP_CLAUSE_IF_MODIFIER (c) != ERROR_MARK
8081 && OMP_CLAUSE_IF_MODIFIER (c) != code)
8083 const char *p[2];
8084 for (int i = 0; i < 2; i++)
8085 switch (i ? OMP_CLAUSE_IF_MODIFIER (c) : code)
8087 case OMP_PARALLEL: p[i] = "parallel"; break;
8088 case OMP_TASK: p[i] = "task"; break;
8089 case OMP_TASKLOOP: p[i] = "taskloop"; break;
8090 case OMP_TARGET_DATA: p[i] = "target data"; break;
8091 case OMP_TARGET: p[i] = "target"; break;
8092 case OMP_TARGET_UPDATE: p[i] = "target update"; break;
8093 case OMP_TARGET_ENTER_DATA:
8094 p[i] = "target enter data"; break;
8095 case OMP_TARGET_EXIT_DATA: p[i] = "target exit data"; break;
8096 default: gcc_unreachable ();
8098 error_at (OMP_CLAUSE_LOCATION (c),
8099 "expected %qs %<if%> clause modifier rather than %qs",
8100 p[0], p[1]);
8101 remove = true;
8103 /* Fall through. */
8105 case OMP_CLAUSE_FINAL:
8106 OMP_CLAUSE_OPERAND (c, 0)
8107 = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
8108 /* Fall through. */
8110 case OMP_CLAUSE_SCHEDULE:
8111 case OMP_CLAUSE_NUM_THREADS:
8112 case OMP_CLAUSE_NUM_TEAMS:
8113 case OMP_CLAUSE_THREAD_LIMIT:
8114 case OMP_CLAUSE_DIST_SCHEDULE:
8115 case OMP_CLAUSE_DEVICE:
8116 case OMP_CLAUSE_PRIORITY:
8117 case OMP_CLAUSE_GRAINSIZE:
8118 case OMP_CLAUSE_NUM_TASKS:
8119 case OMP_CLAUSE_HINT:
8120 case OMP_CLAUSE__CILK_FOR_COUNT_:
8121 case OMP_CLAUSE_ASYNC:
8122 case OMP_CLAUSE_WAIT:
8123 case OMP_CLAUSE_NUM_GANGS:
8124 case OMP_CLAUSE_NUM_WORKERS:
8125 case OMP_CLAUSE_VECTOR_LENGTH:
8126 case OMP_CLAUSE_WORKER:
8127 case OMP_CLAUSE_VECTOR:
8128 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
8129 is_gimple_val, fb_rvalue) == GS_ERROR)
8130 remove = true;
8131 break;
8133 case OMP_CLAUSE_GANG:
8134 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
8135 is_gimple_val, fb_rvalue) == GS_ERROR)
8136 remove = true;
8137 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 1), pre_p, NULL,
8138 is_gimple_val, fb_rvalue) == GS_ERROR)
8139 remove = true;
8140 break;
8142 case OMP_CLAUSE_TILE:
8143 for (tree list = OMP_CLAUSE_TILE_LIST (c); !remove && list;
8144 list = TREE_CHAIN (list))
8146 if (gimplify_expr (&TREE_VALUE (list), pre_p, NULL,
8147 is_gimple_val, fb_rvalue) == GS_ERROR)
8148 remove = true;
8150 break;
8152 case OMP_CLAUSE_NOWAIT:
8153 case OMP_CLAUSE_ORDERED:
8154 case OMP_CLAUSE_UNTIED:
8155 case OMP_CLAUSE_COLLAPSE:
8156 case OMP_CLAUSE_AUTO:
8157 case OMP_CLAUSE_SEQ:
8158 case OMP_CLAUSE_INDEPENDENT:
8159 case OMP_CLAUSE_MERGEABLE:
8160 case OMP_CLAUSE_PROC_BIND:
8161 case OMP_CLAUSE_SAFELEN:
8162 case OMP_CLAUSE_SIMDLEN:
8163 case OMP_CLAUSE_NOGROUP:
8164 case OMP_CLAUSE_THREADS:
8165 case OMP_CLAUSE_SIMD:
8166 break;
8168 case OMP_CLAUSE_DEFAULTMAP:
8169 ctx->target_map_scalars_firstprivate = false;
8170 break;
8172 case OMP_CLAUSE_ALIGNED:
8173 decl = OMP_CLAUSE_DECL (c);
8174 if (error_operand_p (decl))
8176 remove = true;
8177 break;
8179 if (gimplify_expr (&OMP_CLAUSE_ALIGNED_ALIGNMENT (c), pre_p, NULL,
8180 is_gimple_val, fb_rvalue) == GS_ERROR)
8182 remove = true;
8183 break;
8185 if (!is_global_var (decl)
8186 && TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE)
8187 omp_add_variable (ctx, decl, GOVD_ALIGNED);
8188 break;
8190 case OMP_CLAUSE_DEFAULT:
8191 ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
8192 break;
8194 default:
8195 gcc_unreachable ();
8198 if (code == OACC_DATA
8199 && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
8200 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
8201 remove = true;
8202 if (remove)
8203 *list_p = OMP_CLAUSE_CHAIN (c);
8204 else
8205 list_p = &OMP_CLAUSE_CHAIN (c);
8208 gimplify_omp_ctxp = ctx;
8209 if (struct_map_to_clause)
8210 delete struct_map_to_clause;
8213 /* Return true if DECL is a candidate for shared to firstprivate
8214 optimization. We only consider non-addressable scalars, not
8215 too big, and not references. */
8217 static bool
8218 omp_shared_to_firstprivate_optimizable_decl_p (tree decl)
8220 if (TREE_ADDRESSABLE (decl))
8221 return false;
8222 tree type = TREE_TYPE (decl);
8223 if (!is_gimple_reg_type (type)
8224 || TREE_CODE (type) == REFERENCE_TYPE
8225 || TREE_ADDRESSABLE (type))
8226 return false;
8227 /* Don't optimize too large decls, as each thread/task will have
8228 its own. */
8229 HOST_WIDE_INT len = int_size_in_bytes (type);
8230 if (len == -1 || len > 4 * POINTER_SIZE / BITS_PER_UNIT)
8231 return false;
8232 if (lang_hooks.decls.omp_privatize_by_reference (decl))
8233 return false;
8234 return true;
8237 /* Helper function of omp_find_stores_op and gimplify_adjust_omp_clauses*.
8238 For omp_shared_to_firstprivate_optimizable_decl_p decl mark it as
8239 GOVD_WRITTEN in outer contexts. */
8241 static void
8242 omp_mark_stores (struct gimplify_omp_ctx *ctx, tree decl)
8244 for (; ctx; ctx = ctx->outer_context)
8246 splay_tree_node n = splay_tree_lookup (ctx->variables,
8247 (splay_tree_key) decl);
8248 if (n == NULL)
8249 continue;
8250 else if (n->value & GOVD_SHARED)
8252 n->value |= GOVD_WRITTEN;
8253 return;
8255 else if (n->value & GOVD_DATA_SHARE_CLASS)
8256 return;
8260 /* Helper callback for walk_gimple_seq to discover possible stores
8261 to omp_shared_to_firstprivate_optimizable_decl_p decls and set
8262 GOVD_WRITTEN if they are GOVD_SHARED in some outer context
8263 for those. */
8265 static tree
8266 omp_find_stores_op (tree *tp, int *walk_subtrees, void *data)
8268 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
8270 *walk_subtrees = 0;
8271 if (!wi->is_lhs)
8272 return NULL_TREE;
8274 tree op = *tp;
8277 if (handled_component_p (op))
8278 op = TREE_OPERAND (op, 0);
8279 else if ((TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
8280 && TREE_CODE (TREE_OPERAND (op, 0)) == ADDR_EXPR)
8281 op = TREE_OPERAND (TREE_OPERAND (op, 0), 0);
8282 else
8283 break;
8285 while (1);
8286 if (!DECL_P (op) || !omp_shared_to_firstprivate_optimizable_decl_p (op))
8287 return NULL_TREE;
8289 omp_mark_stores (gimplify_omp_ctxp, op);
8290 return NULL_TREE;
8293 /* Helper callback for walk_gimple_seq to discover possible stores
8294 to omp_shared_to_firstprivate_optimizable_decl_p decls and set
8295 GOVD_WRITTEN if they are GOVD_SHARED in some outer context
8296 for those. */
8298 static tree
8299 omp_find_stores_stmt (gimple_stmt_iterator *gsi_p,
8300 bool *handled_ops_p,
8301 struct walk_stmt_info *wi)
8303 gimple *stmt = gsi_stmt (*gsi_p);
8304 switch (gimple_code (stmt))
8306 /* Don't recurse on OpenMP constructs for which
8307 gimplify_adjust_omp_clauses already handled the bodies,
8308 except handle gimple_omp_for_pre_body. */
8309 case GIMPLE_OMP_FOR:
8310 *handled_ops_p = true;
8311 if (gimple_omp_for_pre_body (stmt))
8312 walk_gimple_seq (gimple_omp_for_pre_body (stmt),
8313 omp_find_stores_stmt, omp_find_stores_op, wi);
8314 break;
8315 case GIMPLE_OMP_PARALLEL:
8316 case GIMPLE_OMP_TASK:
8317 case GIMPLE_OMP_SECTIONS:
8318 case GIMPLE_OMP_SINGLE:
8319 case GIMPLE_OMP_TARGET:
8320 case GIMPLE_OMP_TEAMS:
8321 case GIMPLE_OMP_CRITICAL:
8322 *handled_ops_p = true;
8323 break;
8324 default:
8325 break;
8327 return NULL_TREE;
8330 struct gimplify_adjust_omp_clauses_data
8332 tree *list_p;
8333 gimple_seq *pre_p;
8336 /* For all variables that were not actually used within the context,
8337 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
8339 static int
8340 gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data)
8342 tree *list_p = ((struct gimplify_adjust_omp_clauses_data *) data)->list_p;
8343 gimple_seq *pre_p
8344 = ((struct gimplify_adjust_omp_clauses_data *) data)->pre_p;
8345 tree decl = (tree) n->key;
8346 unsigned flags = n->value;
8347 enum omp_clause_code code;
8348 tree clause;
8349 bool private_debug;
8351 if (flags & (GOVD_EXPLICIT | GOVD_LOCAL))
8352 return 0;
8353 if ((flags & GOVD_SEEN) == 0)
8354 return 0;
8355 if (flags & GOVD_DEBUG_PRIVATE)
8357 gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_PRIVATE);
8358 private_debug = true;
8360 else if (flags & GOVD_MAP)
8361 private_debug = false;
8362 else
8363 private_debug
8364 = lang_hooks.decls.omp_private_debug_clause (decl,
8365 !!(flags & GOVD_SHARED));
8366 if (private_debug)
8367 code = OMP_CLAUSE_PRIVATE;
8368 else if (flags & GOVD_MAP)
8370 code = OMP_CLAUSE_MAP;
8371 if ((gimplify_omp_ctxp->region_type & ORT_ACC) == 0
8372 && TYPE_ATOMIC (strip_array_types (TREE_TYPE (decl))))
8374 error ("%<_Atomic%> %qD in implicit %<map%> clause", decl);
8375 return 0;
8378 else if (flags & GOVD_SHARED)
8380 if (is_global_var (decl))
8382 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
8383 while (ctx != NULL)
8385 splay_tree_node on
8386 = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8387 if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
8388 | GOVD_PRIVATE | GOVD_REDUCTION
8389 | GOVD_LINEAR | GOVD_MAP)) != 0)
8390 break;
8391 ctx = ctx->outer_context;
8393 if (ctx == NULL)
8394 return 0;
8396 code = OMP_CLAUSE_SHARED;
8398 else if (flags & GOVD_PRIVATE)
8399 code = OMP_CLAUSE_PRIVATE;
8400 else if (flags & GOVD_FIRSTPRIVATE)
8402 code = OMP_CLAUSE_FIRSTPRIVATE;
8403 if ((gimplify_omp_ctxp->region_type & ORT_TARGET)
8404 && (gimplify_omp_ctxp->region_type & ORT_ACC) == 0
8405 && TYPE_ATOMIC (strip_array_types (TREE_TYPE (decl))))
8407 error ("%<_Atomic%> %qD in implicit %<firstprivate%> clause on "
8408 "%<target%> construct", decl);
8409 return 0;
8412 else if (flags & GOVD_LASTPRIVATE)
8413 code = OMP_CLAUSE_LASTPRIVATE;
8414 else if (flags & GOVD_ALIGNED)
8415 return 0;
8416 else
8417 gcc_unreachable ();
8419 if (((flags & GOVD_LASTPRIVATE)
8420 || (code == OMP_CLAUSE_SHARED && (flags & GOVD_WRITTEN)))
8421 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
8422 omp_mark_stores (gimplify_omp_ctxp->outer_context, decl);
8424 tree chain = *list_p;
8425 clause = build_omp_clause (input_location, code);
8426 OMP_CLAUSE_DECL (clause) = decl;
8427 OMP_CLAUSE_CHAIN (clause) = chain;
8428 if (private_debug)
8429 OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
8430 else if (code == OMP_CLAUSE_PRIVATE && (flags & GOVD_PRIVATE_OUTER_REF))
8431 OMP_CLAUSE_PRIVATE_OUTER_REF (clause) = 1;
8432 else if (code == OMP_CLAUSE_SHARED
8433 && (flags & GOVD_WRITTEN) == 0
8434 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
8435 OMP_CLAUSE_SHARED_READONLY (clause) = 1;
8436 else if (code == OMP_CLAUSE_FIRSTPRIVATE && (flags & GOVD_EXPLICIT) == 0)
8437 OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT (clause) = 1;
8438 else if (code == OMP_CLAUSE_MAP && (flags & GOVD_MAP_0LEN_ARRAY) != 0)
8440 tree nc = build_omp_clause (input_location, OMP_CLAUSE_MAP);
8441 OMP_CLAUSE_DECL (nc) = decl;
8442 if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE
8443 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == POINTER_TYPE)
8444 OMP_CLAUSE_DECL (clause)
8445 = build_simple_mem_ref_loc (input_location, decl);
8446 OMP_CLAUSE_DECL (clause)
8447 = build2 (MEM_REF, char_type_node, OMP_CLAUSE_DECL (clause),
8448 build_int_cst (build_pointer_type (char_type_node), 0));
8449 OMP_CLAUSE_SIZE (clause) = size_zero_node;
8450 OMP_CLAUSE_SIZE (nc) = size_zero_node;
8451 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_ALLOC);
8452 OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (clause) = 1;
8453 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_FIRSTPRIVATE_POINTER);
8454 OMP_CLAUSE_CHAIN (nc) = chain;
8455 OMP_CLAUSE_CHAIN (clause) = nc;
8456 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8457 gimplify_omp_ctxp = ctx->outer_context;
8458 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (clause), 0),
8459 pre_p, NULL, is_gimple_val, fb_rvalue);
8460 gimplify_omp_ctxp = ctx;
8462 else if (code == OMP_CLAUSE_MAP)
8464 int kind = (flags & GOVD_MAP_TO_ONLY
8465 ? GOMP_MAP_TO
8466 : GOMP_MAP_TOFROM);
8467 if (flags & GOVD_MAP_FORCE)
8468 kind |= GOMP_MAP_FLAG_FORCE;
8469 OMP_CLAUSE_SET_MAP_KIND (clause, kind);
8470 if (DECL_SIZE (decl)
8471 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
8473 tree decl2 = DECL_VALUE_EXPR (decl);
8474 gcc_assert (TREE_CODE (decl2) == INDIRECT_REF);
8475 decl2 = TREE_OPERAND (decl2, 0);
8476 gcc_assert (DECL_P (decl2));
8477 tree mem = build_simple_mem_ref (decl2);
8478 OMP_CLAUSE_DECL (clause) = mem;
8479 OMP_CLAUSE_SIZE (clause) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
8480 if (gimplify_omp_ctxp->outer_context)
8482 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
8483 omp_notice_variable (ctx, decl2, true);
8484 omp_notice_variable (ctx, OMP_CLAUSE_SIZE (clause), true);
8486 tree nc = build_omp_clause (OMP_CLAUSE_LOCATION (clause),
8487 OMP_CLAUSE_MAP);
8488 OMP_CLAUSE_DECL (nc) = decl;
8489 OMP_CLAUSE_SIZE (nc) = size_zero_node;
8490 if (gimplify_omp_ctxp->target_firstprivatize_array_bases)
8491 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_FIRSTPRIVATE_POINTER);
8492 else
8493 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_POINTER);
8494 OMP_CLAUSE_CHAIN (nc) = OMP_CLAUSE_CHAIN (clause);
8495 OMP_CLAUSE_CHAIN (clause) = nc;
8497 else if (gimplify_omp_ctxp->target_firstprivatize_array_bases
8498 && lang_hooks.decls.omp_privatize_by_reference (decl))
8500 OMP_CLAUSE_DECL (clause) = build_simple_mem_ref (decl);
8501 OMP_CLAUSE_SIZE (clause)
8502 = unshare_expr (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl))));
8503 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8504 gimplify_omp_ctxp = ctx->outer_context;
8505 gimplify_expr (&OMP_CLAUSE_SIZE (clause),
8506 pre_p, NULL, is_gimple_val, fb_rvalue);
8507 gimplify_omp_ctxp = ctx;
8508 tree nc = build_omp_clause (OMP_CLAUSE_LOCATION (clause),
8509 OMP_CLAUSE_MAP);
8510 OMP_CLAUSE_DECL (nc) = decl;
8511 OMP_CLAUSE_SIZE (nc) = size_zero_node;
8512 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_FIRSTPRIVATE_REFERENCE);
8513 OMP_CLAUSE_CHAIN (nc) = OMP_CLAUSE_CHAIN (clause);
8514 OMP_CLAUSE_CHAIN (clause) = nc;
8516 else
8517 OMP_CLAUSE_SIZE (clause) = DECL_SIZE_UNIT (decl);
8519 if (code == OMP_CLAUSE_FIRSTPRIVATE && (flags & GOVD_LASTPRIVATE) != 0)
8521 tree nc = build_omp_clause (input_location, OMP_CLAUSE_LASTPRIVATE);
8522 OMP_CLAUSE_DECL (nc) = decl;
8523 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (nc) = 1;
8524 OMP_CLAUSE_CHAIN (nc) = chain;
8525 OMP_CLAUSE_CHAIN (clause) = nc;
8526 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8527 gimplify_omp_ctxp = ctx->outer_context;
8528 lang_hooks.decls.omp_finish_clause (nc, pre_p);
8529 gimplify_omp_ctxp = ctx;
8531 *list_p = clause;
8532 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8533 gimplify_omp_ctxp = ctx->outer_context;
8534 lang_hooks.decls.omp_finish_clause (clause, pre_p);
8535 if (gimplify_omp_ctxp)
8536 for (; clause != chain; clause = OMP_CLAUSE_CHAIN (clause))
8537 if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_MAP
8538 && DECL_P (OMP_CLAUSE_SIZE (clause)))
8539 omp_notice_variable (gimplify_omp_ctxp, OMP_CLAUSE_SIZE (clause),
8540 true);
8541 gimplify_omp_ctxp = ctx;
8542 return 0;
8545 static void
8546 gimplify_adjust_omp_clauses (gimple_seq *pre_p, gimple_seq body, tree *list_p,
8547 enum tree_code code)
8549 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8550 tree c, decl;
8552 if (body)
8554 struct gimplify_omp_ctx *octx;
8555 for (octx = ctx; octx; octx = octx->outer_context)
8556 if ((octx->region_type & (ORT_PARALLEL | ORT_TASK | ORT_TEAMS)) != 0)
8557 break;
8558 if (octx)
8560 struct walk_stmt_info wi;
8561 memset (&wi, 0, sizeof (wi));
8562 walk_gimple_seq (body, omp_find_stores_stmt,
8563 omp_find_stores_op, &wi);
8566 while ((c = *list_p) != NULL)
8568 splay_tree_node n;
8569 bool remove = false;
8571 switch (OMP_CLAUSE_CODE (c))
8573 case OMP_CLAUSE_FIRSTPRIVATE:
8574 if ((ctx->region_type & ORT_TARGET)
8575 && (ctx->region_type & ORT_ACC) == 0
8576 && TYPE_ATOMIC (strip_array_types
8577 (TREE_TYPE (OMP_CLAUSE_DECL (c)))))
8579 error_at (OMP_CLAUSE_LOCATION (c),
8580 "%<_Atomic%> %qD in %<firstprivate%> clause on "
8581 "%<target%> construct", OMP_CLAUSE_DECL (c));
8582 remove = true;
8583 break;
8585 /* FALLTHRU */
8586 case OMP_CLAUSE_PRIVATE:
8587 case OMP_CLAUSE_SHARED:
8588 case OMP_CLAUSE_LINEAR:
8589 decl = OMP_CLAUSE_DECL (c);
8590 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8591 remove = !(n->value & GOVD_SEEN);
8592 if (! remove)
8594 bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
8595 if ((n->value & GOVD_DEBUG_PRIVATE)
8596 || lang_hooks.decls.omp_private_debug_clause (decl, shared))
8598 gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
8599 || ((n->value & GOVD_DATA_SHARE_CLASS)
8600 == GOVD_PRIVATE));
8601 OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
8602 OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
8604 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED
8605 && (n->value & GOVD_WRITTEN) == 0
8606 && DECL_P (decl)
8607 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
8608 OMP_CLAUSE_SHARED_READONLY (c) = 1;
8609 else if (DECL_P (decl)
8610 && ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED
8611 && (n->value & GOVD_WRITTEN) != 1)
8612 || (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
8613 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c)))
8614 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
8615 omp_mark_stores (gimplify_omp_ctxp->outer_context, decl);
8617 break;
8619 case OMP_CLAUSE_LASTPRIVATE:
8620 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
8621 accurately reflect the presence of a FIRSTPRIVATE clause. */
8622 decl = OMP_CLAUSE_DECL (c);
8623 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8624 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
8625 = (n->value & GOVD_FIRSTPRIVATE) != 0;
8626 if (omp_no_lastprivate (ctx))
8628 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c))
8629 remove = true;
8630 else
8631 OMP_CLAUSE_CODE (c) = OMP_CLAUSE_PRIVATE;
8633 else if (code == OMP_DISTRIBUTE
8634 && OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c))
8636 remove = true;
8637 error_at (OMP_CLAUSE_LOCATION (c),
8638 "same variable used in %<firstprivate%> and "
8639 "%<lastprivate%> clauses on %<distribute%> "
8640 "construct");
8642 if (!remove
8643 && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
8644 && DECL_P (decl)
8645 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
8646 omp_mark_stores (gimplify_omp_ctxp->outer_context, decl);
8647 break;
8649 case OMP_CLAUSE_ALIGNED:
8650 decl = OMP_CLAUSE_DECL (c);
8651 if (!is_global_var (decl))
8653 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8654 remove = n == NULL || !(n->value & GOVD_SEEN);
8655 if (!remove && TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE)
8657 struct gimplify_omp_ctx *octx;
8658 if (n != NULL
8659 && (n->value & (GOVD_DATA_SHARE_CLASS
8660 & ~GOVD_FIRSTPRIVATE)))
8661 remove = true;
8662 else
8663 for (octx = ctx->outer_context; octx;
8664 octx = octx->outer_context)
8666 n = splay_tree_lookup (octx->variables,
8667 (splay_tree_key) decl);
8668 if (n == NULL)
8669 continue;
8670 if (n->value & GOVD_LOCAL)
8671 break;
8672 /* We have to avoid assigning a shared variable
8673 to itself when trying to add
8674 __builtin_assume_aligned. */
8675 if (n->value & GOVD_SHARED)
8677 remove = true;
8678 break;
8683 else if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
8685 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8686 if (n != NULL && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
8687 remove = true;
8689 break;
8691 case OMP_CLAUSE_MAP:
8692 if (code == OMP_TARGET_EXIT_DATA
8693 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_POINTER)
8695 remove = true;
8696 break;
8698 decl = OMP_CLAUSE_DECL (c);
8699 /* Data clauses associated with acc parallel reductions must be
8700 compatible with present_or_copy. Warn and adjust the clause
8701 if that is not the case. */
8702 if (ctx->region_type == ORT_ACC_PARALLEL)
8704 tree t = DECL_P (decl) ? decl : TREE_OPERAND (decl, 0);
8705 n = NULL;
8707 if (DECL_P (t))
8708 n = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
8710 if (n && (n->value & GOVD_REDUCTION))
8712 enum gomp_map_kind kind = OMP_CLAUSE_MAP_KIND (c);
8714 OMP_CLAUSE_MAP_IN_REDUCTION (c) = 1;
8715 if ((kind & GOMP_MAP_TOFROM) != GOMP_MAP_TOFROM
8716 && kind != GOMP_MAP_FORCE_PRESENT
8717 && kind != GOMP_MAP_POINTER)
8719 warning_at (OMP_CLAUSE_LOCATION (c), 0,
8720 "incompatible data clause with reduction "
8721 "on %qE; promoting to present_or_copy",
8722 DECL_NAME (t));
8723 OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_TOFROM);
8727 if (!DECL_P (decl))
8729 if ((ctx->region_type & ORT_TARGET) != 0
8730 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
8732 if (TREE_CODE (decl) == INDIRECT_REF
8733 && TREE_CODE (TREE_OPERAND (decl, 0)) == COMPONENT_REF
8734 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl, 0)))
8735 == REFERENCE_TYPE))
8736 decl = TREE_OPERAND (decl, 0);
8737 if (TREE_CODE (decl) == COMPONENT_REF)
8739 while (TREE_CODE (decl) == COMPONENT_REF)
8740 decl = TREE_OPERAND (decl, 0);
8741 if (DECL_P (decl))
8743 n = splay_tree_lookup (ctx->variables,
8744 (splay_tree_key) decl);
8745 if (!(n->value & GOVD_SEEN))
8746 remove = true;
8750 break;
8752 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8753 if ((ctx->region_type & ORT_TARGET) != 0
8754 && !(n->value & GOVD_SEEN)
8755 && GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c)) == 0
8756 && !lookup_attribute ("omp declare target link",
8757 DECL_ATTRIBUTES (decl)))
8759 remove = true;
8760 /* For struct element mapping, if struct is never referenced
8761 in target block and none of the mapping has always modifier,
8762 remove all the struct element mappings, which immediately
8763 follow the GOMP_MAP_STRUCT map clause. */
8764 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_STRUCT)
8766 HOST_WIDE_INT cnt = tree_to_shwi (OMP_CLAUSE_SIZE (c));
8767 while (cnt--)
8768 OMP_CLAUSE_CHAIN (c)
8769 = OMP_CLAUSE_CHAIN (OMP_CLAUSE_CHAIN (c));
8772 else if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_STRUCT
8773 && code == OMP_TARGET_EXIT_DATA)
8774 remove = true;
8775 else if (DECL_SIZE (decl)
8776 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST
8777 && OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_POINTER
8778 && OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_FIRSTPRIVATE_POINTER
8779 && (OMP_CLAUSE_MAP_KIND (c)
8780 != GOMP_MAP_FIRSTPRIVATE_REFERENCE))
8782 /* For GOMP_MAP_FORCE_DEVICEPTR, we'll never enter here, because
8783 for these, TREE_CODE (DECL_SIZE (decl)) will always be
8784 INTEGER_CST. */
8785 gcc_assert (OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_FORCE_DEVICEPTR);
8787 tree decl2 = DECL_VALUE_EXPR (decl);
8788 gcc_assert (TREE_CODE (decl2) == INDIRECT_REF);
8789 decl2 = TREE_OPERAND (decl2, 0);
8790 gcc_assert (DECL_P (decl2));
8791 tree mem = build_simple_mem_ref (decl2);
8792 OMP_CLAUSE_DECL (c) = mem;
8793 OMP_CLAUSE_SIZE (c) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
8794 if (ctx->outer_context)
8796 omp_notice_variable (ctx->outer_context, decl2, true);
8797 omp_notice_variable (ctx->outer_context,
8798 OMP_CLAUSE_SIZE (c), true);
8800 if (((ctx->region_type & ORT_TARGET) != 0
8801 || !ctx->target_firstprivatize_array_bases)
8802 && ((n->value & GOVD_SEEN) == 0
8803 || (n->value & (GOVD_PRIVATE | GOVD_FIRSTPRIVATE)) == 0))
8805 tree nc = build_omp_clause (OMP_CLAUSE_LOCATION (c),
8806 OMP_CLAUSE_MAP);
8807 OMP_CLAUSE_DECL (nc) = decl;
8808 OMP_CLAUSE_SIZE (nc) = size_zero_node;
8809 if (ctx->target_firstprivatize_array_bases)
8810 OMP_CLAUSE_SET_MAP_KIND (nc,
8811 GOMP_MAP_FIRSTPRIVATE_POINTER);
8812 else
8813 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_POINTER);
8814 OMP_CLAUSE_CHAIN (nc) = OMP_CLAUSE_CHAIN (c);
8815 OMP_CLAUSE_CHAIN (c) = nc;
8816 c = nc;
8819 else
8821 if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
8822 OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (decl);
8823 gcc_assert ((n->value & GOVD_SEEN) == 0
8824 || ((n->value & (GOVD_PRIVATE | GOVD_FIRSTPRIVATE))
8825 == 0));
8827 break;
8829 case OMP_CLAUSE_TO:
8830 case OMP_CLAUSE_FROM:
8831 case OMP_CLAUSE__CACHE_:
8832 decl = OMP_CLAUSE_DECL (c);
8833 if (!DECL_P (decl))
8834 break;
8835 if (DECL_SIZE (decl)
8836 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
8838 tree decl2 = DECL_VALUE_EXPR (decl);
8839 gcc_assert (TREE_CODE (decl2) == INDIRECT_REF);
8840 decl2 = TREE_OPERAND (decl2, 0);
8841 gcc_assert (DECL_P (decl2));
8842 tree mem = build_simple_mem_ref (decl2);
8843 OMP_CLAUSE_DECL (c) = mem;
8844 OMP_CLAUSE_SIZE (c) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
8845 if (ctx->outer_context)
8847 omp_notice_variable (ctx->outer_context, decl2, true);
8848 omp_notice_variable (ctx->outer_context,
8849 OMP_CLAUSE_SIZE (c), true);
8852 else if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
8853 OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (decl);
8854 break;
8856 case OMP_CLAUSE_REDUCTION:
8857 decl = OMP_CLAUSE_DECL (c);
8858 /* OpenACC reductions need a present_or_copy data clause.
8859 Add one if necessary. Error is the reduction is private. */
8860 if (ctx->region_type == ORT_ACC_PARALLEL)
8862 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8863 if (n->value & (GOVD_PRIVATE | GOVD_FIRSTPRIVATE))
8864 error_at (OMP_CLAUSE_LOCATION (c), "invalid private "
8865 "reduction on %qE", DECL_NAME (decl));
8866 else if ((n->value & GOVD_MAP) == 0)
8868 tree next = OMP_CLAUSE_CHAIN (c);
8869 tree nc = build_omp_clause (UNKNOWN_LOCATION, OMP_CLAUSE_MAP);
8870 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_TOFROM);
8871 OMP_CLAUSE_DECL (nc) = decl;
8872 OMP_CLAUSE_CHAIN (c) = nc;
8873 lang_hooks.decls.omp_finish_clause (nc, pre_p);
8874 while (1)
8876 OMP_CLAUSE_MAP_IN_REDUCTION (nc) = 1;
8877 if (OMP_CLAUSE_CHAIN (nc) == NULL)
8878 break;
8879 nc = OMP_CLAUSE_CHAIN (nc);
8881 OMP_CLAUSE_CHAIN (nc) = next;
8882 n->value |= GOVD_MAP;
8885 if (DECL_P (decl)
8886 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
8887 omp_mark_stores (gimplify_omp_ctxp->outer_context, decl);
8888 break;
8889 case OMP_CLAUSE_COPYIN:
8890 case OMP_CLAUSE_COPYPRIVATE:
8891 case OMP_CLAUSE_IF:
8892 case OMP_CLAUSE_NUM_THREADS:
8893 case OMP_CLAUSE_NUM_TEAMS:
8894 case OMP_CLAUSE_THREAD_LIMIT:
8895 case OMP_CLAUSE_DIST_SCHEDULE:
8896 case OMP_CLAUSE_DEVICE:
8897 case OMP_CLAUSE_SCHEDULE:
8898 case OMP_CLAUSE_NOWAIT:
8899 case OMP_CLAUSE_ORDERED:
8900 case OMP_CLAUSE_DEFAULT:
8901 case OMP_CLAUSE_UNTIED:
8902 case OMP_CLAUSE_COLLAPSE:
8903 case OMP_CLAUSE_FINAL:
8904 case OMP_CLAUSE_MERGEABLE:
8905 case OMP_CLAUSE_PROC_BIND:
8906 case OMP_CLAUSE_SAFELEN:
8907 case OMP_CLAUSE_SIMDLEN:
8908 case OMP_CLAUSE_DEPEND:
8909 case OMP_CLAUSE_PRIORITY:
8910 case OMP_CLAUSE_GRAINSIZE:
8911 case OMP_CLAUSE_NUM_TASKS:
8912 case OMP_CLAUSE_NOGROUP:
8913 case OMP_CLAUSE_THREADS:
8914 case OMP_CLAUSE_SIMD:
8915 case OMP_CLAUSE_HINT:
8916 case OMP_CLAUSE_DEFAULTMAP:
8917 case OMP_CLAUSE_USE_DEVICE_PTR:
8918 case OMP_CLAUSE_IS_DEVICE_PTR:
8919 case OMP_CLAUSE__CILK_FOR_COUNT_:
8920 case OMP_CLAUSE_ASYNC:
8921 case OMP_CLAUSE_WAIT:
8922 case OMP_CLAUSE_INDEPENDENT:
8923 case OMP_CLAUSE_NUM_GANGS:
8924 case OMP_CLAUSE_NUM_WORKERS:
8925 case OMP_CLAUSE_VECTOR_LENGTH:
8926 case OMP_CLAUSE_GANG:
8927 case OMP_CLAUSE_WORKER:
8928 case OMP_CLAUSE_VECTOR:
8929 case OMP_CLAUSE_AUTO:
8930 case OMP_CLAUSE_SEQ:
8931 break;
8933 case OMP_CLAUSE_TILE:
8934 /* We're not yet making use of the information provided by OpenACC
8935 tile clauses. Discard these here, to simplify later middle end
8936 processing. */
8937 remove = true;
8938 break;
8940 default:
8941 gcc_unreachable ();
8944 if (remove)
8945 *list_p = OMP_CLAUSE_CHAIN (c);
8946 else
8947 list_p = &OMP_CLAUSE_CHAIN (c);
8950 /* Add in any implicit data sharing. */
8951 struct gimplify_adjust_omp_clauses_data data;
8952 data.list_p = list_p;
8953 data.pre_p = pre_p;
8954 splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, &data);
8956 gimplify_omp_ctxp = ctx->outer_context;
8957 delete_omp_context (ctx);
8960 /* Gimplify OACC_CACHE. */
8962 static void
8963 gimplify_oacc_cache (tree *expr_p, gimple_seq *pre_p)
8965 tree expr = *expr_p;
8967 gimplify_scan_omp_clauses (&OACC_CACHE_CLAUSES (expr), pre_p, ORT_ACC,
8968 OACC_CACHE);
8969 gimplify_adjust_omp_clauses (pre_p, NULL, &OACC_CACHE_CLAUSES (expr),
8970 OACC_CACHE);
8972 /* TODO: Do something sensible with this information. */
8974 *expr_p = NULL_TREE;
8977 /* Helper function of gimplify_oacc_declare. The helper's purpose is to,
8978 if required, translate 'kind' in CLAUSE into an 'entry' kind and 'exit'
8979 kind. The entry kind will replace the one in CLAUSE, while the exit
8980 kind will be used in a new omp_clause and returned to the caller. */
8982 static tree
8983 gimplify_oacc_declare_1 (tree clause)
8985 HOST_WIDE_INT kind, new_op;
8986 bool ret = false;
8987 tree c = NULL;
8989 kind = OMP_CLAUSE_MAP_KIND (clause);
8991 switch (kind)
8993 case GOMP_MAP_ALLOC:
8994 case GOMP_MAP_FORCE_ALLOC:
8995 case GOMP_MAP_FORCE_TO:
8996 new_op = GOMP_MAP_DELETE;
8997 ret = true;
8998 break;
9000 case GOMP_MAP_FORCE_FROM:
9001 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_FORCE_ALLOC);
9002 new_op = GOMP_MAP_FORCE_FROM;
9003 ret = true;
9004 break;
9006 case GOMP_MAP_FORCE_TOFROM:
9007 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_FORCE_TO);
9008 new_op = GOMP_MAP_FORCE_FROM;
9009 ret = true;
9010 break;
9012 case GOMP_MAP_FROM:
9013 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_FORCE_ALLOC);
9014 new_op = GOMP_MAP_FROM;
9015 ret = true;
9016 break;
9018 case GOMP_MAP_TOFROM:
9019 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_TO);
9020 new_op = GOMP_MAP_FROM;
9021 ret = true;
9022 break;
9024 case GOMP_MAP_DEVICE_RESIDENT:
9025 case GOMP_MAP_FORCE_DEVICEPTR:
9026 case GOMP_MAP_FORCE_PRESENT:
9027 case GOMP_MAP_LINK:
9028 case GOMP_MAP_POINTER:
9029 case GOMP_MAP_TO:
9030 break;
9032 default:
9033 gcc_unreachable ();
9034 break;
9037 if (ret)
9039 c = build_omp_clause (OMP_CLAUSE_LOCATION (clause), OMP_CLAUSE_MAP);
9040 OMP_CLAUSE_SET_MAP_KIND (c, new_op);
9041 OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clause);
9044 return c;
9047 /* Gimplify OACC_DECLARE. */
9049 static void
9050 gimplify_oacc_declare (tree *expr_p, gimple_seq *pre_p)
9052 tree expr = *expr_p;
9053 gomp_target *stmt;
9054 tree clauses, t;
9056 clauses = OACC_DECLARE_CLAUSES (expr);
9058 gimplify_scan_omp_clauses (&clauses, pre_p, ORT_TARGET_DATA, OACC_DECLARE);
9060 for (t = clauses; t; t = OMP_CLAUSE_CHAIN (t))
9062 tree decl = OMP_CLAUSE_DECL (t);
9064 if (TREE_CODE (decl) == MEM_REF)
9065 continue;
9067 if (VAR_P (decl)
9068 && !is_global_var (decl)
9069 && DECL_CONTEXT (decl) == current_function_decl)
9071 tree c = gimplify_oacc_declare_1 (t);
9072 if (c)
9074 if (oacc_declare_returns == NULL)
9075 oacc_declare_returns = new hash_map<tree, tree>;
9077 oacc_declare_returns->put (decl, c);
9081 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_SEEN);
9084 stmt = gimple_build_omp_target (NULL, GF_OMP_TARGET_KIND_OACC_DECLARE,
9085 clauses);
9087 gimplify_seq_add_stmt (pre_p, stmt);
9089 *expr_p = NULL_TREE;
9092 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
9093 gimplification of the body, as well as scanning the body for used
9094 variables. We need to do this scan now, because variable-sized
9095 decls will be decomposed during gimplification. */
9097 static void
9098 gimplify_omp_parallel (tree *expr_p, gimple_seq *pre_p)
9100 tree expr = *expr_p;
9101 gimple *g;
9102 gimple_seq body = NULL;
9104 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p,
9105 OMP_PARALLEL_COMBINED (expr)
9106 ? ORT_COMBINED_PARALLEL
9107 : ORT_PARALLEL, OMP_PARALLEL);
9109 push_gimplify_context ();
9111 g = gimplify_and_return_first (OMP_PARALLEL_BODY (expr), &body);
9112 if (gimple_code (g) == GIMPLE_BIND)
9113 pop_gimplify_context (g);
9114 else
9115 pop_gimplify_context (NULL);
9117 gimplify_adjust_omp_clauses (pre_p, body, &OMP_PARALLEL_CLAUSES (expr),
9118 OMP_PARALLEL);
9120 g = gimple_build_omp_parallel (body,
9121 OMP_PARALLEL_CLAUSES (expr),
9122 NULL_TREE, NULL_TREE);
9123 if (OMP_PARALLEL_COMBINED (expr))
9124 gimple_omp_set_subcode (g, GF_OMP_PARALLEL_COMBINED);
9125 gimplify_seq_add_stmt (pre_p, g);
9126 *expr_p = NULL_TREE;
9129 /* Gimplify the contents of an OMP_TASK statement. This involves
9130 gimplification of the body, as well as scanning the body for used
9131 variables. We need to do this scan now, because variable-sized
9132 decls will be decomposed during gimplification. */
9134 static void
9135 gimplify_omp_task (tree *expr_p, gimple_seq *pre_p)
9137 tree expr = *expr_p;
9138 gimple *g;
9139 gimple_seq body = NULL;
9141 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr), pre_p,
9142 find_omp_clause (OMP_TASK_CLAUSES (expr),
9143 OMP_CLAUSE_UNTIED)
9144 ? ORT_UNTIED_TASK : ORT_TASK, OMP_TASK);
9146 push_gimplify_context ();
9148 g = gimplify_and_return_first (OMP_TASK_BODY (expr), &body);
9149 if (gimple_code (g) == GIMPLE_BIND)
9150 pop_gimplify_context (g);
9151 else
9152 pop_gimplify_context (NULL);
9154 gimplify_adjust_omp_clauses (pre_p, body, &OMP_TASK_CLAUSES (expr),
9155 OMP_TASK);
9157 g = gimple_build_omp_task (body,
9158 OMP_TASK_CLAUSES (expr),
9159 NULL_TREE, NULL_TREE,
9160 NULL_TREE, NULL_TREE, NULL_TREE);
9161 gimplify_seq_add_stmt (pre_p, g);
9162 *expr_p = NULL_TREE;
9165 /* Helper function of gimplify_omp_for, find OMP_FOR resp. OMP_SIMD
9166 with non-NULL OMP_FOR_INIT. */
9168 static tree
9169 find_combined_omp_for (tree *tp, int *walk_subtrees, void *)
9171 *walk_subtrees = 0;
9172 switch (TREE_CODE (*tp))
9174 case OMP_FOR:
9175 *walk_subtrees = 1;
9176 /* FALLTHRU */
9177 case OMP_SIMD:
9178 if (OMP_FOR_INIT (*tp) != NULL_TREE)
9179 return *tp;
9180 break;
9181 case BIND_EXPR:
9182 case STATEMENT_LIST:
9183 case OMP_PARALLEL:
9184 *walk_subtrees = 1;
9185 break;
9186 default:
9187 break;
9189 return NULL_TREE;
9192 /* Gimplify the gross structure of an OMP_FOR statement. */
9194 static enum gimplify_status
9195 gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
9197 tree for_stmt, orig_for_stmt, inner_for_stmt = NULL_TREE, decl, var, t;
9198 enum gimplify_status ret = GS_ALL_DONE;
9199 enum gimplify_status tret;
9200 gomp_for *gfor;
9201 gimple_seq for_body, for_pre_body;
9202 int i;
9203 bitmap has_decl_expr = NULL;
9204 enum omp_region_type ort = ORT_WORKSHARE;
9206 orig_for_stmt = for_stmt = *expr_p;
9208 switch (TREE_CODE (for_stmt))
9210 case OMP_FOR:
9211 case CILK_FOR:
9212 case OMP_DISTRIBUTE:
9213 break;
9214 case OACC_LOOP:
9215 ort = ORT_ACC;
9216 break;
9217 case OMP_TASKLOOP:
9218 if (find_omp_clause (OMP_FOR_CLAUSES (for_stmt), OMP_CLAUSE_UNTIED))
9219 ort = ORT_UNTIED_TASK;
9220 else
9221 ort = ORT_TASK;
9222 break;
9223 case OMP_SIMD:
9224 case CILK_SIMD:
9225 ort = ORT_SIMD;
9226 break;
9227 default:
9228 gcc_unreachable ();
9231 /* Set OMP_CLAUSE_LINEAR_NO_COPYIN flag on explicit linear
9232 clause for the IV. */
9233 if (ort == ORT_SIMD && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) == 1)
9235 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), 0);
9236 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
9237 decl = TREE_OPERAND (t, 0);
9238 for (tree c = OMP_FOR_CLAUSES (for_stmt); c; c = OMP_CLAUSE_CHAIN (c))
9239 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
9240 && OMP_CLAUSE_DECL (c) == decl)
9242 OMP_CLAUSE_LINEAR_NO_COPYIN (c) = 1;
9243 break;
9247 if (OMP_FOR_INIT (for_stmt) == NULL_TREE)
9249 gcc_assert (TREE_CODE (for_stmt) != OACC_LOOP);
9250 inner_for_stmt = walk_tree (&OMP_FOR_BODY (for_stmt),
9251 find_combined_omp_for, NULL, NULL);
9252 if (inner_for_stmt == NULL_TREE)
9254 gcc_assert (seen_error ());
9255 *expr_p = NULL_TREE;
9256 return GS_ERROR;
9260 if (TREE_CODE (for_stmt) != OMP_TASKLOOP)
9261 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p, ort,
9262 TREE_CODE (for_stmt));
9264 if (TREE_CODE (for_stmt) == OMP_DISTRIBUTE)
9265 gimplify_omp_ctxp->distribute = true;
9267 /* Handle OMP_FOR_INIT. */
9268 for_pre_body = NULL;
9269 if (ort == ORT_SIMD && OMP_FOR_PRE_BODY (for_stmt))
9271 has_decl_expr = BITMAP_ALLOC (NULL);
9272 if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt)) == DECL_EXPR
9273 && TREE_CODE (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt)))
9274 == VAR_DECL)
9276 t = OMP_FOR_PRE_BODY (for_stmt);
9277 bitmap_set_bit (has_decl_expr, DECL_UID (DECL_EXPR_DECL (t)));
9279 else if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt)) == STATEMENT_LIST)
9281 tree_stmt_iterator si;
9282 for (si = tsi_start (OMP_FOR_PRE_BODY (for_stmt)); !tsi_end_p (si);
9283 tsi_next (&si))
9285 t = tsi_stmt (si);
9286 if (TREE_CODE (t) == DECL_EXPR
9287 && TREE_CODE (DECL_EXPR_DECL (t)) == VAR_DECL)
9288 bitmap_set_bit (has_decl_expr, DECL_UID (DECL_EXPR_DECL (t)));
9292 if (OMP_FOR_PRE_BODY (for_stmt))
9294 if (TREE_CODE (for_stmt) != OMP_TASKLOOP || gimplify_omp_ctxp)
9295 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt), &for_pre_body);
9296 else
9298 struct gimplify_omp_ctx ctx;
9299 memset (&ctx, 0, sizeof (ctx));
9300 ctx.region_type = ORT_NONE;
9301 gimplify_omp_ctxp = &ctx;
9302 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt), &for_pre_body);
9303 gimplify_omp_ctxp = NULL;
9306 OMP_FOR_PRE_BODY (for_stmt) = NULL_TREE;
9308 if (OMP_FOR_INIT (for_stmt) == NULL_TREE)
9309 for_stmt = inner_for_stmt;
9311 /* For taskloop, need to gimplify the start, end and step before the
9312 taskloop, outside of the taskloop omp context. */
9313 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
9315 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
9317 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
9318 if (!is_gimple_constant (TREE_OPERAND (t, 1)))
9320 TREE_OPERAND (t, 1)
9321 = get_initialized_tmp_var (TREE_OPERAND (t, 1),
9322 pre_p, NULL, false);
9323 tree c = build_omp_clause (input_location,
9324 OMP_CLAUSE_FIRSTPRIVATE);
9325 OMP_CLAUSE_DECL (c) = TREE_OPERAND (t, 1);
9326 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (orig_for_stmt);
9327 OMP_FOR_CLAUSES (orig_for_stmt) = c;
9330 /* Handle OMP_FOR_COND. */
9331 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
9332 if (!is_gimple_constant (TREE_OPERAND (t, 1)))
9334 TREE_OPERAND (t, 1)
9335 = get_initialized_tmp_var (TREE_OPERAND (t, 1),
9336 gimple_seq_empty_p (for_pre_body)
9337 ? pre_p : &for_pre_body, NULL,
9338 false);
9339 tree c = build_omp_clause (input_location,
9340 OMP_CLAUSE_FIRSTPRIVATE);
9341 OMP_CLAUSE_DECL (c) = TREE_OPERAND (t, 1);
9342 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (orig_for_stmt);
9343 OMP_FOR_CLAUSES (orig_for_stmt) = c;
9346 /* Handle OMP_FOR_INCR. */
9347 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
9348 if (TREE_CODE (t) == MODIFY_EXPR)
9350 decl = TREE_OPERAND (t, 0);
9351 t = TREE_OPERAND (t, 1);
9352 tree *tp = &TREE_OPERAND (t, 1);
9353 if (TREE_CODE (t) == PLUS_EXPR && *tp == decl)
9354 tp = &TREE_OPERAND (t, 0);
9356 if (!is_gimple_constant (*tp))
9358 gimple_seq *seq = gimple_seq_empty_p (for_pre_body)
9359 ? pre_p : &for_pre_body;
9360 *tp = get_initialized_tmp_var (*tp, seq, NULL, false);
9361 tree c = build_omp_clause (input_location,
9362 OMP_CLAUSE_FIRSTPRIVATE);
9363 OMP_CLAUSE_DECL (c) = *tp;
9364 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (orig_for_stmt);
9365 OMP_FOR_CLAUSES (orig_for_stmt) = c;
9370 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (orig_for_stmt), pre_p, ort,
9371 OMP_TASKLOOP);
9374 if (orig_for_stmt != for_stmt)
9375 gimplify_omp_ctxp->combined_loop = true;
9377 for_body = NULL;
9378 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
9379 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt)));
9380 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
9381 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt)));
9383 tree c = find_omp_clause (OMP_FOR_CLAUSES (for_stmt), OMP_CLAUSE_ORDERED);
9384 bool is_doacross = false;
9385 if (c && OMP_CLAUSE_ORDERED_EXPR (c))
9387 is_doacross = true;
9388 gimplify_omp_ctxp->loop_iter_var.create (TREE_VEC_LENGTH
9389 (OMP_FOR_INIT (for_stmt))
9390 * 2);
9392 int collapse = 1;
9393 c = find_omp_clause (OMP_FOR_CLAUSES (for_stmt), OMP_CLAUSE_COLLAPSE);
9394 if (c)
9395 collapse = tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (c));
9396 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
9398 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
9399 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
9400 decl = TREE_OPERAND (t, 0);
9401 gcc_assert (DECL_P (decl));
9402 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl))
9403 || POINTER_TYPE_P (TREE_TYPE (decl)));
9404 if (is_doacross)
9406 if (TREE_CODE (for_stmt) == OMP_FOR && OMP_FOR_ORIG_DECLS (for_stmt))
9407 gimplify_omp_ctxp->loop_iter_var.quick_push
9408 (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt), i));
9409 else
9410 gimplify_omp_ctxp->loop_iter_var.quick_push (decl);
9411 gimplify_omp_ctxp->loop_iter_var.quick_push (decl);
9414 /* Make sure the iteration variable is private. */
9415 tree c = NULL_TREE;
9416 tree c2 = NULL_TREE;
9417 if (orig_for_stmt != for_stmt)
9418 /* Do this only on innermost construct for combined ones. */;
9419 else if (ort == ORT_SIMD)
9421 splay_tree_node n = splay_tree_lookup (gimplify_omp_ctxp->variables,
9422 (splay_tree_key) decl);
9423 omp_is_private (gimplify_omp_ctxp, decl,
9424 1 + (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
9425 != 1));
9426 if (n != NULL && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
9427 omp_notice_variable (gimplify_omp_ctxp, decl, true);
9428 else if (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) == 1)
9430 c = build_omp_clause (input_location, OMP_CLAUSE_LINEAR);
9431 OMP_CLAUSE_LINEAR_NO_COPYIN (c) = 1;
9432 unsigned int flags = GOVD_LINEAR | GOVD_EXPLICIT | GOVD_SEEN;
9433 if ((has_decl_expr
9434 && bitmap_bit_p (has_decl_expr, DECL_UID (decl)))
9435 || omp_no_lastprivate (gimplify_omp_ctxp))
9437 OMP_CLAUSE_LINEAR_NO_COPYOUT (c) = 1;
9438 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
9440 struct gimplify_omp_ctx *outer
9441 = gimplify_omp_ctxp->outer_context;
9442 if (outer && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
9444 if (outer->region_type == ORT_WORKSHARE
9445 && outer->combined_loop)
9447 n = splay_tree_lookup (outer->variables,
9448 (splay_tree_key)decl);
9449 if (n != NULL && (n->value & GOVD_LOCAL) != 0)
9451 OMP_CLAUSE_LINEAR_NO_COPYOUT (c) = 1;
9452 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
9454 else
9456 struct gimplify_omp_ctx *octx = outer->outer_context;
9457 if (octx
9458 && octx->region_type == ORT_COMBINED_PARALLEL
9459 && octx->outer_context
9460 && (octx->outer_context->region_type
9461 == ORT_WORKSHARE)
9462 && octx->outer_context->combined_loop)
9464 octx = octx->outer_context;
9465 n = splay_tree_lookup (octx->variables,
9466 (splay_tree_key)decl);
9467 if (n != NULL && (n->value & GOVD_LOCAL) != 0)
9469 OMP_CLAUSE_LINEAR_NO_COPYOUT (c) = 1;
9470 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
9477 OMP_CLAUSE_DECL (c) = decl;
9478 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (for_stmt);
9479 OMP_FOR_CLAUSES (for_stmt) = c;
9480 omp_add_variable (gimplify_omp_ctxp, decl, flags);
9481 if (outer && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
9483 if (outer->region_type == ORT_WORKSHARE
9484 && outer->combined_loop)
9486 if (outer->outer_context
9487 && (outer->outer_context->region_type
9488 == ORT_COMBINED_PARALLEL))
9489 outer = outer->outer_context;
9490 else if (omp_check_private (outer, decl, false))
9491 outer = NULL;
9493 else if (((outer->region_type & ORT_TASK) != 0)
9494 && outer->combined_loop
9495 && !omp_check_private (gimplify_omp_ctxp,
9496 decl, false))
9498 else if (outer->region_type != ORT_COMBINED_PARALLEL)
9500 omp_notice_variable (outer, decl, true);
9501 outer = NULL;
9503 if (outer)
9505 n = splay_tree_lookup (outer->variables,
9506 (splay_tree_key)decl);
9507 if (n == NULL || (n->value & GOVD_DATA_SHARE_CLASS) == 0)
9509 omp_add_variable (outer, decl,
9510 GOVD_LASTPRIVATE | GOVD_SEEN);
9511 if (outer->region_type == ORT_COMBINED_PARALLEL
9512 && outer->outer_context
9513 && (outer->outer_context->region_type
9514 == ORT_WORKSHARE)
9515 && outer->outer_context->combined_loop)
9517 outer = outer->outer_context;
9518 n = splay_tree_lookup (outer->variables,
9519 (splay_tree_key)decl);
9520 if (omp_check_private (outer, decl, false))
9521 outer = NULL;
9522 else if (n == NULL
9523 || ((n->value & GOVD_DATA_SHARE_CLASS)
9524 == 0))
9525 omp_add_variable (outer, decl,
9526 GOVD_LASTPRIVATE
9527 | GOVD_SEEN);
9528 else
9529 outer = NULL;
9531 if (outer && outer->outer_context
9532 && (outer->outer_context->region_type
9533 == ORT_COMBINED_TEAMS))
9535 outer = outer->outer_context;
9536 n = splay_tree_lookup (outer->variables,
9537 (splay_tree_key)decl);
9538 if (n == NULL
9539 || (n->value & GOVD_DATA_SHARE_CLASS) == 0)
9540 omp_add_variable (outer, decl,
9541 GOVD_SHARED | GOVD_SEEN);
9542 else
9543 outer = NULL;
9545 if (outer && outer->outer_context)
9546 omp_notice_variable (outer->outer_context, decl,
9547 true);
9552 else
9554 bool lastprivate
9555 = (!has_decl_expr
9556 || !bitmap_bit_p (has_decl_expr, DECL_UID (decl)))
9557 && !omp_no_lastprivate (gimplify_omp_ctxp);
9558 struct gimplify_omp_ctx *outer
9559 = gimplify_omp_ctxp->outer_context;
9560 if (outer && lastprivate)
9562 if (outer->region_type == ORT_WORKSHARE
9563 && outer->combined_loop)
9565 n = splay_tree_lookup (outer->variables,
9566 (splay_tree_key)decl);
9567 if (n != NULL && (n->value & GOVD_LOCAL) != 0)
9569 lastprivate = false;
9570 outer = NULL;
9572 else if (outer->outer_context
9573 && (outer->outer_context->region_type
9574 == ORT_COMBINED_PARALLEL))
9575 outer = outer->outer_context;
9576 else if (omp_check_private (outer, decl, false))
9577 outer = NULL;
9579 else if (((outer->region_type & ORT_TASK) != 0)
9580 && outer->combined_loop
9581 && !omp_check_private (gimplify_omp_ctxp,
9582 decl, false))
9584 else if (outer->region_type != ORT_COMBINED_PARALLEL)
9586 omp_notice_variable (outer, decl, true);
9587 outer = NULL;
9589 if (outer)
9591 n = splay_tree_lookup (outer->variables,
9592 (splay_tree_key)decl);
9593 if (n == NULL || (n->value & GOVD_DATA_SHARE_CLASS) == 0)
9595 omp_add_variable (outer, decl,
9596 GOVD_LASTPRIVATE | GOVD_SEEN);
9597 if (outer->region_type == ORT_COMBINED_PARALLEL
9598 && outer->outer_context
9599 && (outer->outer_context->region_type
9600 == ORT_WORKSHARE)
9601 && outer->outer_context->combined_loop)
9603 outer = outer->outer_context;
9604 n = splay_tree_lookup (outer->variables,
9605 (splay_tree_key)decl);
9606 if (omp_check_private (outer, decl, false))
9607 outer = NULL;
9608 else if (n == NULL
9609 || ((n->value & GOVD_DATA_SHARE_CLASS)
9610 == 0))
9611 omp_add_variable (outer, decl,
9612 GOVD_LASTPRIVATE
9613 | GOVD_SEEN);
9614 else
9615 outer = NULL;
9617 if (outer && outer->outer_context
9618 && (outer->outer_context->region_type
9619 == ORT_COMBINED_TEAMS))
9621 outer = outer->outer_context;
9622 n = splay_tree_lookup (outer->variables,
9623 (splay_tree_key)decl);
9624 if (n == NULL
9625 || (n->value & GOVD_DATA_SHARE_CLASS) == 0)
9626 omp_add_variable (outer, decl,
9627 GOVD_SHARED | GOVD_SEEN);
9628 else
9629 outer = NULL;
9631 if (outer && outer->outer_context)
9632 omp_notice_variable (outer->outer_context, decl,
9633 true);
9638 c = build_omp_clause (input_location,
9639 lastprivate ? OMP_CLAUSE_LASTPRIVATE
9640 : OMP_CLAUSE_PRIVATE);
9641 OMP_CLAUSE_DECL (c) = decl;
9642 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (for_stmt);
9643 OMP_FOR_CLAUSES (for_stmt) = c;
9644 omp_add_variable (gimplify_omp_ctxp, decl,
9645 (lastprivate ? GOVD_LASTPRIVATE : GOVD_PRIVATE)
9646 | GOVD_EXPLICIT | GOVD_SEEN);
9647 c = NULL_TREE;
9650 else if (omp_is_private (gimplify_omp_ctxp, decl, 0))
9651 omp_notice_variable (gimplify_omp_ctxp, decl, true);
9652 else
9653 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
9655 /* If DECL is not a gimple register, create a temporary variable to act
9656 as an iteration counter. This is valid, since DECL cannot be
9657 modified in the body of the loop. Similarly for any iteration vars
9658 in simd with collapse > 1 where the iterator vars must be
9659 lastprivate. */
9660 if (orig_for_stmt != for_stmt)
9661 var = decl;
9662 else if (!is_gimple_reg (decl)
9663 || (ort == ORT_SIMD
9664 && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) > 1))
9666 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
9667 /* Make sure omp_add_variable is not called on it prematurely.
9668 We call it ourselves a few lines later. */
9669 gimplify_omp_ctxp = NULL;
9670 var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
9671 gimplify_omp_ctxp = ctx;
9672 TREE_OPERAND (t, 0) = var;
9674 gimplify_seq_add_stmt (&for_body, gimple_build_assign (decl, var));
9676 if (ort == ORT_SIMD
9677 && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) == 1)
9679 c2 = build_omp_clause (input_location, OMP_CLAUSE_LINEAR);
9680 OMP_CLAUSE_LINEAR_NO_COPYIN (c2) = 1;
9681 OMP_CLAUSE_LINEAR_NO_COPYOUT (c2) = 1;
9682 OMP_CLAUSE_DECL (c2) = var;
9683 OMP_CLAUSE_CHAIN (c2) = OMP_FOR_CLAUSES (for_stmt);
9684 OMP_FOR_CLAUSES (for_stmt) = c2;
9685 omp_add_variable (gimplify_omp_ctxp, var,
9686 GOVD_LINEAR | GOVD_EXPLICIT | GOVD_SEEN);
9687 if (c == NULL_TREE)
9689 c = c2;
9690 c2 = NULL_TREE;
9693 else
9694 omp_add_variable (gimplify_omp_ctxp, var,
9695 GOVD_PRIVATE | GOVD_SEEN);
9697 else
9698 var = decl;
9700 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
9701 is_gimple_val, fb_rvalue, false);
9702 ret = MIN (ret, tret);
9703 if (ret == GS_ERROR)
9704 return ret;
9706 /* Handle OMP_FOR_COND. */
9707 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
9708 gcc_assert (COMPARISON_CLASS_P (t));
9709 gcc_assert (TREE_OPERAND (t, 0) == decl);
9711 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
9712 is_gimple_val, fb_rvalue, false);
9713 ret = MIN (ret, tret);
9715 /* Handle OMP_FOR_INCR. */
9716 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
9717 switch (TREE_CODE (t))
9719 case PREINCREMENT_EXPR:
9720 case POSTINCREMENT_EXPR:
9722 tree decl = TREE_OPERAND (t, 0);
9723 /* c_omp_for_incr_canonicalize_ptr() should have been
9724 called to massage things appropriately. */
9725 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl)));
9727 if (orig_for_stmt != for_stmt)
9728 break;
9729 t = build_int_cst (TREE_TYPE (decl), 1);
9730 if (c)
9731 OMP_CLAUSE_LINEAR_STEP (c) = t;
9732 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
9733 t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
9734 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
9735 break;
9738 case PREDECREMENT_EXPR:
9739 case POSTDECREMENT_EXPR:
9740 /* c_omp_for_incr_canonicalize_ptr() should have been
9741 called to massage things appropriately. */
9742 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl)));
9743 if (orig_for_stmt != for_stmt)
9744 break;
9745 t = build_int_cst (TREE_TYPE (decl), -1);
9746 if (c)
9747 OMP_CLAUSE_LINEAR_STEP (c) = t;
9748 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
9749 t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
9750 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
9751 break;
9753 case MODIFY_EXPR:
9754 gcc_assert (TREE_OPERAND (t, 0) == decl);
9755 TREE_OPERAND (t, 0) = var;
9757 t = TREE_OPERAND (t, 1);
9758 switch (TREE_CODE (t))
9760 case PLUS_EXPR:
9761 if (TREE_OPERAND (t, 1) == decl)
9763 TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
9764 TREE_OPERAND (t, 0) = var;
9765 break;
9768 /* Fallthru. */
9769 case MINUS_EXPR:
9770 case POINTER_PLUS_EXPR:
9771 gcc_assert (TREE_OPERAND (t, 0) == decl);
9772 TREE_OPERAND (t, 0) = var;
9773 break;
9774 default:
9775 gcc_unreachable ();
9778 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
9779 is_gimple_val, fb_rvalue, false);
9780 ret = MIN (ret, tret);
9781 if (c)
9783 tree step = TREE_OPERAND (t, 1);
9784 tree stept = TREE_TYPE (decl);
9785 if (POINTER_TYPE_P (stept))
9786 stept = sizetype;
9787 step = fold_convert (stept, step);
9788 if (TREE_CODE (t) == MINUS_EXPR)
9789 step = fold_build1 (NEGATE_EXPR, stept, step);
9790 OMP_CLAUSE_LINEAR_STEP (c) = step;
9791 if (step != TREE_OPERAND (t, 1))
9793 tret = gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c),
9794 &for_pre_body, NULL,
9795 is_gimple_val, fb_rvalue, false);
9796 ret = MIN (ret, tret);
9799 break;
9801 default:
9802 gcc_unreachable ();
9805 if (c2)
9807 gcc_assert (c);
9808 OMP_CLAUSE_LINEAR_STEP (c2) = OMP_CLAUSE_LINEAR_STEP (c);
9811 if ((var != decl || collapse > 1) && orig_for_stmt == for_stmt)
9813 for (c = OMP_FOR_CLAUSES (for_stmt); c ; c = OMP_CLAUSE_CHAIN (c))
9814 if (((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
9815 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c) == NULL)
9816 || (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
9817 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c)
9818 && OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c) == NULL))
9819 && OMP_CLAUSE_DECL (c) == decl)
9821 if (is_doacross && (collapse == 1 || i >= collapse))
9822 t = var;
9823 else
9825 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
9826 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
9827 gcc_assert (TREE_OPERAND (t, 0) == var);
9828 t = TREE_OPERAND (t, 1);
9829 gcc_assert (TREE_CODE (t) == PLUS_EXPR
9830 || TREE_CODE (t) == MINUS_EXPR
9831 || TREE_CODE (t) == POINTER_PLUS_EXPR);
9832 gcc_assert (TREE_OPERAND (t, 0) == var);
9833 t = build2 (TREE_CODE (t), TREE_TYPE (decl),
9834 is_doacross ? var : decl,
9835 TREE_OPERAND (t, 1));
9837 gimple_seq *seq;
9838 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
9839 seq = &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c);
9840 else
9841 seq = &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c);
9842 gimplify_assign (decl, t, seq);
9847 BITMAP_FREE (has_decl_expr);
9849 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
9851 push_gimplify_context ();
9852 if (TREE_CODE (OMP_FOR_BODY (orig_for_stmt)) != BIND_EXPR)
9854 OMP_FOR_BODY (orig_for_stmt)
9855 = build3 (BIND_EXPR, void_type_node, NULL,
9856 OMP_FOR_BODY (orig_for_stmt), NULL);
9857 TREE_SIDE_EFFECTS (OMP_FOR_BODY (orig_for_stmt)) = 1;
9861 gimple *g = gimplify_and_return_first (OMP_FOR_BODY (orig_for_stmt),
9862 &for_body);
9864 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
9866 if (gimple_code (g) == GIMPLE_BIND)
9867 pop_gimplify_context (g);
9868 else
9869 pop_gimplify_context (NULL);
9872 if (orig_for_stmt != for_stmt)
9873 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
9875 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
9876 decl = TREE_OPERAND (t, 0);
9877 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
9878 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
9879 gimplify_omp_ctxp = ctx->outer_context;
9880 var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
9881 gimplify_omp_ctxp = ctx;
9882 omp_add_variable (gimplify_omp_ctxp, var, GOVD_PRIVATE | GOVD_SEEN);
9883 TREE_OPERAND (t, 0) = var;
9884 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
9885 TREE_OPERAND (t, 1) = copy_node (TREE_OPERAND (t, 1));
9886 TREE_OPERAND (TREE_OPERAND (t, 1), 0) = var;
9889 gimplify_adjust_omp_clauses (pre_p, for_body,
9890 &OMP_FOR_CLAUSES (orig_for_stmt),
9891 TREE_CODE (orig_for_stmt));
9893 int kind;
9894 switch (TREE_CODE (orig_for_stmt))
9896 case OMP_FOR: kind = GF_OMP_FOR_KIND_FOR; break;
9897 case OMP_SIMD: kind = GF_OMP_FOR_KIND_SIMD; break;
9898 case CILK_SIMD: kind = GF_OMP_FOR_KIND_CILKSIMD; break;
9899 case CILK_FOR: kind = GF_OMP_FOR_KIND_CILKFOR; break;
9900 case OMP_DISTRIBUTE: kind = GF_OMP_FOR_KIND_DISTRIBUTE; break;
9901 case OMP_TASKLOOP: kind = GF_OMP_FOR_KIND_TASKLOOP; break;
9902 case OACC_LOOP: kind = GF_OMP_FOR_KIND_OACC_LOOP; break;
9903 default:
9904 gcc_unreachable ();
9906 gfor = gimple_build_omp_for (for_body, kind, OMP_FOR_CLAUSES (orig_for_stmt),
9907 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)),
9908 for_pre_body);
9909 if (orig_for_stmt != for_stmt)
9910 gimple_omp_for_set_combined_p (gfor, true);
9911 if (gimplify_omp_ctxp
9912 && (gimplify_omp_ctxp->combined_loop
9913 || (gimplify_omp_ctxp->region_type == ORT_COMBINED_PARALLEL
9914 && gimplify_omp_ctxp->outer_context
9915 && gimplify_omp_ctxp->outer_context->combined_loop)))
9917 gimple_omp_for_set_combined_into_p (gfor, true);
9918 if (gimplify_omp_ctxp->combined_loop)
9919 gcc_assert (TREE_CODE (orig_for_stmt) == OMP_SIMD);
9920 else
9921 gcc_assert (TREE_CODE (orig_for_stmt) == OMP_FOR);
9924 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
9926 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
9927 gimple_omp_for_set_index (gfor, i, TREE_OPERAND (t, 0));
9928 gimple_omp_for_set_initial (gfor, i, TREE_OPERAND (t, 1));
9929 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
9930 gimple_omp_for_set_cond (gfor, i, TREE_CODE (t));
9931 gimple_omp_for_set_final (gfor, i, TREE_OPERAND (t, 1));
9932 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
9933 gimple_omp_for_set_incr (gfor, i, TREE_OPERAND (t, 1));
9936 /* OMP_TASKLOOP is gimplified as two GIMPLE_OMP_FOR taskloop
9937 constructs with GIMPLE_OMP_TASK sandwiched in between them.
9938 The outer taskloop stands for computing the number of iterations,
9939 counts for collapsed loops and holding taskloop specific clauses.
9940 The task construct stands for the effect of data sharing on the
9941 explicit task it creates and the inner taskloop stands for expansion
9942 of the static loop inside of the explicit task construct. */
9943 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
9945 tree *gfor_clauses_ptr = gimple_omp_for_clauses_ptr (gfor);
9946 tree task_clauses = NULL_TREE;
9947 tree c = *gfor_clauses_ptr;
9948 tree *gtask_clauses_ptr = &task_clauses;
9949 tree outer_for_clauses = NULL_TREE;
9950 tree *gforo_clauses_ptr = &outer_for_clauses;
9951 for (; c; c = OMP_CLAUSE_CHAIN (c))
9952 switch (OMP_CLAUSE_CODE (c))
9954 /* These clauses are allowed on task, move them there. */
9955 case OMP_CLAUSE_SHARED:
9956 case OMP_CLAUSE_FIRSTPRIVATE:
9957 case OMP_CLAUSE_DEFAULT:
9958 case OMP_CLAUSE_IF:
9959 case OMP_CLAUSE_UNTIED:
9960 case OMP_CLAUSE_FINAL:
9961 case OMP_CLAUSE_MERGEABLE:
9962 case OMP_CLAUSE_PRIORITY:
9963 *gtask_clauses_ptr = c;
9964 gtask_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
9965 break;
9966 case OMP_CLAUSE_PRIVATE:
9967 if (OMP_CLAUSE_PRIVATE_TASKLOOP_IV (c))
9969 /* We want private on outer for and firstprivate
9970 on task. */
9971 *gtask_clauses_ptr
9972 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
9973 OMP_CLAUSE_FIRSTPRIVATE);
9974 OMP_CLAUSE_DECL (*gtask_clauses_ptr) = OMP_CLAUSE_DECL (c);
9975 lang_hooks.decls.omp_finish_clause (*gtask_clauses_ptr, NULL);
9976 gtask_clauses_ptr = &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr);
9977 *gforo_clauses_ptr = c;
9978 gforo_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
9980 else
9982 *gtask_clauses_ptr = c;
9983 gtask_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
9985 break;
9986 /* These clauses go into outer taskloop clauses. */
9987 case OMP_CLAUSE_GRAINSIZE:
9988 case OMP_CLAUSE_NUM_TASKS:
9989 case OMP_CLAUSE_NOGROUP:
9990 *gforo_clauses_ptr = c;
9991 gforo_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
9992 break;
9993 /* Taskloop clause we duplicate on both taskloops. */
9994 case OMP_CLAUSE_COLLAPSE:
9995 *gfor_clauses_ptr = c;
9996 gfor_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
9997 *gforo_clauses_ptr = copy_node (c);
9998 gforo_clauses_ptr = &OMP_CLAUSE_CHAIN (*gforo_clauses_ptr);
9999 break;
10000 /* For lastprivate, keep the clause on inner taskloop, and add
10001 a shared clause on task. If the same decl is also firstprivate,
10002 add also firstprivate clause on the inner taskloop. */
10003 case OMP_CLAUSE_LASTPRIVATE:
10004 if (OMP_CLAUSE_LASTPRIVATE_TASKLOOP_IV (c))
10006 /* For taskloop C++ lastprivate IVs, we want:
10007 1) private on outer taskloop
10008 2) firstprivate and shared on task
10009 3) lastprivate on inner taskloop */
10010 *gtask_clauses_ptr
10011 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
10012 OMP_CLAUSE_FIRSTPRIVATE);
10013 OMP_CLAUSE_DECL (*gtask_clauses_ptr) = OMP_CLAUSE_DECL (c);
10014 lang_hooks.decls.omp_finish_clause (*gtask_clauses_ptr, NULL);
10015 gtask_clauses_ptr = &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr);
10016 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c) = 1;
10017 *gforo_clauses_ptr = build_omp_clause (OMP_CLAUSE_LOCATION (c),
10018 OMP_CLAUSE_PRIVATE);
10019 OMP_CLAUSE_DECL (*gforo_clauses_ptr) = OMP_CLAUSE_DECL (c);
10020 OMP_CLAUSE_PRIVATE_TASKLOOP_IV (*gforo_clauses_ptr) = 1;
10021 TREE_TYPE (*gforo_clauses_ptr) = TREE_TYPE (c);
10022 gforo_clauses_ptr = &OMP_CLAUSE_CHAIN (*gforo_clauses_ptr);
10024 *gfor_clauses_ptr = c;
10025 gfor_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
10026 *gtask_clauses_ptr
10027 = build_omp_clause (OMP_CLAUSE_LOCATION (c), OMP_CLAUSE_SHARED);
10028 OMP_CLAUSE_DECL (*gtask_clauses_ptr) = OMP_CLAUSE_DECL (c);
10029 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c))
10030 OMP_CLAUSE_SHARED_FIRSTPRIVATE (*gtask_clauses_ptr) = 1;
10031 gtask_clauses_ptr
10032 = &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr);
10033 break;
10034 default:
10035 gcc_unreachable ();
10037 *gfor_clauses_ptr = NULL_TREE;
10038 *gtask_clauses_ptr = NULL_TREE;
10039 *gforo_clauses_ptr = NULL_TREE;
10040 g = gimple_build_bind (NULL_TREE, gfor, NULL_TREE);
10041 g = gimple_build_omp_task (g, task_clauses, NULL_TREE, NULL_TREE,
10042 NULL_TREE, NULL_TREE, NULL_TREE);
10043 gimple_omp_task_set_taskloop_p (g, true);
10044 g = gimple_build_bind (NULL_TREE, g, NULL_TREE);
10045 gomp_for *gforo
10046 = gimple_build_omp_for (g, GF_OMP_FOR_KIND_TASKLOOP, outer_for_clauses,
10047 gimple_omp_for_collapse (gfor),
10048 gimple_omp_for_pre_body (gfor));
10049 gimple_omp_for_set_pre_body (gfor, NULL);
10050 gimple_omp_for_set_combined_p (gforo, true);
10051 gimple_omp_for_set_combined_into_p (gfor, true);
10052 for (i = 0; i < (int) gimple_omp_for_collapse (gfor); i++)
10054 t = unshare_expr (gimple_omp_for_index (gfor, i));
10055 gimple_omp_for_set_index (gforo, i, t);
10056 t = unshare_expr (gimple_omp_for_initial (gfor, i));
10057 gimple_omp_for_set_initial (gforo, i, t);
10058 gimple_omp_for_set_cond (gforo, i,
10059 gimple_omp_for_cond (gfor, i));
10060 t = unshare_expr (gimple_omp_for_final (gfor, i));
10061 gimple_omp_for_set_final (gforo, i, t);
10062 t = unshare_expr (gimple_omp_for_incr (gfor, i));
10063 gimple_omp_for_set_incr (gforo, i, t);
10065 gimplify_seq_add_stmt (pre_p, gforo);
10067 else
10068 gimplify_seq_add_stmt (pre_p, gfor);
10069 if (ret != GS_ALL_DONE)
10070 return GS_ERROR;
10071 *expr_p = NULL_TREE;
10072 return GS_ALL_DONE;
10075 /* Helper function of optimize_target_teams, find OMP_TEAMS inside
10076 of OMP_TARGET's body. */
10078 static tree
10079 find_omp_teams (tree *tp, int *walk_subtrees, void *)
10081 *walk_subtrees = 0;
10082 switch (TREE_CODE (*tp))
10084 case OMP_TEAMS:
10085 return *tp;
10086 case BIND_EXPR:
10087 case STATEMENT_LIST:
10088 *walk_subtrees = 1;
10089 break;
10090 default:
10091 break;
10093 return NULL_TREE;
10096 /* Helper function of optimize_target_teams, determine if the expression
10097 can be computed safely before the target construct on the host. */
10099 static tree
10100 computable_teams_clause (tree *tp, int *walk_subtrees, void *)
10102 splay_tree_node n;
10104 if (TYPE_P (*tp))
10106 *walk_subtrees = 0;
10107 return NULL_TREE;
10109 switch (TREE_CODE (*tp))
10111 case VAR_DECL:
10112 case PARM_DECL:
10113 case RESULT_DECL:
10114 *walk_subtrees = 0;
10115 if (error_operand_p (*tp)
10116 || !INTEGRAL_TYPE_P (TREE_TYPE (*tp))
10117 || DECL_HAS_VALUE_EXPR_P (*tp)
10118 || DECL_THREAD_LOCAL_P (*tp)
10119 || TREE_SIDE_EFFECTS (*tp)
10120 || TREE_THIS_VOLATILE (*tp))
10121 return *tp;
10122 if (is_global_var (*tp)
10123 && (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (*tp))
10124 || lookup_attribute ("omp declare target link",
10125 DECL_ATTRIBUTES (*tp))))
10126 return *tp;
10127 n = splay_tree_lookup (gimplify_omp_ctxp->variables,
10128 (splay_tree_key) *tp);
10129 if (n == NULL)
10131 if (gimplify_omp_ctxp->target_map_scalars_firstprivate)
10132 return NULL_TREE;
10133 return *tp;
10135 else if (n->value & GOVD_LOCAL)
10136 return *tp;
10137 else if (n->value & GOVD_FIRSTPRIVATE)
10138 return NULL_TREE;
10139 else if ((n->value & (GOVD_MAP | GOVD_MAP_ALWAYS_TO))
10140 == (GOVD_MAP | GOVD_MAP_ALWAYS_TO))
10141 return NULL_TREE;
10142 return *tp;
10143 case INTEGER_CST:
10144 if (!INTEGRAL_TYPE_P (TREE_TYPE (*tp)))
10145 return *tp;
10146 return NULL_TREE;
10147 case TARGET_EXPR:
10148 if (TARGET_EXPR_INITIAL (*tp)
10149 || TREE_CODE (TARGET_EXPR_SLOT (*tp)) != VAR_DECL)
10150 return *tp;
10151 return computable_teams_clause (&TARGET_EXPR_SLOT (*tp),
10152 walk_subtrees, NULL);
10153 /* Allow some reasonable subset of integral arithmetics. */
10154 case PLUS_EXPR:
10155 case MINUS_EXPR:
10156 case MULT_EXPR:
10157 case TRUNC_DIV_EXPR:
10158 case CEIL_DIV_EXPR:
10159 case FLOOR_DIV_EXPR:
10160 case ROUND_DIV_EXPR:
10161 case TRUNC_MOD_EXPR:
10162 case CEIL_MOD_EXPR:
10163 case FLOOR_MOD_EXPR:
10164 case ROUND_MOD_EXPR:
10165 case RDIV_EXPR:
10166 case EXACT_DIV_EXPR:
10167 case MIN_EXPR:
10168 case MAX_EXPR:
10169 case LSHIFT_EXPR:
10170 case RSHIFT_EXPR:
10171 case BIT_IOR_EXPR:
10172 case BIT_XOR_EXPR:
10173 case BIT_AND_EXPR:
10174 case NEGATE_EXPR:
10175 case ABS_EXPR:
10176 case BIT_NOT_EXPR:
10177 case NON_LVALUE_EXPR:
10178 CASE_CONVERT:
10179 if (!INTEGRAL_TYPE_P (TREE_TYPE (*tp)))
10180 return *tp;
10181 return NULL_TREE;
10182 /* And disallow anything else, except for comparisons. */
10183 default:
10184 if (COMPARISON_CLASS_P (*tp))
10185 return NULL_TREE;
10186 return *tp;
10190 /* Try to determine if the num_teams and/or thread_limit expressions
10191 can have their values determined already before entering the
10192 target construct.
10193 INTEGER_CSTs trivially are,
10194 integral decls that are firstprivate (explicitly or implicitly)
10195 or explicitly map(always, to:) or map(always, tofrom:) on the target
10196 region too, and expressions involving simple arithmetics on those
10197 too, function calls are not ok, dereferencing something neither etc.
10198 Add NUM_TEAMS and THREAD_LIMIT clauses to the OMP_CLAUSES of
10199 EXPR based on what we find:
10200 0 stands for clause not specified at all, use implementation default
10201 -1 stands for value that can't be determined easily before entering
10202 the target construct.
10203 If teams construct is not present at all, use 1 for num_teams
10204 and 0 for thread_limit (only one team is involved, and the thread
10205 limit is implementation defined. */
10207 static void
10208 optimize_target_teams (tree target, gimple_seq *pre_p)
10210 tree body = OMP_BODY (target);
10211 tree teams = walk_tree (&body, find_omp_teams, NULL, NULL);
10212 tree num_teams = integer_zero_node;
10213 tree thread_limit = integer_zero_node;
10214 location_t num_teams_loc = EXPR_LOCATION (target);
10215 location_t thread_limit_loc = EXPR_LOCATION (target);
10216 tree c, *p, expr;
10217 struct gimplify_omp_ctx *target_ctx = gimplify_omp_ctxp;
10219 if (teams == NULL_TREE)
10220 num_teams = integer_one_node;
10221 else
10222 for (c = OMP_TEAMS_CLAUSES (teams); c; c = OMP_CLAUSE_CHAIN (c))
10224 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_NUM_TEAMS)
10226 p = &num_teams;
10227 num_teams_loc = OMP_CLAUSE_LOCATION (c);
10229 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_THREAD_LIMIT)
10231 p = &thread_limit;
10232 thread_limit_loc = OMP_CLAUSE_LOCATION (c);
10234 else
10235 continue;
10236 expr = OMP_CLAUSE_OPERAND (c, 0);
10237 if (TREE_CODE (expr) == INTEGER_CST)
10239 *p = expr;
10240 continue;
10242 if (walk_tree (&expr, computable_teams_clause, NULL, NULL))
10244 *p = integer_minus_one_node;
10245 continue;
10247 *p = expr;
10248 gimplify_omp_ctxp = gimplify_omp_ctxp->outer_context;
10249 if (gimplify_expr (p, pre_p, NULL, is_gimple_val, fb_rvalue, false)
10250 == GS_ERROR)
10252 gimplify_omp_ctxp = target_ctx;
10253 *p = integer_minus_one_node;
10254 continue;
10256 gimplify_omp_ctxp = target_ctx;
10257 if (!DECL_P (expr) && TREE_CODE (expr) != TARGET_EXPR)
10258 OMP_CLAUSE_OPERAND (c, 0) = *p;
10260 c = build_omp_clause (thread_limit_loc, OMP_CLAUSE_THREAD_LIMIT);
10261 OMP_CLAUSE_THREAD_LIMIT_EXPR (c) = thread_limit;
10262 OMP_CLAUSE_CHAIN (c) = OMP_TARGET_CLAUSES (target);
10263 OMP_TARGET_CLAUSES (target) = c;
10264 c = build_omp_clause (num_teams_loc, OMP_CLAUSE_NUM_TEAMS);
10265 OMP_CLAUSE_NUM_TEAMS_EXPR (c) = num_teams;
10266 OMP_CLAUSE_CHAIN (c) = OMP_TARGET_CLAUSES (target);
10267 OMP_TARGET_CLAUSES (target) = c;
10270 /* Gimplify the gross structure of several OMP constructs. */
10272 static void
10273 gimplify_omp_workshare (tree *expr_p, gimple_seq *pre_p)
10275 tree expr = *expr_p;
10276 gimple *stmt;
10277 gimple_seq body = NULL;
10278 enum omp_region_type ort;
10280 switch (TREE_CODE (expr))
10282 case OMP_SECTIONS:
10283 case OMP_SINGLE:
10284 ort = ORT_WORKSHARE;
10285 break;
10286 case OMP_TARGET:
10287 ort = OMP_TARGET_COMBINED (expr) ? ORT_COMBINED_TARGET : ORT_TARGET;
10288 break;
10289 case OACC_KERNELS:
10290 ort = ORT_ACC_KERNELS;
10291 break;
10292 case OACC_PARALLEL:
10293 ort = ORT_ACC_PARALLEL;
10294 break;
10295 case OACC_DATA:
10296 ort = ORT_ACC_DATA;
10297 break;
10298 case OMP_TARGET_DATA:
10299 ort = ORT_TARGET_DATA;
10300 break;
10301 case OMP_TEAMS:
10302 ort = OMP_TEAMS_COMBINED (expr) ? ORT_COMBINED_TEAMS : ORT_TEAMS;
10303 break;
10304 case OACC_HOST_DATA:
10305 ort = ORT_ACC_HOST_DATA;
10306 break;
10307 default:
10308 gcc_unreachable ();
10310 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr), pre_p, ort,
10311 TREE_CODE (expr));
10312 if (TREE_CODE (expr) == OMP_TARGET)
10313 optimize_target_teams (expr, pre_p);
10314 if ((ort & (ORT_TARGET | ORT_TARGET_DATA)) != 0)
10316 push_gimplify_context ();
10317 gimple *g = gimplify_and_return_first (OMP_BODY (expr), &body);
10318 if (gimple_code (g) == GIMPLE_BIND)
10319 pop_gimplify_context (g);
10320 else
10321 pop_gimplify_context (NULL);
10322 if ((ort & ORT_TARGET_DATA) != 0)
10324 enum built_in_function end_ix;
10325 switch (TREE_CODE (expr))
10327 case OACC_DATA:
10328 case OACC_HOST_DATA:
10329 end_ix = BUILT_IN_GOACC_DATA_END;
10330 break;
10331 case OMP_TARGET_DATA:
10332 end_ix = BUILT_IN_GOMP_TARGET_END_DATA;
10333 break;
10334 default:
10335 gcc_unreachable ();
10337 tree fn = builtin_decl_explicit (end_ix);
10338 g = gimple_build_call (fn, 0);
10339 gimple_seq cleanup = NULL;
10340 gimple_seq_add_stmt (&cleanup, g);
10341 g = gimple_build_try (body, cleanup, GIMPLE_TRY_FINALLY);
10342 body = NULL;
10343 gimple_seq_add_stmt (&body, g);
10346 else
10347 gimplify_and_add (OMP_BODY (expr), &body);
10348 gimplify_adjust_omp_clauses (pre_p, body, &OMP_CLAUSES (expr),
10349 TREE_CODE (expr));
10351 switch (TREE_CODE (expr))
10353 case OACC_DATA:
10354 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_OACC_DATA,
10355 OMP_CLAUSES (expr));
10356 break;
10357 case OACC_KERNELS:
10358 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_OACC_KERNELS,
10359 OMP_CLAUSES (expr));
10360 break;
10361 case OACC_HOST_DATA:
10362 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_OACC_HOST_DATA,
10363 OMP_CLAUSES (expr));
10364 break;
10365 case OACC_PARALLEL:
10366 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_OACC_PARALLEL,
10367 OMP_CLAUSES (expr));
10368 break;
10369 case OMP_SECTIONS:
10370 stmt = gimple_build_omp_sections (body, OMP_CLAUSES (expr));
10371 break;
10372 case OMP_SINGLE:
10373 stmt = gimple_build_omp_single (body, OMP_CLAUSES (expr));
10374 break;
10375 case OMP_TARGET:
10376 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_REGION,
10377 OMP_CLAUSES (expr));
10378 break;
10379 case OMP_TARGET_DATA:
10380 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_DATA,
10381 OMP_CLAUSES (expr));
10382 break;
10383 case OMP_TEAMS:
10384 stmt = gimple_build_omp_teams (body, OMP_CLAUSES (expr));
10385 break;
10386 default:
10387 gcc_unreachable ();
10390 gimplify_seq_add_stmt (pre_p, stmt);
10391 *expr_p = NULL_TREE;
10394 /* Gimplify the gross structure of OpenACC enter/exit data, update, and OpenMP
10395 target update constructs. */
10397 static void
10398 gimplify_omp_target_update (tree *expr_p, gimple_seq *pre_p)
10400 tree expr = *expr_p;
10401 int kind;
10402 gomp_target *stmt;
10403 enum omp_region_type ort = ORT_WORKSHARE;
10405 switch (TREE_CODE (expr))
10407 case OACC_ENTER_DATA:
10408 case OACC_EXIT_DATA:
10409 kind = GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA;
10410 ort = ORT_ACC;
10411 break;
10412 case OACC_UPDATE:
10413 kind = GF_OMP_TARGET_KIND_OACC_UPDATE;
10414 ort = ORT_ACC;
10415 break;
10416 case OMP_TARGET_UPDATE:
10417 kind = GF_OMP_TARGET_KIND_UPDATE;
10418 break;
10419 case OMP_TARGET_ENTER_DATA:
10420 kind = GF_OMP_TARGET_KIND_ENTER_DATA;
10421 break;
10422 case OMP_TARGET_EXIT_DATA:
10423 kind = GF_OMP_TARGET_KIND_EXIT_DATA;
10424 break;
10425 default:
10426 gcc_unreachable ();
10428 gimplify_scan_omp_clauses (&OMP_STANDALONE_CLAUSES (expr), pre_p,
10429 ort, TREE_CODE (expr));
10430 gimplify_adjust_omp_clauses (pre_p, NULL, &OMP_STANDALONE_CLAUSES (expr),
10431 TREE_CODE (expr));
10432 stmt = gimple_build_omp_target (NULL, kind, OMP_STANDALONE_CLAUSES (expr));
10434 gimplify_seq_add_stmt (pre_p, stmt);
10435 *expr_p = NULL_TREE;
10438 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
10439 stabilized the lhs of the atomic operation as *ADDR. Return true if
10440 EXPR is this stabilized form. */
10442 static bool
10443 goa_lhs_expr_p (tree expr, tree addr)
10445 /* Also include casts to other type variants. The C front end is fond
10446 of adding these for e.g. volatile variables. This is like
10447 STRIP_TYPE_NOPS but includes the main variant lookup. */
10448 STRIP_USELESS_TYPE_CONVERSION (expr);
10450 if (TREE_CODE (expr) == INDIRECT_REF)
10452 expr = TREE_OPERAND (expr, 0);
10453 while (expr != addr
10454 && (CONVERT_EXPR_P (expr)
10455 || TREE_CODE (expr) == NON_LVALUE_EXPR)
10456 && TREE_CODE (expr) == TREE_CODE (addr)
10457 && types_compatible_p (TREE_TYPE (expr), TREE_TYPE (addr)))
10459 expr = TREE_OPERAND (expr, 0);
10460 addr = TREE_OPERAND (addr, 0);
10462 if (expr == addr)
10463 return true;
10464 return (TREE_CODE (addr) == ADDR_EXPR
10465 && TREE_CODE (expr) == ADDR_EXPR
10466 && TREE_OPERAND (addr, 0) == TREE_OPERAND (expr, 0));
10468 if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0))
10469 return true;
10470 return false;
10473 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
10474 expression does not involve the lhs, evaluate it into a temporary.
10475 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
10476 or -1 if an error was encountered. */
10478 static int
10479 goa_stabilize_expr (tree *expr_p, gimple_seq *pre_p, tree lhs_addr,
10480 tree lhs_var)
10482 tree expr = *expr_p;
10483 int saw_lhs;
10485 if (goa_lhs_expr_p (expr, lhs_addr))
10487 *expr_p = lhs_var;
10488 return 1;
10490 if (is_gimple_val (expr))
10491 return 0;
10493 saw_lhs = 0;
10494 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
10496 case tcc_binary:
10497 case tcc_comparison:
10498 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p, lhs_addr,
10499 lhs_var);
10500 /* FALLTHRU */
10501 case tcc_unary:
10502 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p, lhs_addr,
10503 lhs_var);
10504 break;
10505 case tcc_expression:
10506 switch (TREE_CODE (expr))
10508 case TRUTH_ANDIF_EXPR:
10509 case TRUTH_ORIF_EXPR:
10510 case TRUTH_AND_EXPR:
10511 case TRUTH_OR_EXPR:
10512 case TRUTH_XOR_EXPR:
10513 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
10514 lhs_addr, lhs_var);
10515 /* FALLTHRU */
10516 case TRUTH_NOT_EXPR:
10517 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
10518 lhs_addr, lhs_var);
10519 break;
10520 case COMPOUND_EXPR:
10521 /* Break out any preevaluations from cp_build_modify_expr. */
10522 for (; TREE_CODE (expr) == COMPOUND_EXPR;
10523 expr = TREE_OPERAND (expr, 1))
10524 gimplify_stmt (&TREE_OPERAND (expr, 0), pre_p);
10525 *expr_p = expr;
10526 return goa_stabilize_expr (expr_p, pre_p, lhs_addr, lhs_var);
10527 default:
10528 break;
10530 break;
10531 default:
10532 break;
10535 if (saw_lhs == 0)
10537 enum gimplify_status gs;
10538 gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue);
10539 if (gs != GS_ALL_DONE)
10540 saw_lhs = -1;
10543 return saw_lhs;
10546 /* Gimplify an OMP_ATOMIC statement. */
10548 static enum gimplify_status
10549 gimplify_omp_atomic (tree *expr_p, gimple_seq *pre_p)
10551 tree addr = TREE_OPERAND (*expr_p, 0);
10552 tree rhs = TREE_CODE (*expr_p) == OMP_ATOMIC_READ
10553 ? NULL : TREE_OPERAND (*expr_p, 1);
10554 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
10555 tree tmp_load;
10556 gomp_atomic_load *loadstmt;
10557 gomp_atomic_store *storestmt;
10559 tmp_load = create_tmp_reg (type);
10560 if (rhs && goa_stabilize_expr (&rhs, pre_p, addr, tmp_load) < 0)
10561 return GS_ERROR;
10563 if (gimplify_expr (&addr, pre_p, NULL, is_gimple_val, fb_rvalue)
10564 != GS_ALL_DONE)
10565 return GS_ERROR;
10567 loadstmt = gimple_build_omp_atomic_load (tmp_load, addr);
10568 gimplify_seq_add_stmt (pre_p, loadstmt);
10569 if (rhs && gimplify_expr (&rhs, pre_p, NULL, is_gimple_val, fb_rvalue)
10570 != GS_ALL_DONE)
10571 return GS_ERROR;
10573 if (TREE_CODE (*expr_p) == OMP_ATOMIC_READ)
10574 rhs = tmp_load;
10575 storestmt = gimple_build_omp_atomic_store (rhs);
10576 gimplify_seq_add_stmt (pre_p, storestmt);
10577 if (OMP_ATOMIC_SEQ_CST (*expr_p))
10579 gimple_omp_atomic_set_seq_cst (loadstmt);
10580 gimple_omp_atomic_set_seq_cst (storestmt);
10582 switch (TREE_CODE (*expr_p))
10584 case OMP_ATOMIC_READ:
10585 case OMP_ATOMIC_CAPTURE_OLD:
10586 *expr_p = tmp_load;
10587 gimple_omp_atomic_set_need_value (loadstmt);
10588 break;
10589 case OMP_ATOMIC_CAPTURE_NEW:
10590 *expr_p = rhs;
10591 gimple_omp_atomic_set_need_value (storestmt);
10592 break;
10593 default:
10594 *expr_p = NULL;
10595 break;
10598 return GS_ALL_DONE;
10601 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
10602 body, and adding some EH bits. */
10604 static enum gimplify_status
10605 gimplify_transaction (tree *expr_p, gimple_seq *pre_p)
10607 tree expr = *expr_p, temp, tbody = TRANSACTION_EXPR_BODY (expr);
10608 gimple *body_stmt;
10609 gtransaction *trans_stmt;
10610 gimple_seq body = NULL;
10611 int subcode = 0;
10613 /* Wrap the transaction body in a BIND_EXPR so we have a context
10614 where to put decls for OMP. */
10615 if (TREE_CODE (tbody) != BIND_EXPR)
10617 tree bind = build3 (BIND_EXPR, void_type_node, NULL, tbody, NULL);
10618 TREE_SIDE_EFFECTS (bind) = 1;
10619 SET_EXPR_LOCATION (bind, EXPR_LOCATION (tbody));
10620 TRANSACTION_EXPR_BODY (expr) = bind;
10623 push_gimplify_context ();
10624 temp = voidify_wrapper_expr (*expr_p, NULL);
10626 body_stmt = gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr), &body);
10627 pop_gimplify_context (body_stmt);
10629 trans_stmt = gimple_build_transaction (body);
10630 if (TRANSACTION_EXPR_OUTER (expr))
10631 subcode = GTMA_IS_OUTER;
10632 else if (TRANSACTION_EXPR_RELAXED (expr))
10633 subcode = GTMA_IS_RELAXED;
10634 gimple_transaction_set_subcode (trans_stmt, subcode);
10636 gimplify_seq_add_stmt (pre_p, trans_stmt);
10638 if (temp)
10640 *expr_p = temp;
10641 return GS_OK;
10644 *expr_p = NULL_TREE;
10645 return GS_ALL_DONE;
10648 /* Gimplify an OMP_ORDERED construct. EXPR is the tree version. BODY
10649 is the OMP_BODY of the original EXPR (which has already been
10650 gimplified so it's not present in the EXPR).
10652 Return the gimplified GIMPLE_OMP_ORDERED tuple. */
10654 static gimple *
10655 gimplify_omp_ordered (tree expr, gimple_seq body)
10657 tree c, decls;
10658 int failures = 0;
10659 unsigned int i;
10660 tree source_c = NULL_TREE;
10661 tree sink_c = NULL_TREE;
10663 if (gimplify_omp_ctxp)
10665 for (c = OMP_ORDERED_CLAUSES (expr); c; c = OMP_CLAUSE_CHAIN (c))
10666 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
10667 && gimplify_omp_ctxp->loop_iter_var.is_empty ()
10668 && (OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SINK
10669 || OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SOURCE))
10671 error_at (OMP_CLAUSE_LOCATION (c),
10672 "%<ordered%> construct with %<depend%> clause must be "
10673 "closely nested inside a loop with %<ordered%> clause "
10674 "with a parameter");
10675 failures++;
10677 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
10678 && OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SINK)
10680 bool fail = false;
10681 for (decls = OMP_CLAUSE_DECL (c), i = 0;
10682 decls && TREE_CODE (decls) == TREE_LIST;
10683 decls = TREE_CHAIN (decls), ++i)
10684 if (i >= gimplify_omp_ctxp->loop_iter_var.length () / 2)
10685 continue;
10686 else if (TREE_VALUE (decls)
10687 != gimplify_omp_ctxp->loop_iter_var[2 * i])
10689 error_at (OMP_CLAUSE_LOCATION (c),
10690 "variable %qE is not an iteration "
10691 "of outermost loop %d, expected %qE",
10692 TREE_VALUE (decls), i + 1,
10693 gimplify_omp_ctxp->loop_iter_var[2 * i]);
10694 fail = true;
10695 failures++;
10697 else
10698 TREE_VALUE (decls)
10699 = gimplify_omp_ctxp->loop_iter_var[2 * i + 1];
10700 if (!fail && i != gimplify_omp_ctxp->loop_iter_var.length () / 2)
10702 error_at (OMP_CLAUSE_LOCATION (c),
10703 "number of variables in %<depend(sink)%> "
10704 "clause does not match number of "
10705 "iteration variables");
10706 failures++;
10708 sink_c = c;
10710 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
10711 && OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SOURCE)
10713 if (source_c)
10715 error_at (OMP_CLAUSE_LOCATION (c),
10716 "more than one %<depend(source)%> clause on an "
10717 "%<ordered%> construct");
10718 failures++;
10720 else
10721 source_c = c;
10724 if (source_c && sink_c)
10726 error_at (OMP_CLAUSE_LOCATION (source_c),
10727 "%<depend(source)%> clause specified together with "
10728 "%<depend(sink:)%> clauses on the same construct");
10729 failures++;
10732 if (failures)
10733 return gimple_build_nop ();
10734 return gimple_build_omp_ordered (body, OMP_ORDERED_CLAUSES (expr));
10737 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
10738 expression produces a value to be used as an operand inside a GIMPLE
10739 statement, the value will be stored back in *EXPR_P. This value will
10740 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
10741 an SSA_NAME. The corresponding sequence of GIMPLE statements is
10742 emitted in PRE_P and POST_P.
10744 Additionally, this process may overwrite parts of the input
10745 expression during gimplification. Ideally, it should be
10746 possible to do non-destructive gimplification.
10748 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
10749 the expression needs to evaluate to a value to be used as
10750 an operand in a GIMPLE statement, this value will be stored in
10751 *EXPR_P on exit. This happens when the caller specifies one
10752 of fb_lvalue or fb_rvalue fallback flags.
10754 PRE_P will contain the sequence of GIMPLE statements corresponding
10755 to the evaluation of EXPR and all the side-effects that must
10756 be executed before the main expression. On exit, the last
10757 statement of PRE_P is the core statement being gimplified. For
10758 instance, when gimplifying 'if (++a)' the last statement in
10759 PRE_P will be 'if (t.1)' where t.1 is the result of
10760 pre-incrementing 'a'.
10762 POST_P will contain the sequence of GIMPLE statements corresponding
10763 to the evaluation of all the side-effects that must be executed
10764 after the main expression. If this is NULL, the post
10765 side-effects are stored at the end of PRE_P.
10767 The reason why the output is split in two is to handle post
10768 side-effects explicitly. In some cases, an expression may have
10769 inner and outer post side-effects which need to be emitted in
10770 an order different from the one given by the recursive
10771 traversal. For instance, for the expression (*p--)++ the post
10772 side-effects of '--' must actually occur *after* the post
10773 side-effects of '++'. However, gimplification will first visit
10774 the inner expression, so if a separate POST sequence was not
10775 used, the resulting sequence would be:
10777 1 t.1 = *p
10778 2 p = p - 1
10779 3 t.2 = t.1 + 1
10780 4 *p = t.2
10782 However, the post-decrement operation in line #2 must not be
10783 evaluated until after the store to *p at line #4, so the
10784 correct sequence should be:
10786 1 t.1 = *p
10787 2 t.2 = t.1 + 1
10788 3 *p = t.2
10789 4 p = p - 1
10791 So, by specifying a separate post queue, it is possible
10792 to emit the post side-effects in the correct order.
10793 If POST_P is NULL, an internal queue will be used. Before
10794 returning to the caller, the sequence POST_P is appended to
10795 the main output sequence PRE_P.
10797 GIMPLE_TEST_F points to a function that takes a tree T and
10798 returns nonzero if T is in the GIMPLE form requested by the
10799 caller. The GIMPLE predicates are in gimple.c.
10801 FALLBACK tells the function what sort of a temporary we want if
10802 gimplification cannot produce an expression that complies with
10803 GIMPLE_TEST_F.
10805 fb_none means that no temporary should be generated
10806 fb_rvalue means that an rvalue is OK to generate
10807 fb_lvalue means that an lvalue is OK to generate
10808 fb_either means that either is OK, but an lvalue is preferable.
10809 fb_mayfail means that gimplification may fail (in which case
10810 GS_ERROR will be returned)
10812 The return value is either GS_ERROR or GS_ALL_DONE, since this
10813 function iterates until EXPR is completely gimplified or an error
10814 occurs. */
10816 enum gimplify_status
10817 gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
10818 bool (*gimple_test_f) (tree), fallback_t fallback)
10820 tree tmp;
10821 gimple_seq internal_pre = NULL;
10822 gimple_seq internal_post = NULL;
10823 tree save_expr;
10824 bool is_statement;
10825 location_t saved_location;
10826 enum gimplify_status ret;
10827 gimple_stmt_iterator pre_last_gsi, post_last_gsi;
10829 save_expr = *expr_p;
10830 if (save_expr == NULL_TREE)
10831 return GS_ALL_DONE;
10833 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
10834 is_statement = gimple_test_f == is_gimple_stmt;
10835 if (is_statement)
10836 gcc_assert (pre_p);
10838 /* Consistency checks. */
10839 if (gimple_test_f == is_gimple_reg)
10840 gcc_assert (fallback & (fb_rvalue | fb_lvalue));
10841 else if (gimple_test_f == is_gimple_val
10842 || gimple_test_f == is_gimple_call_addr
10843 || gimple_test_f == is_gimple_condexpr
10844 || gimple_test_f == is_gimple_mem_rhs
10845 || gimple_test_f == is_gimple_mem_rhs_or_call
10846 || gimple_test_f == is_gimple_reg_rhs
10847 || gimple_test_f == is_gimple_reg_rhs_or_call
10848 || gimple_test_f == is_gimple_asm_val
10849 || gimple_test_f == is_gimple_mem_ref_addr)
10850 gcc_assert (fallback & fb_rvalue);
10851 else if (gimple_test_f == is_gimple_min_lval
10852 || gimple_test_f == is_gimple_lvalue)
10853 gcc_assert (fallback & fb_lvalue);
10854 else if (gimple_test_f == is_gimple_addressable)
10855 gcc_assert (fallback & fb_either);
10856 else if (gimple_test_f == is_gimple_stmt)
10857 gcc_assert (fallback == fb_none);
10858 else
10860 /* We should have recognized the GIMPLE_TEST_F predicate to
10861 know what kind of fallback to use in case a temporary is
10862 needed to hold the value or address of *EXPR_P. */
10863 gcc_unreachable ();
10866 /* We used to check the predicate here and return immediately if it
10867 succeeds. This is wrong; the design is for gimplification to be
10868 idempotent, and for the predicates to only test for valid forms, not
10869 whether they are fully simplified. */
10870 if (pre_p == NULL)
10871 pre_p = &internal_pre;
10873 if (post_p == NULL)
10874 post_p = &internal_post;
10876 /* Remember the last statements added to PRE_P and POST_P. Every
10877 new statement added by the gimplification helpers needs to be
10878 annotated with location information. To centralize the
10879 responsibility, we remember the last statement that had been
10880 added to both queues before gimplifying *EXPR_P. If
10881 gimplification produces new statements in PRE_P and POST_P, those
10882 statements will be annotated with the same location information
10883 as *EXPR_P. */
10884 pre_last_gsi = gsi_last (*pre_p);
10885 post_last_gsi = gsi_last (*post_p);
10887 saved_location = input_location;
10888 if (save_expr != error_mark_node
10889 && EXPR_HAS_LOCATION (*expr_p))
10890 input_location = EXPR_LOCATION (*expr_p);
10892 /* Loop over the specific gimplifiers until the toplevel node
10893 remains the same. */
10896 /* Strip away as many useless type conversions as possible
10897 at the toplevel. */
10898 STRIP_USELESS_TYPE_CONVERSION (*expr_p);
10900 /* Remember the expr. */
10901 save_expr = *expr_p;
10903 /* Die, die, die, my darling. */
10904 if (save_expr == error_mark_node
10905 || (TREE_TYPE (save_expr)
10906 && TREE_TYPE (save_expr) == error_mark_node))
10908 ret = GS_ERROR;
10909 break;
10912 /* Do any language-specific gimplification. */
10913 ret = ((enum gimplify_status)
10914 lang_hooks.gimplify_expr (expr_p, pre_p, post_p));
10915 if (ret == GS_OK)
10917 if (*expr_p == NULL_TREE)
10918 break;
10919 if (*expr_p != save_expr)
10920 continue;
10922 else if (ret != GS_UNHANDLED)
10923 break;
10925 /* Make sure that all the cases set 'ret' appropriately. */
10926 ret = GS_UNHANDLED;
10927 switch (TREE_CODE (*expr_p))
10929 /* First deal with the special cases. */
10931 case POSTINCREMENT_EXPR:
10932 case POSTDECREMENT_EXPR:
10933 case PREINCREMENT_EXPR:
10934 case PREDECREMENT_EXPR:
10935 ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
10936 fallback != fb_none,
10937 TREE_TYPE (*expr_p));
10938 break;
10940 case VIEW_CONVERT_EXPR:
10941 if (is_gimple_reg_type (TREE_TYPE (*expr_p))
10942 && is_gimple_reg_type (TREE_TYPE (TREE_OPERAND (*expr_p, 0))))
10944 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
10945 post_p, is_gimple_val, fb_rvalue);
10946 recalculate_side_effects (*expr_p);
10947 break;
10949 /* Fallthru. */
10951 case ARRAY_REF:
10952 case ARRAY_RANGE_REF:
10953 case REALPART_EXPR:
10954 case IMAGPART_EXPR:
10955 case COMPONENT_REF:
10956 ret = gimplify_compound_lval (expr_p, pre_p, post_p,
10957 fallback ? fallback : fb_rvalue);
10958 break;
10960 case COND_EXPR:
10961 ret = gimplify_cond_expr (expr_p, pre_p, fallback);
10963 /* C99 code may assign to an array in a structure value of a
10964 conditional expression, and this has undefined behavior
10965 only on execution, so create a temporary if an lvalue is
10966 required. */
10967 if (fallback == fb_lvalue)
10969 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p, false);
10970 mark_addressable (*expr_p);
10971 ret = GS_OK;
10973 break;
10975 case CALL_EXPR:
10976 ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
10978 /* C99 code may assign to an array in a structure returned
10979 from a function, and this has undefined behavior only on
10980 execution, so create a temporary if an lvalue is
10981 required. */
10982 if (fallback == fb_lvalue)
10984 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p, false);
10985 mark_addressable (*expr_p);
10986 ret = GS_OK;
10988 break;
10990 case TREE_LIST:
10991 gcc_unreachable ();
10993 case COMPOUND_EXPR:
10994 ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
10995 break;
10997 case COMPOUND_LITERAL_EXPR:
10998 ret = gimplify_compound_literal_expr (expr_p, pre_p,
10999 gimple_test_f, fallback);
11000 break;
11002 case MODIFY_EXPR:
11003 case INIT_EXPR:
11004 ret = gimplify_modify_expr (expr_p, pre_p, post_p,
11005 fallback != fb_none);
11006 break;
11008 case TRUTH_ANDIF_EXPR:
11009 case TRUTH_ORIF_EXPR:
11011 /* Preserve the original type of the expression and the
11012 source location of the outer expression. */
11013 tree org_type = TREE_TYPE (*expr_p);
11014 *expr_p = gimple_boolify (*expr_p);
11015 *expr_p = build3_loc (input_location, COND_EXPR,
11016 org_type, *expr_p,
11017 fold_convert_loc
11018 (input_location,
11019 org_type, boolean_true_node),
11020 fold_convert_loc
11021 (input_location,
11022 org_type, boolean_false_node));
11023 ret = GS_OK;
11024 break;
11027 case TRUTH_NOT_EXPR:
11029 tree type = TREE_TYPE (*expr_p);
11030 /* The parsers are careful to generate TRUTH_NOT_EXPR
11031 only with operands that are always zero or one.
11032 We do not fold here but handle the only interesting case
11033 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
11034 *expr_p = gimple_boolify (*expr_p);
11035 if (TYPE_PRECISION (TREE_TYPE (*expr_p)) == 1)
11036 *expr_p = build1_loc (input_location, BIT_NOT_EXPR,
11037 TREE_TYPE (*expr_p),
11038 TREE_OPERAND (*expr_p, 0));
11039 else
11040 *expr_p = build2_loc (input_location, BIT_XOR_EXPR,
11041 TREE_TYPE (*expr_p),
11042 TREE_OPERAND (*expr_p, 0),
11043 build_int_cst (TREE_TYPE (*expr_p), 1));
11044 if (!useless_type_conversion_p (type, TREE_TYPE (*expr_p)))
11045 *expr_p = fold_convert_loc (input_location, type, *expr_p);
11046 ret = GS_OK;
11047 break;
11050 case ADDR_EXPR:
11051 ret = gimplify_addr_expr (expr_p, pre_p, post_p);
11052 break;
11054 case ANNOTATE_EXPR:
11056 tree cond = TREE_OPERAND (*expr_p, 0);
11057 tree kind = TREE_OPERAND (*expr_p, 1);
11058 tree type = TREE_TYPE (cond);
11059 if (!INTEGRAL_TYPE_P (type))
11061 *expr_p = cond;
11062 ret = GS_OK;
11063 break;
11065 tree tmp = create_tmp_var (type);
11066 gimplify_arg (&cond, pre_p, EXPR_LOCATION (*expr_p));
11067 gcall *call
11068 = gimple_build_call_internal (IFN_ANNOTATE, 2, cond, kind);
11069 gimple_call_set_lhs (call, tmp);
11070 gimplify_seq_add_stmt (pre_p, call);
11071 *expr_p = tmp;
11072 ret = GS_ALL_DONE;
11073 break;
11076 case VA_ARG_EXPR:
11077 ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
11078 break;
11080 CASE_CONVERT:
11081 if (IS_EMPTY_STMT (*expr_p))
11083 ret = GS_ALL_DONE;
11084 break;
11087 if (VOID_TYPE_P (TREE_TYPE (*expr_p))
11088 || fallback == fb_none)
11090 /* Just strip a conversion to void (or in void context) and
11091 try again. */
11092 *expr_p = TREE_OPERAND (*expr_p, 0);
11093 ret = GS_OK;
11094 break;
11097 ret = gimplify_conversion (expr_p);
11098 if (ret == GS_ERROR)
11099 break;
11100 if (*expr_p != save_expr)
11101 break;
11102 /* FALLTHRU */
11104 case FIX_TRUNC_EXPR:
11105 /* unary_expr: ... | '(' cast ')' val | ... */
11106 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
11107 is_gimple_val, fb_rvalue);
11108 recalculate_side_effects (*expr_p);
11109 break;
11111 case INDIRECT_REF:
11113 bool volatilep = TREE_THIS_VOLATILE (*expr_p);
11114 bool notrap = TREE_THIS_NOTRAP (*expr_p);
11115 tree saved_ptr_type = TREE_TYPE (TREE_OPERAND (*expr_p, 0));
11117 *expr_p = fold_indirect_ref_loc (input_location, *expr_p);
11118 if (*expr_p != save_expr)
11120 ret = GS_OK;
11121 break;
11124 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
11125 is_gimple_reg, fb_rvalue);
11126 if (ret == GS_ERROR)
11127 break;
11129 recalculate_side_effects (*expr_p);
11130 *expr_p = fold_build2_loc (input_location, MEM_REF,
11131 TREE_TYPE (*expr_p),
11132 TREE_OPERAND (*expr_p, 0),
11133 build_int_cst (saved_ptr_type, 0));
11134 TREE_THIS_VOLATILE (*expr_p) = volatilep;
11135 TREE_THIS_NOTRAP (*expr_p) = notrap;
11136 ret = GS_OK;
11137 break;
11140 /* We arrive here through the various re-gimplifcation paths. */
11141 case MEM_REF:
11142 /* First try re-folding the whole thing. */
11143 tmp = fold_binary (MEM_REF, TREE_TYPE (*expr_p),
11144 TREE_OPERAND (*expr_p, 0),
11145 TREE_OPERAND (*expr_p, 1));
11146 if (tmp)
11148 REF_REVERSE_STORAGE_ORDER (tmp)
11149 = REF_REVERSE_STORAGE_ORDER (*expr_p);
11150 *expr_p = tmp;
11151 recalculate_side_effects (*expr_p);
11152 ret = GS_OK;
11153 break;
11155 /* Avoid re-gimplifying the address operand if it is already
11156 in suitable form. Re-gimplifying would mark the address
11157 operand addressable. Always gimplify when not in SSA form
11158 as we still may have to gimplify decls with value-exprs. */
11159 if (!gimplify_ctxp || !gimple_in_ssa_p (cfun)
11160 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p, 0)))
11162 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
11163 is_gimple_mem_ref_addr, fb_rvalue);
11164 if (ret == GS_ERROR)
11165 break;
11167 recalculate_side_effects (*expr_p);
11168 ret = GS_ALL_DONE;
11169 break;
11171 /* Constants need not be gimplified. */
11172 case INTEGER_CST:
11173 case REAL_CST:
11174 case FIXED_CST:
11175 case STRING_CST:
11176 case COMPLEX_CST:
11177 case VECTOR_CST:
11178 /* Drop the overflow flag on constants, we do not want
11179 that in the GIMPLE IL. */
11180 if (TREE_OVERFLOW_P (*expr_p))
11181 *expr_p = drop_tree_overflow (*expr_p);
11182 ret = GS_ALL_DONE;
11183 break;
11185 case CONST_DECL:
11186 /* If we require an lvalue, such as for ADDR_EXPR, retain the
11187 CONST_DECL node. Otherwise the decl is replaceable by its
11188 value. */
11189 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
11190 if (fallback & fb_lvalue)
11191 ret = GS_ALL_DONE;
11192 else
11194 *expr_p = DECL_INITIAL (*expr_p);
11195 ret = GS_OK;
11197 break;
11199 case DECL_EXPR:
11200 ret = gimplify_decl_expr (expr_p, pre_p);
11201 break;
11203 case BIND_EXPR:
11204 ret = gimplify_bind_expr (expr_p, pre_p);
11205 break;
11207 case LOOP_EXPR:
11208 ret = gimplify_loop_expr (expr_p, pre_p);
11209 break;
11211 case SWITCH_EXPR:
11212 ret = gimplify_switch_expr (expr_p, pre_p);
11213 break;
11215 case EXIT_EXPR:
11216 ret = gimplify_exit_expr (expr_p);
11217 break;
11219 case GOTO_EXPR:
11220 /* If the target is not LABEL, then it is a computed jump
11221 and the target needs to be gimplified. */
11222 if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
11224 ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
11225 NULL, is_gimple_val, fb_rvalue);
11226 if (ret == GS_ERROR)
11227 break;
11229 gimplify_seq_add_stmt (pre_p,
11230 gimple_build_goto (GOTO_DESTINATION (*expr_p)));
11231 ret = GS_ALL_DONE;
11232 break;
11234 case PREDICT_EXPR:
11235 gimplify_seq_add_stmt (pre_p,
11236 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p),
11237 PREDICT_EXPR_OUTCOME (*expr_p)));
11238 ret = GS_ALL_DONE;
11239 break;
11241 case LABEL_EXPR:
11242 ret = gimplify_label_expr (expr_p, pre_p);
11243 break;
11245 case CASE_LABEL_EXPR:
11246 ret = gimplify_case_label_expr (expr_p, pre_p);
11247 break;
11249 case RETURN_EXPR:
11250 ret = gimplify_return_expr (*expr_p, pre_p);
11251 break;
11253 case CONSTRUCTOR:
11254 /* Don't reduce this in place; let gimplify_init_constructor work its
11255 magic. Buf if we're just elaborating this for side effects, just
11256 gimplify any element that has side-effects. */
11257 if (fallback == fb_none)
11259 unsigned HOST_WIDE_INT ix;
11260 tree val;
11261 tree temp = NULL_TREE;
11262 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p), ix, val)
11263 if (TREE_SIDE_EFFECTS (val))
11264 append_to_statement_list (val, &temp);
11266 *expr_p = temp;
11267 ret = temp ? GS_OK : GS_ALL_DONE;
11269 /* C99 code may assign to an array in a constructed
11270 structure or union, and this has undefined behavior only
11271 on execution, so create a temporary if an lvalue is
11272 required. */
11273 else if (fallback == fb_lvalue)
11275 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p, false);
11276 mark_addressable (*expr_p);
11277 ret = GS_OK;
11279 else
11280 ret = GS_ALL_DONE;
11281 break;
11283 /* The following are special cases that are not handled by the
11284 original GIMPLE grammar. */
11286 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
11287 eliminated. */
11288 case SAVE_EXPR:
11289 ret = gimplify_save_expr (expr_p, pre_p, post_p);
11290 break;
11292 case BIT_FIELD_REF:
11293 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11294 post_p, is_gimple_lvalue, fb_either);
11295 recalculate_side_effects (*expr_p);
11296 break;
11298 case TARGET_MEM_REF:
11300 enum gimplify_status r0 = GS_ALL_DONE, r1 = GS_ALL_DONE;
11302 if (TMR_BASE (*expr_p))
11303 r0 = gimplify_expr (&TMR_BASE (*expr_p), pre_p,
11304 post_p, is_gimple_mem_ref_addr, fb_either);
11305 if (TMR_INDEX (*expr_p))
11306 r1 = gimplify_expr (&TMR_INDEX (*expr_p), pre_p,
11307 post_p, is_gimple_val, fb_rvalue);
11308 if (TMR_INDEX2 (*expr_p))
11309 r1 = gimplify_expr (&TMR_INDEX2 (*expr_p), pre_p,
11310 post_p, is_gimple_val, fb_rvalue);
11311 /* TMR_STEP and TMR_OFFSET are always integer constants. */
11312 ret = MIN (r0, r1);
11314 break;
11316 case NON_LVALUE_EXPR:
11317 /* This should have been stripped above. */
11318 gcc_unreachable ();
11320 case ASM_EXPR:
11321 ret = gimplify_asm_expr (expr_p, pre_p, post_p);
11322 break;
11324 case TRY_FINALLY_EXPR:
11325 case TRY_CATCH_EXPR:
11327 gimple_seq eval, cleanup;
11328 gtry *try_;
11330 /* Calls to destructors are generated automatically in FINALLY/CATCH
11331 block. They should have location as UNKNOWN_LOCATION. However,
11332 gimplify_call_expr will reset these call stmts to input_location
11333 if it finds stmt's location is unknown. To prevent resetting for
11334 destructors, we set the input_location to unknown.
11335 Note that this only affects the destructor calls in FINALLY/CATCH
11336 block, and will automatically reset to its original value by the
11337 end of gimplify_expr. */
11338 input_location = UNKNOWN_LOCATION;
11339 eval = cleanup = NULL;
11340 gimplify_and_add (TREE_OPERAND (*expr_p, 0), &eval);
11341 gimplify_and_add (TREE_OPERAND (*expr_p, 1), &cleanup);
11342 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
11343 if (gimple_seq_empty_p (cleanup))
11345 gimple_seq_add_seq (pre_p, eval);
11346 ret = GS_ALL_DONE;
11347 break;
11349 try_ = gimple_build_try (eval, cleanup,
11350 TREE_CODE (*expr_p) == TRY_FINALLY_EXPR
11351 ? GIMPLE_TRY_FINALLY
11352 : GIMPLE_TRY_CATCH);
11353 if (EXPR_HAS_LOCATION (save_expr))
11354 gimple_set_location (try_, EXPR_LOCATION (save_expr));
11355 else if (LOCATION_LOCUS (saved_location) != UNKNOWN_LOCATION)
11356 gimple_set_location (try_, saved_location);
11357 if (TREE_CODE (*expr_p) == TRY_CATCH_EXPR)
11358 gimple_try_set_catch_is_cleanup (try_,
11359 TRY_CATCH_IS_CLEANUP (*expr_p));
11360 gimplify_seq_add_stmt (pre_p, try_);
11361 ret = GS_ALL_DONE;
11362 break;
11365 case CLEANUP_POINT_EXPR:
11366 ret = gimplify_cleanup_point_expr (expr_p, pre_p);
11367 break;
11369 case TARGET_EXPR:
11370 ret = gimplify_target_expr (expr_p, pre_p, post_p);
11371 break;
11373 case CATCH_EXPR:
11375 gimple *c;
11376 gimple_seq handler = NULL;
11377 gimplify_and_add (CATCH_BODY (*expr_p), &handler);
11378 c = gimple_build_catch (CATCH_TYPES (*expr_p), handler);
11379 gimplify_seq_add_stmt (pre_p, c);
11380 ret = GS_ALL_DONE;
11381 break;
11384 case EH_FILTER_EXPR:
11386 gimple *ehf;
11387 gimple_seq failure = NULL;
11389 gimplify_and_add (EH_FILTER_FAILURE (*expr_p), &failure);
11390 ehf = gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p), failure);
11391 gimple_set_no_warning (ehf, TREE_NO_WARNING (*expr_p));
11392 gimplify_seq_add_stmt (pre_p, ehf);
11393 ret = GS_ALL_DONE;
11394 break;
11397 case OBJ_TYPE_REF:
11399 enum gimplify_status r0, r1;
11400 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p,
11401 post_p, is_gimple_val, fb_rvalue);
11402 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p,
11403 post_p, is_gimple_val, fb_rvalue);
11404 TREE_SIDE_EFFECTS (*expr_p) = 0;
11405 ret = MIN (r0, r1);
11407 break;
11409 case LABEL_DECL:
11410 /* We get here when taking the address of a label. We mark
11411 the label as "forced"; meaning it can never be removed and
11412 it is a potential target for any computed goto. */
11413 FORCED_LABEL (*expr_p) = 1;
11414 ret = GS_ALL_DONE;
11415 break;
11417 case STATEMENT_LIST:
11418 ret = gimplify_statement_list (expr_p, pre_p);
11419 break;
11421 case WITH_SIZE_EXPR:
11423 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11424 post_p == &internal_post ? NULL : post_p,
11425 gimple_test_f, fallback);
11426 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
11427 is_gimple_val, fb_rvalue);
11428 ret = GS_ALL_DONE;
11430 break;
11432 case VAR_DECL:
11433 case PARM_DECL:
11434 ret = gimplify_var_or_parm_decl (expr_p);
11435 break;
11437 case RESULT_DECL:
11438 /* When within an OMP context, notice uses of variables. */
11439 if (gimplify_omp_ctxp)
11440 omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
11441 ret = GS_ALL_DONE;
11442 break;
11444 case SSA_NAME:
11445 /* Allow callbacks into the gimplifier during optimization. */
11446 ret = GS_ALL_DONE;
11447 break;
11449 case OMP_PARALLEL:
11450 gimplify_omp_parallel (expr_p, pre_p);
11451 ret = GS_ALL_DONE;
11452 break;
11454 case OMP_TASK:
11455 gimplify_omp_task (expr_p, pre_p);
11456 ret = GS_ALL_DONE;
11457 break;
11459 case OMP_FOR:
11460 case OMP_SIMD:
11461 case CILK_SIMD:
11462 case CILK_FOR:
11463 case OMP_DISTRIBUTE:
11464 case OMP_TASKLOOP:
11465 case OACC_LOOP:
11466 ret = gimplify_omp_for (expr_p, pre_p);
11467 break;
11469 case OACC_CACHE:
11470 gimplify_oacc_cache (expr_p, pre_p);
11471 ret = GS_ALL_DONE;
11472 break;
11474 case OACC_DECLARE:
11475 gimplify_oacc_declare (expr_p, pre_p);
11476 ret = GS_ALL_DONE;
11477 break;
11479 case OACC_HOST_DATA:
11480 case OACC_DATA:
11481 case OACC_KERNELS:
11482 case OACC_PARALLEL:
11483 case OMP_SECTIONS:
11484 case OMP_SINGLE:
11485 case OMP_TARGET:
11486 case OMP_TARGET_DATA:
11487 case OMP_TEAMS:
11488 gimplify_omp_workshare (expr_p, pre_p);
11489 ret = GS_ALL_DONE;
11490 break;
11492 case OACC_ENTER_DATA:
11493 case OACC_EXIT_DATA:
11494 case OACC_UPDATE:
11495 case OMP_TARGET_UPDATE:
11496 case OMP_TARGET_ENTER_DATA:
11497 case OMP_TARGET_EXIT_DATA:
11498 gimplify_omp_target_update (expr_p, pre_p);
11499 ret = GS_ALL_DONE;
11500 break;
11502 case OMP_SECTION:
11503 case OMP_MASTER:
11504 case OMP_TASKGROUP:
11505 case OMP_ORDERED:
11506 case OMP_CRITICAL:
11508 gimple_seq body = NULL;
11509 gimple *g;
11511 gimplify_and_add (OMP_BODY (*expr_p), &body);
11512 switch (TREE_CODE (*expr_p))
11514 case OMP_SECTION:
11515 g = gimple_build_omp_section (body);
11516 break;
11517 case OMP_MASTER:
11518 g = gimple_build_omp_master (body);
11519 break;
11520 case OMP_TASKGROUP:
11522 gimple_seq cleanup = NULL;
11523 tree fn
11524 = builtin_decl_explicit (BUILT_IN_GOMP_TASKGROUP_END);
11525 g = gimple_build_call (fn, 0);
11526 gimple_seq_add_stmt (&cleanup, g);
11527 g = gimple_build_try (body, cleanup, GIMPLE_TRY_FINALLY);
11528 body = NULL;
11529 gimple_seq_add_stmt (&body, g);
11530 g = gimple_build_omp_taskgroup (body);
11532 break;
11533 case OMP_ORDERED:
11534 g = gimplify_omp_ordered (*expr_p, body);
11535 break;
11536 case OMP_CRITICAL:
11537 gimplify_scan_omp_clauses (&OMP_CRITICAL_CLAUSES (*expr_p),
11538 pre_p, ORT_WORKSHARE, OMP_CRITICAL);
11539 gimplify_adjust_omp_clauses (pre_p, body,
11540 &OMP_CRITICAL_CLAUSES (*expr_p),
11541 OMP_CRITICAL);
11542 g = gimple_build_omp_critical (body,
11543 OMP_CRITICAL_NAME (*expr_p),
11544 OMP_CRITICAL_CLAUSES (*expr_p));
11545 break;
11546 default:
11547 gcc_unreachable ();
11549 gimplify_seq_add_stmt (pre_p, g);
11550 ret = GS_ALL_DONE;
11551 break;
11554 case OMP_ATOMIC:
11555 case OMP_ATOMIC_READ:
11556 case OMP_ATOMIC_CAPTURE_OLD:
11557 case OMP_ATOMIC_CAPTURE_NEW:
11558 ret = gimplify_omp_atomic (expr_p, pre_p);
11559 break;
11561 case TRANSACTION_EXPR:
11562 ret = gimplify_transaction (expr_p, pre_p);
11563 break;
11565 case TRUTH_AND_EXPR:
11566 case TRUTH_OR_EXPR:
11567 case TRUTH_XOR_EXPR:
11569 tree orig_type = TREE_TYPE (*expr_p);
11570 tree new_type, xop0, xop1;
11571 *expr_p = gimple_boolify (*expr_p);
11572 new_type = TREE_TYPE (*expr_p);
11573 if (!useless_type_conversion_p (orig_type, new_type))
11575 *expr_p = fold_convert_loc (input_location, orig_type, *expr_p);
11576 ret = GS_OK;
11577 break;
11580 /* Boolified binary truth expressions are semantically equivalent
11581 to bitwise binary expressions. Canonicalize them to the
11582 bitwise variant. */
11583 switch (TREE_CODE (*expr_p))
11585 case TRUTH_AND_EXPR:
11586 TREE_SET_CODE (*expr_p, BIT_AND_EXPR);
11587 break;
11588 case TRUTH_OR_EXPR:
11589 TREE_SET_CODE (*expr_p, BIT_IOR_EXPR);
11590 break;
11591 case TRUTH_XOR_EXPR:
11592 TREE_SET_CODE (*expr_p, BIT_XOR_EXPR);
11593 break;
11594 default:
11595 break;
11597 /* Now make sure that operands have compatible type to
11598 expression's new_type. */
11599 xop0 = TREE_OPERAND (*expr_p, 0);
11600 xop1 = TREE_OPERAND (*expr_p, 1);
11601 if (!useless_type_conversion_p (new_type, TREE_TYPE (xop0)))
11602 TREE_OPERAND (*expr_p, 0) = fold_convert_loc (input_location,
11603 new_type,
11604 xop0);
11605 if (!useless_type_conversion_p (new_type, TREE_TYPE (xop1)))
11606 TREE_OPERAND (*expr_p, 1) = fold_convert_loc (input_location,
11607 new_type,
11608 xop1);
11609 /* Continue classified as tcc_binary. */
11610 goto expr_2;
11613 case VEC_COND_EXPR:
11615 enum gimplify_status r0, r1, r2;
11617 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11618 post_p, is_gimple_condexpr, fb_rvalue);
11619 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
11620 post_p, is_gimple_val, fb_rvalue);
11621 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
11622 post_p, is_gimple_val, fb_rvalue);
11624 ret = MIN (MIN (r0, r1), r2);
11625 recalculate_side_effects (*expr_p);
11627 break;
11629 case FMA_EXPR:
11630 case VEC_PERM_EXPR:
11631 /* Classified as tcc_expression. */
11632 goto expr_3;
11634 case BIT_INSERT_EXPR:
11635 /* Argument 3 is a constant. */
11636 goto expr_2;
11638 case POINTER_PLUS_EXPR:
11640 enum gimplify_status r0, r1;
11641 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11642 post_p, is_gimple_val, fb_rvalue);
11643 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
11644 post_p, is_gimple_val, fb_rvalue);
11645 recalculate_side_effects (*expr_p);
11646 ret = MIN (r0, r1);
11647 break;
11650 case CILK_SYNC_STMT:
11652 if (!fn_contains_cilk_spawn_p (cfun))
11654 error_at (EXPR_LOCATION (*expr_p),
11655 "expected %<_Cilk_spawn%> before %<_Cilk_sync%>");
11656 ret = GS_ERROR;
11658 else
11660 gimplify_cilk_sync (expr_p, pre_p);
11661 ret = GS_ALL_DONE;
11663 break;
11666 default:
11667 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
11669 case tcc_comparison:
11670 /* Handle comparison of objects of non scalar mode aggregates
11671 with a call to memcmp. It would be nice to only have to do
11672 this for variable-sized objects, but then we'd have to allow
11673 the same nest of reference nodes we allow for MODIFY_EXPR and
11674 that's too complex.
11676 Compare scalar mode aggregates as scalar mode values. Using
11677 memcmp for them would be very inefficient at best, and is
11678 plain wrong if bitfields are involved. */
11680 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
11682 /* Vector comparisons need no boolification. */
11683 if (TREE_CODE (type) == VECTOR_TYPE)
11684 goto expr_2;
11685 else if (!AGGREGATE_TYPE_P (type))
11687 tree org_type = TREE_TYPE (*expr_p);
11688 *expr_p = gimple_boolify (*expr_p);
11689 if (!useless_type_conversion_p (org_type,
11690 TREE_TYPE (*expr_p)))
11692 *expr_p = fold_convert_loc (input_location,
11693 org_type, *expr_p);
11694 ret = GS_OK;
11696 else
11697 goto expr_2;
11699 else if (TYPE_MODE (type) != BLKmode)
11700 ret = gimplify_scalar_mode_aggregate_compare (expr_p);
11701 else
11702 ret = gimplify_variable_sized_compare (expr_p);
11704 break;
11707 /* If *EXPR_P does not need to be special-cased, handle it
11708 according to its class. */
11709 case tcc_unary:
11710 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11711 post_p, is_gimple_val, fb_rvalue);
11712 break;
11714 case tcc_binary:
11715 expr_2:
11717 enum gimplify_status r0, r1;
11719 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11720 post_p, is_gimple_val, fb_rvalue);
11721 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
11722 post_p, is_gimple_val, fb_rvalue);
11724 ret = MIN (r0, r1);
11725 break;
11728 expr_3:
11730 enum gimplify_status r0, r1, r2;
11732 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11733 post_p, is_gimple_val, fb_rvalue);
11734 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
11735 post_p, is_gimple_val, fb_rvalue);
11736 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
11737 post_p, is_gimple_val, fb_rvalue);
11739 ret = MIN (MIN (r0, r1), r2);
11740 break;
11743 case tcc_declaration:
11744 case tcc_constant:
11745 ret = GS_ALL_DONE;
11746 goto dont_recalculate;
11748 default:
11749 gcc_unreachable ();
11752 recalculate_side_effects (*expr_p);
11754 dont_recalculate:
11755 break;
11758 gcc_assert (*expr_p || ret != GS_OK);
11760 while (ret == GS_OK);
11762 /* If we encountered an error_mark somewhere nested inside, either
11763 stub out the statement or propagate the error back out. */
11764 if (ret == GS_ERROR)
11766 if (is_statement)
11767 *expr_p = NULL;
11768 goto out;
11771 /* This was only valid as a return value from the langhook, which
11772 we handled. Make sure it doesn't escape from any other context. */
11773 gcc_assert (ret != GS_UNHANDLED);
11775 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
11777 /* We aren't looking for a value, and we don't have a valid
11778 statement. If it doesn't have side-effects, throw it away. */
11779 if (!TREE_SIDE_EFFECTS (*expr_p))
11780 *expr_p = NULL;
11781 else if (!TREE_THIS_VOLATILE (*expr_p))
11783 /* This is probably a _REF that contains something nested that
11784 has side effects. Recurse through the operands to find it. */
11785 enum tree_code code = TREE_CODE (*expr_p);
11787 switch (code)
11789 case COMPONENT_REF:
11790 case REALPART_EXPR:
11791 case IMAGPART_EXPR:
11792 case VIEW_CONVERT_EXPR:
11793 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
11794 gimple_test_f, fallback);
11795 break;
11797 case ARRAY_REF:
11798 case ARRAY_RANGE_REF:
11799 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
11800 gimple_test_f, fallback);
11801 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
11802 gimple_test_f, fallback);
11803 break;
11805 default:
11806 /* Anything else with side-effects must be converted to
11807 a valid statement before we get here. */
11808 gcc_unreachable ();
11811 *expr_p = NULL;
11813 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p))
11814 && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode)
11816 /* Historically, the compiler has treated a bare reference
11817 to a non-BLKmode volatile lvalue as forcing a load. */
11818 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
11820 /* Normally, we do not want to create a temporary for a
11821 TREE_ADDRESSABLE type because such a type should not be
11822 copied by bitwise-assignment. However, we make an
11823 exception here, as all we are doing here is ensuring that
11824 we read the bytes that make up the type. We use
11825 create_tmp_var_raw because create_tmp_var will abort when
11826 given a TREE_ADDRESSABLE type. */
11827 tree tmp = create_tmp_var_raw (type, "vol");
11828 gimple_add_tmp_var (tmp);
11829 gimplify_assign (tmp, *expr_p, pre_p);
11830 *expr_p = NULL;
11832 else
11833 /* We can't do anything useful with a volatile reference to
11834 an incomplete type, so just throw it away. Likewise for
11835 a BLKmode type, since any implicit inner load should
11836 already have been turned into an explicit one by the
11837 gimplification process. */
11838 *expr_p = NULL;
11841 /* If we are gimplifying at the statement level, we're done. Tack
11842 everything together and return. */
11843 if (fallback == fb_none || is_statement)
11845 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
11846 it out for GC to reclaim it. */
11847 *expr_p = NULL_TREE;
11849 if (!gimple_seq_empty_p (internal_pre)
11850 || !gimple_seq_empty_p (internal_post))
11852 gimplify_seq_add_seq (&internal_pre, internal_post);
11853 gimplify_seq_add_seq (pre_p, internal_pre);
11856 /* The result of gimplifying *EXPR_P is going to be the last few
11857 statements in *PRE_P and *POST_P. Add location information
11858 to all the statements that were added by the gimplification
11859 helpers. */
11860 if (!gimple_seq_empty_p (*pre_p))
11861 annotate_all_with_location_after (*pre_p, pre_last_gsi, input_location);
11863 if (!gimple_seq_empty_p (*post_p))
11864 annotate_all_with_location_after (*post_p, post_last_gsi,
11865 input_location);
11867 goto out;
11870 #ifdef ENABLE_GIMPLE_CHECKING
11871 if (*expr_p)
11873 enum tree_code code = TREE_CODE (*expr_p);
11874 /* These expressions should already be in gimple IR form. */
11875 gcc_assert (code != MODIFY_EXPR
11876 && code != ASM_EXPR
11877 && code != BIND_EXPR
11878 && code != CATCH_EXPR
11879 && (code != COND_EXPR || gimplify_ctxp->allow_rhs_cond_expr)
11880 && code != EH_FILTER_EXPR
11881 && code != GOTO_EXPR
11882 && code != LABEL_EXPR
11883 && code != LOOP_EXPR
11884 && code != SWITCH_EXPR
11885 && code != TRY_FINALLY_EXPR
11886 && code != OACC_PARALLEL
11887 && code != OACC_KERNELS
11888 && code != OACC_DATA
11889 && code != OACC_HOST_DATA
11890 && code != OACC_DECLARE
11891 && code != OACC_UPDATE
11892 && code != OACC_ENTER_DATA
11893 && code != OACC_EXIT_DATA
11894 && code != OACC_CACHE
11895 && code != OMP_CRITICAL
11896 && code != OMP_FOR
11897 && code != OACC_LOOP
11898 && code != OMP_MASTER
11899 && code != OMP_TASKGROUP
11900 && code != OMP_ORDERED
11901 && code != OMP_PARALLEL
11902 && code != OMP_SECTIONS
11903 && code != OMP_SECTION
11904 && code != OMP_SINGLE);
11906 #endif
11908 /* Otherwise we're gimplifying a subexpression, so the resulting
11909 value is interesting. If it's a valid operand that matches
11910 GIMPLE_TEST_F, we're done. Unless we are handling some
11911 post-effects internally; if that's the case, we need to copy into
11912 a temporary before adding the post-effects to POST_P. */
11913 if (gimple_seq_empty_p (internal_post) && (*gimple_test_f) (*expr_p))
11914 goto out;
11916 /* Otherwise, we need to create a new temporary for the gimplified
11917 expression. */
11919 /* We can't return an lvalue if we have an internal postqueue. The
11920 object the lvalue refers to would (probably) be modified by the
11921 postqueue; we need to copy the value out first, which means an
11922 rvalue. */
11923 if ((fallback & fb_lvalue)
11924 && gimple_seq_empty_p (internal_post)
11925 && is_gimple_addressable (*expr_p))
11927 /* An lvalue will do. Take the address of the expression, store it
11928 in a temporary, and replace the expression with an INDIRECT_REF of
11929 that temporary. */
11930 tmp = build_fold_addr_expr_loc (input_location, *expr_p);
11931 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
11932 *expr_p = build_simple_mem_ref (tmp);
11934 else if ((fallback & fb_rvalue) && is_gimple_reg_rhs_or_call (*expr_p))
11936 /* An rvalue will do. Assign the gimplified expression into a
11937 new temporary TMP and replace the original expression with
11938 TMP. First, make sure that the expression has a type so that
11939 it can be assigned into a temporary. */
11940 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
11941 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
11943 else
11945 #ifdef ENABLE_GIMPLE_CHECKING
11946 if (!(fallback & fb_mayfail))
11948 fprintf (stderr, "gimplification failed:\n");
11949 print_generic_expr (stderr, *expr_p, 0);
11950 debug_tree (*expr_p);
11951 internal_error ("gimplification failed");
11953 #endif
11954 gcc_assert (fallback & fb_mayfail);
11956 /* If this is an asm statement, and the user asked for the
11957 impossible, don't die. Fail and let gimplify_asm_expr
11958 issue an error. */
11959 ret = GS_ERROR;
11960 goto out;
11963 /* Make sure the temporary matches our predicate. */
11964 gcc_assert ((*gimple_test_f) (*expr_p));
11966 if (!gimple_seq_empty_p (internal_post))
11968 annotate_all_with_location (internal_post, input_location);
11969 gimplify_seq_add_seq (pre_p, internal_post);
11972 out:
11973 input_location = saved_location;
11974 return ret;
11977 /* Like gimplify_expr but make sure the gimplified result is not itself
11978 a SSA name (but a decl if it were). Temporaries required by
11979 evaluating *EXPR_P may be still SSA names. */
11981 static enum gimplify_status
11982 gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
11983 bool (*gimple_test_f) (tree), fallback_t fallback,
11984 bool allow_ssa)
11986 bool was_ssa_name_p = TREE_CODE (*expr_p) == SSA_NAME;
11987 enum gimplify_status ret = gimplify_expr (expr_p, pre_p, post_p,
11988 gimple_test_f, fallback);
11989 if (! allow_ssa
11990 && TREE_CODE (*expr_p) == SSA_NAME)
11992 tree name = *expr_p;
11993 if (was_ssa_name_p)
11994 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, NULL, false);
11995 else
11997 /* Avoid the extra copy if possible. */
11998 *expr_p = create_tmp_reg (TREE_TYPE (name));
11999 gimple_set_lhs (SSA_NAME_DEF_STMT (name), *expr_p);
12000 release_ssa_name (name);
12003 return ret;
12006 /* Look through TYPE for variable-sized objects and gimplify each such
12007 size that we find. Add to LIST_P any statements generated. */
12009 void
12010 gimplify_type_sizes (tree type, gimple_seq *list_p)
12012 tree field, t;
12014 if (type == NULL || type == error_mark_node)
12015 return;
12017 /* We first do the main variant, then copy into any other variants. */
12018 type = TYPE_MAIN_VARIANT (type);
12020 /* Avoid infinite recursion. */
12021 if (TYPE_SIZES_GIMPLIFIED (type))
12022 return;
12024 TYPE_SIZES_GIMPLIFIED (type) = 1;
12026 switch (TREE_CODE (type))
12028 case INTEGER_TYPE:
12029 case ENUMERAL_TYPE:
12030 case BOOLEAN_TYPE:
12031 case REAL_TYPE:
12032 case FIXED_POINT_TYPE:
12033 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
12034 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
12036 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
12038 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
12039 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
12041 break;
12043 case ARRAY_TYPE:
12044 /* These types may not have declarations, so handle them here. */
12045 gimplify_type_sizes (TREE_TYPE (type), list_p);
12046 gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
12047 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
12048 with assigned stack slots, for -O1+ -g they should be tracked
12049 by VTA. */
12050 if (!(TYPE_NAME (type)
12051 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12052 && DECL_IGNORED_P (TYPE_NAME (type)))
12053 && TYPE_DOMAIN (type)
12054 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type)))
12056 t = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
12057 if (t && VAR_P (t) && DECL_ARTIFICIAL (t))
12058 DECL_IGNORED_P (t) = 0;
12059 t = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
12060 if (t && VAR_P (t) && DECL_ARTIFICIAL (t))
12061 DECL_IGNORED_P (t) = 0;
12063 break;
12065 case RECORD_TYPE:
12066 case UNION_TYPE:
12067 case QUAL_UNION_TYPE:
12068 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
12069 if (TREE_CODE (field) == FIELD_DECL)
12071 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
12072 gimplify_one_sizepos (&DECL_SIZE (field), list_p);
12073 gimplify_one_sizepos (&DECL_SIZE_UNIT (field), list_p);
12074 gimplify_type_sizes (TREE_TYPE (field), list_p);
12076 break;
12078 case POINTER_TYPE:
12079 case REFERENCE_TYPE:
12080 /* We used to recurse on the pointed-to type here, which turned out to
12081 be incorrect because its definition might refer to variables not
12082 yet initialized at this point if a forward declaration is involved.
12084 It was actually useful for anonymous pointed-to types to ensure
12085 that the sizes evaluation dominates every possible later use of the
12086 values. Restricting to such types here would be safe since there
12087 is no possible forward declaration around, but would introduce an
12088 undesirable middle-end semantic to anonymity. We then defer to
12089 front-ends the responsibility of ensuring that the sizes are
12090 evaluated both early and late enough, e.g. by attaching artificial
12091 type declarations to the tree. */
12092 break;
12094 default:
12095 break;
12098 gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
12099 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
12101 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
12103 TYPE_SIZE (t) = TYPE_SIZE (type);
12104 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type);
12105 TYPE_SIZES_GIMPLIFIED (t) = 1;
12109 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
12110 a size or position, has had all of its SAVE_EXPRs evaluated.
12111 We add any required statements to *STMT_P. */
12113 void
12114 gimplify_one_sizepos (tree *expr_p, gimple_seq *stmt_p)
12116 tree expr = *expr_p;
12118 /* We don't do anything if the value isn't there, is constant, or contains
12119 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
12120 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
12121 will want to replace it with a new variable, but that will cause problems
12122 if this type is from outside the function. It's OK to have that here. */
12123 if (is_gimple_sizepos (expr))
12124 return;
12126 *expr_p = unshare_expr (expr);
12128 /* SSA names in decl/type fields are a bad idea - they'll get reclaimed
12129 if the def vanishes. */
12130 gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue, false);
12133 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
12134 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
12135 is true, also gimplify the parameters. */
12137 gbind *
12138 gimplify_body (tree fndecl, bool do_parms)
12140 location_t saved_location = input_location;
12141 gimple_seq parm_stmts, seq;
12142 gimple *outer_stmt;
12143 gbind *outer_bind;
12144 struct cgraph_node *cgn;
12146 timevar_push (TV_TREE_GIMPLIFY);
12148 init_tree_ssa (cfun);
12150 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
12151 gimplification. */
12152 default_rtl_profile ();
12154 gcc_assert (gimplify_ctxp == NULL);
12155 push_gimplify_context (true);
12157 if (flag_openacc || flag_openmp)
12159 gcc_assert (gimplify_omp_ctxp == NULL);
12160 if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (fndecl)))
12161 gimplify_omp_ctxp = new_omp_context (ORT_TARGET);
12164 /* Unshare most shared trees in the body and in that of any nested functions.
12165 It would seem we don't have to do this for nested functions because
12166 they are supposed to be output and then the outer function gimplified
12167 first, but the g++ front end doesn't always do it that way. */
12168 unshare_body (fndecl);
12169 unvisit_body (fndecl);
12171 cgn = cgraph_node::get (fndecl);
12172 if (cgn && cgn->origin)
12173 nonlocal_vlas = new hash_set<tree>;
12175 /* Make sure input_location isn't set to something weird. */
12176 input_location = DECL_SOURCE_LOCATION (fndecl);
12178 /* Resolve callee-copies. This has to be done before processing
12179 the body so that DECL_VALUE_EXPR gets processed correctly. */
12180 parm_stmts = do_parms ? gimplify_parameters () : NULL;
12182 /* Gimplify the function's body. */
12183 seq = NULL;
12184 gimplify_stmt (&DECL_SAVED_TREE (fndecl), &seq);
12185 outer_stmt = gimple_seq_first_stmt (seq);
12186 if (!outer_stmt)
12188 outer_stmt = gimple_build_nop ();
12189 gimplify_seq_add_stmt (&seq, outer_stmt);
12192 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
12193 not the case, wrap everything in a GIMPLE_BIND to make it so. */
12194 if (gimple_code (outer_stmt) == GIMPLE_BIND
12195 && gimple_seq_first (seq) == gimple_seq_last (seq))
12196 outer_bind = as_a <gbind *> (outer_stmt);
12197 else
12198 outer_bind = gimple_build_bind (NULL_TREE, seq, NULL);
12200 DECL_SAVED_TREE (fndecl) = NULL_TREE;
12202 /* If we had callee-copies statements, insert them at the beginning
12203 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
12204 if (!gimple_seq_empty_p (parm_stmts))
12206 tree parm;
12208 gimplify_seq_add_seq (&parm_stmts, gimple_bind_body (outer_bind));
12209 gimple_bind_set_body (outer_bind, parm_stmts);
12211 for (parm = DECL_ARGUMENTS (current_function_decl);
12212 parm; parm = DECL_CHAIN (parm))
12213 if (DECL_HAS_VALUE_EXPR_P (parm))
12215 DECL_HAS_VALUE_EXPR_P (parm) = 0;
12216 DECL_IGNORED_P (parm) = 0;
12220 if (nonlocal_vlas)
12222 if (nonlocal_vla_vars)
12224 /* tree-nested.c may later on call declare_vars (..., true);
12225 which relies on BLOCK_VARS chain to be the tail of the
12226 gimple_bind_vars chain. Ensure we don't violate that
12227 assumption. */
12228 if (gimple_bind_block (outer_bind)
12229 == DECL_INITIAL (current_function_decl))
12230 declare_vars (nonlocal_vla_vars, outer_bind, true);
12231 else
12232 BLOCK_VARS (DECL_INITIAL (current_function_decl))
12233 = chainon (BLOCK_VARS (DECL_INITIAL (current_function_decl)),
12234 nonlocal_vla_vars);
12235 nonlocal_vla_vars = NULL_TREE;
12237 delete nonlocal_vlas;
12238 nonlocal_vlas = NULL;
12241 if ((flag_openacc || flag_openmp || flag_openmp_simd)
12242 && gimplify_omp_ctxp)
12244 delete_omp_context (gimplify_omp_ctxp);
12245 gimplify_omp_ctxp = NULL;
12248 pop_gimplify_context (outer_bind);
12249 gcc_assert (gimplify_ctxp == NULL);
12251 if (flag_checking && !seen_error ())
12252 verify_gimple_in_seq (gimple_bind_body (outer_bind));
12254 timevar_pop (TV_TREE_GIMPLIFY);
12255 input_location = saved_location;
12257 return outer_bind;
12260 typedef char *char_p; /* For DEF_VEC_P. */
12262 /* Return whether we should exclude FNDECL from instrumentation. */
12264 static bool
12265 flag_instrument_functions_exclude_p (tree fndecl)
12267 vec<char_p> *v;
12269 v = (vec<char_p> *) flag_instrument_functions_exclude_functions;
12270 if (v && v->length () > 0)
12272 const char *name;
12273 int i;
12274 char *s;
12276 name = lang_hooks.decl_printable_name (fndecl, 0);
12277 FOR_EACH_VEC_ELT (*v, i, s)
12278 if (strstr (name, s) != NULL)
12279 return true;
12282 v = (vec<char_p> *) flag_instrument_functions_exclude_files;
12283 if (v && v->length () > 0)
12285 const char *name;
12286 int i;
12287 char *s;
12289 name = DECL_SOURCE_FILE (fndecl);
12290 FOR_EACH_VEC_ELT (*v, i, s)
12291 if (strstr (name, s) != NULL)
12292 return true;
12295 return false;
12298 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
12299 node for the function we want to gimplify.
12301 Return the sequence of GIMPLE statements corresponding to the body
12302 of FNDECL. */
12304 void
12305 gimplify_function_tree (tree fndecl)
12307 tree parm, ret;
12308 gimple_seq seq;
12309 gbind *bind;
12311 gcc_assert (!gimple_body (fndecl));
12313 if (DECL_STRUCT_FUNCTION (fndecl))
12314 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
12315 else
12316 push_struct_function (fndecl);
12318 /* Tentatively set PROP_gimple_lva here, and reset it in gimplify_va_arg_expr
12319 if necessary. */
12320 cfun->curr_properties |= PROP_gimple_lva;
12322 for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = DECL_CHAIN (parm))
12324 /* Preliminarily mark non-addressed complex variables as eligible
12325 for promotion to gimple registers. We'll transform their uses
12326 as we find them. */
12327 if ((TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
12328 || TREE_CODE (TREE_TYPE (parm)) == VECTOR_TYPE)
12329 && !TREE_THIS_VOLATILE (parm)
12330 && !needs_to_live_in_memory (parm))
12331 DECL_GIMPLE_REG_P (parm) = 1;
12334 ret = DECL_RESULT (fndecl);
12335 if ((TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE
12336 || TREE_CODE (TREE_TYPE (ret)) == VECTOR_TYPE)
12337 && !needs_to_live_in_memory (ret))
12338 DECL_GIMPLE_REG_P (ret) = 1;
12340 bind = gimplify_body (fndecl, true);
12342 /* The tree body of the function is no longer needed, replace it
12343 with the new GIMPLE body. */
12344 seq = NULL;
12345 gimple_seq_add_stmt (&seq, bind);
12346 gimple_set_body (fndecl, seq);
12348 /* If we're instrumenting function entry/exit, then prepend the call to
12349 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
12350 catch the exit hook. */
12351 /* ??? Add some way to ignore exceptions for this TFE. */
12352 if (flag_instrument_function_entry_exit
12353 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl)
12354 && !flag_instrument_functions_exclude_p (fndecl))
12356 tree x;
12357 gbind *new_bind;
12358 gimple *tf;
12359 gimple_seq cleanup = NULL, body = NULL;
12360 tree tmp_var;
12361 gcall *call;
12363 x = builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS);
12364 call = gimple_build_call (x, 1, integer_zero_node);
12365 tmp_var = create_tmp_var (ptr_type_node, "return_addr");
12366 gimple_call_set_lhs (call, tmp_var);
12367 gimplify_seq_add_stmt (&cleanup, call);
12368 x = builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT);
12369 call = gimple_build_call (x, 2,
12370 build_fold_addr_expr (current_function_decl),
12371 tmp_var);
12372 gimplify_seq_add_stmt (&cleanup, call);
12373 tf = gimple_build_try (seq, cleanup, GIMPLE_TRY_FINALLY);
12375 x = builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS);
12376 call = gimple_build_call (x, 1, integer_zero_node);
12377 tmp_var = create_tmp_var (ptr_type_node, "return_addr");
12378 gimple_call_set_lhs (call, tmp_var);
12379 gimplify_seq_add_stmt (&body, call);
12380 x = builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER);
12381 call = gimple_build_call (x, 2,
12382 build_fold_addr_expr (current_function_decl),
12383 tmp_var);
12384 gimplify_seq_add_stmt (&body, call);
12385 gimplify_seq_add_stmt (&body, tf);
12386 new_bind = gimple_build_bind (NULL, body, NULL);
12388 /* Replace the current function body with the body
12389 wrapped in the try/finally TF. */
12390 seq = NULL;
12391 gimple_seq_add_stmt (&seq, new_bind);
12392 gimple_set_body (fndecl, seq);
12393 bind = new_bind;
12396 if ((flag_sanitize & SANITIZE_THREAD) != 0
12397 && !lookup_attribute ("no_sanitize_thread", DECL_ATTRIBUTES (fndecl)))
12399 gcall *call = gimple_build_call_internal (IFN_TSAN_FUNC_EXIT, 0);
12400 gimple *tf = gimple_build_try (seq, call, GIMPLE_TRY_FINALLY);
12401 gbind *new_bind = gimple_build_bind (NULL, tf, NULL);
12402 /* Replace the current function body with the body
12403 wrapped in the try/finally TF. */
12404 seq = NULL;
12405 gimple_seq_add_stmt (&seq, new_bind);
12406 gimple_set_body (fndecl, seq);
12409 DECL_SAVED_TREE (fndecl) = NULL_TREE;
12410 cfun->curr_properties |= PROP_gimple_any;
12412 pop_cfun ();
12414 dump_function (TDI_generic, fndecl);
12417 /* Return a dummy expression of type TYPE in order to keep going after an
12418 error. */
12420 static tree
12421 dummy_object (tree type)
12423 tree t = build_int_cst (build_pointer_type (type), 0);
12424 return build2 (MEM_REF, type, t, t);
12427 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
12428 builtin function, but a very special sort of operator. */
12430 enum gimplify_status
12431 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p,
12432 gimple_seq *post_p ATTRIBUTE_UNUSED)
12434 tree promoted_type, have_va_type;
12435 tree valist = TREE_OPERAND (*expr_p, 0);
12436 tree type = TREE_TYPE (*expr_p);
12437 tree t, tag, aptag;
12438 location_t loc = EXPR_LOCATION (*expr_p);
12440 /* Verify that valist is of the proper type. */
12441 have_va_type = TREE_TYPE (valist);
12442 if (have_va_type == error_mark_node)
12443 return GS_ERROR;
12444 have_va_type = targetm.canonical_va_list_type (have_va_type);
12445 if (have_va_type == NULL_TREE
12446 && TREE_CODE (valist) == ADDR_EXPR)
12447 /* Handle 'Case 1: Not an array type' from c-common.c/build_va_arg. */
12448 have_va_type
12449 = targetm.canonical_va_list_type (TREE_TYPE (TREE_TYPE (valist)));
12450 gcc_assert (have_va_type != NULL_TREE);
12452 /* Generate a diagnostic for requesting data of a type that cannot
12453 be passed through `...' due to type promotion at the call site. */
12454 if ((promoted_type = lang_hooks.types.type_promotes_to (type))
12455 != type)
12457 static bool gave_help;
12458 bool warned;
12459 /* Use the expansion point to handle cases such as passing bool (defined
12460 in a system header) through `...'. */
12461 source_location xloc
12462 = expansion_point_location_if_in_system_header (loc);
12464 /* Unfortunately, this is merely undefined, rather than a constraint
12465 violation, so we cannot make this an error. If this call is never
12466 executed, the program is still strictly conforming. */
12467 warned = warning_at (xloc, 0,
12468 "%qT is promoted to %qT when passed through %<...%>",
12469 type, promoted_type);
12470 if (!gave_help && warned)
12472 gave_help = true;
12473 inform (xloc, "(so you should pass %qT not %qT to %<va_arg%>)",
12474 promoted_type, type);
12477 /* We can, however, treat "undefined" any way we please.
12478 Call abort to encourage the user to fix the program. */
12479 if (warned)
12480 inform (xloc, "if this code is reached, the program will abort");
12481 /* Before the abort, allow the evaluation of the va_list
12482 expression to exit or longjmp. */
12483 gimplify_and_add (valist, pre_p);
12484 t = build_call_expr_loc (loc,
12485 builtin_decl_implicit (BUILT_IN_TRAP), 0);
12486 gimplify_and_add (t, pre_p);
12488 /* This is dead code, but go ahead and finish so that the
12489 mode of the result comes out right. */
12490 *expr_p = dummy_object (type);
12491 return GS_ALL_DONE;
12494 tag = build_int_cst (build_pointer_type (type), 0);
12495 aptag = build_int_cst (TREE_TYPE (valist), 0);
12497 *expr_p = build_call_expr_internal_loc (loc, IFN_VA_ARG, type, 3,
12498 valist, tag, aptag);
12500 /* Clear the tentatively set PROP_gimple_lva, to indicate that IFN_VA_ARG
12501 needs to be expanded. */
12502 cfun->curr_properties &= ~PROP_gimple_lva;
12504 return GS_OK;
12507 /* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
12509 DST/SRC are the destination and source respectively. You can pass
12510 ungimplified trees in DST or SRC, in which case they will be
12511 converted to a gimple operand if necessary.
12513 This function returns the newly created GIMPLE_ASSIGN tuple. */
12515 gimple *
12516 gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
12518 tree t = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
12519 gimplify_and_add (t, seq_p);
12520 ggc_free (t);
12521 return gimple_seq_last_stmt (*seq_p);
12524 inline hashval_t
12525 gimplify_hasher::hash (const elt_t *p)
12527 tree t = p->val;
12528 return iterative_hash_expr (t, 0);
12531 inline bool
12532 gimplify_hasher::equal (const elt_t *p1, const elt_t *p2)
12534 tree t1 = p1->val;
12535 tree t2 = p2->val;
12536 enum tree_code code = TREE_CODE (t1);
12538 if (TREE_CODE (t2) != code
12539 || TREE_TYPE (t1) != TREE_TYPE (t2))
12540 return false;
12542 if (!operand_equal_p (t1, t2, 0))
12543 return false;
12545 /* Only allow them to compare equal if they also hash equal; otherwise
12546 results are nondeterminate, and we fail bootstrap comparison. */
12547 gcc_checking_assert (hash (p1) == hash (p2));
12549 return true;