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
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
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/>. */
25 #include "coretypes.h"
31 #include "gimple-predict.h"
32 #include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
35 #include "tree-pretty-print.h"
36 #include "diagnostic-core.h"
38 #include "fold-const.h"
43 #include "gimple-fold.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"
55 #include "gimple-low.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 */
63 enum gimplify_omp_var_data
69 GOVD_FIRSTPRIVATE = 16,
70 GOVD_LASTPRIVATE = 32,
74 GOVD_DEBUG_PRIVATE = 512,
75 GOVD_PRIVATE_OUTER_REF = 1024,
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
104 ORT_WORKSHARE = 0x00,
108 ORT_COMBINED_PARALLEL = 0x03,
111 ORT_UNTIED_TASK = 0x05,
114 ORT_COMBINED_TEAMS = 0x09,
117 ORT_TARGET_DATA = 0x10,
119 /* Data region with offloading. */
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. */
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 *);
145 struct gimplify_ctx *prev_context;
147 vec<gbind *> bind_expr_stack;
149 gimple_seq conditional_cleanups;
153 vec<tree> case_labels;
154 /* The formal temporary table. Should this be persistent? */
155 hash_table<gimplify_hasher> *temp_htab;
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;
165 struct gimplify_omp_ctx
167 struct gimplify_omp_ctx *outer_context;
168 splay_tree variables;
169 hash_set<tree> *privatized_types;
170 /* Iteration variables in an OMP_FOR. */
171 vec<tree> loop_iter_var;
173 enum omp_clause_default_kind default_kind;
174 enum omp_region_type region_type;
177 bool target_map_scalars_firstprivate;
178 bool target_map_pointers_as_0len_arrays;
179 bool target_firstprivatize_array_bases;
182 static struct gimplify_ctx *gimplify_ctxp;
183 static struct gimplify_omp_ctx *gimplify_omp_ctxp;
185 /* Forward declaration. */
186 static enum gimplify_status gimplify_compound_expr (tree *, gimple_seq *, bool);
187 static hash_map<tree, tree> *oacc_declare_returns;
188 static enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *,
189 bool (*) (tree), fallback_t, bool);
191 /* Shorter alias name for the above function for use in gimplify.c
195 gimplify_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
197 gimple_seq_add_stmt_without_update (seq_p, gs);
200 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
201 NULL, a new sequence is allocated. This function is
202 similar to gimple_seq_add_seq, but does not scan the operands.
203 During gimplification, we need to manipulate statement sequences
204 before the def/use vectors have been constructed. */
207 gimplify_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
209 gimple_stmt_iterator si;
214 si = gsi_last (*dst_p);
215 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
219 /* Pointer to a list of allocated gimplify_ctx structs to be used for pushing
220 and popping gimplify contexts. */
222 static struct gimplify_ctx *ctx_pool = NULL;
224 /* Return a gimplify context struct from the pool. */
226 static inline struct gimplify_ctx *
229 struct gimplify_ctx * c = ctx_pool;
232 ctx_pool = c->prev_context;
234 c = XNEW (struct gimplify_ctx);
236 memset (c, '\0', sizeof (*c));
240 /* Put gimplify context C back into the pool. */
243 ctx_free (struct gimplify_ctx *c)
245 c->prev_context = ctx_pool;
249 /* Free allocated ctx stack memory. */
252 free_gimplify_stack (void)
254 struct gimplify_ctx *c;
256 while ((c = ctx_pool))
258 ctx_pool = c->prev_context;
264 /* Set up a context for the gimplifier. */
267 push_gimplify_context (bool in_ssa, bool rhs_cond_ok)
269 struct gimplify_ctx *c = ctx_alloc ();
271 c->prev_context = gimplify_ctxp;
273 gimplify_ctxp->into_ssa = in_ssa;
274 gimplify_ctxp->allow_rhs_cond_expr = rhs_cond_ok;
277 /* Tear down a context for the gimplifier. If BODY is non-null, then
278 put the temporaries into the outer BIND_EXPR. Otherwise, put them
281 BODY is not a sequence, but the first tuple in a sequence. */
284 pop_gimplify_context (gimple *body)
286 struct gimplify_ctx *c = gimplify_ctxp;
289 && (!c->bind_expr_stack.exists ()
290 || c->bind_expr_stack.is_empty ()));
291 c->bind_expr_stack.release ();
292 gimplify_ctxp = c->prev_context;
295 declare_vars (c->temps, body, false);
297 record_vars (c->temps);
304 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
307 gimple_push_bind_expr (gbind *bind_stmt)
309 gimplify_ctxp->bind_expr_stack.reserve (8);
310 gimplify_ctxp->bind_expr_stack.safe_push (bind_stmt);
313 /* Pop the first element off the stack of bindings. */
316 gimple_pop_bind_expr (void)
318 gimplify_ctxp->bind_expr_stack.pop ();
321 /* Return the first element of the stack of bindings. */
324 gimple_current_bind_expr (void)
326 return gimplify_ctxp->bind_expr_stack.last ();
329 /* Return the stack of bindings created during gimplification. */
332 gimple_bind_expr_stack (void)
334 return gimplify_ctxp->bind_expr_stack;
337 /* Return true iff there is a COND_EXPR between us and the innermost
338 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
341 gimple_conditional_context (void)
343 return gimplify_ctxp->conditions > 0;
346 /* Note that we've entered a COND_EXPR. */
349 gimple_push_condition (void)
351 #ifdef ENABLE_GIMPLE_CHECKING
352 if (gimplify_ctxp->conditions == 0)
353 gcc_assert (gimple_seq_empty_p (gimplify_ctxp->conditional_cleanups));
355 ++(gimplify_ctxp->conditions);
358 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
359 now, add any conditional cleanups we've seen to the prequeue. */
362 gimple_pop_condition (gimple_seq *pre_p)
364 int conds = --(gimplify_ctxp->conditions);
366 gcc_assert (conds >= 0);
369 gimplify_seq_add_seq (pre_p, gimplify_ctxp->conditional_cleanups);
370 gimplify_ctxp->conditional_cleanups = NULL;
374 /* A stable comparison routine for use with splay trees and DECLs. */
377 splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
382 return DECL_UID (a) - DECL_UID (b);
385 /* Create a new omp construct that deals with variable remapping. */
387 static struct gimplify_omp_ctx *
388 new_omp_context (enum omp_region_type region_type)
390 struct gimplify_omp_ctx *c;
392 c = XCNEW (struct gimplify_omp_ctx);
393 c->outer_context = gimplify_omp_ctxp;
394 c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
395 c->privatized_types = new hash_set<tree>;
396 c->location = input_location;
397 c->region_type = region_type;
398 if ((region_type & ORT_TASK) == 0)
399 c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
401 c->default_kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
406 /* Destroy an omp construct that deals with variable remapping. */
409 delete_omp_context (struct gimplify_omp_ctx *c)
411 splay_tree_delete (c->variables);
412 delete c->privatized_types;
413 c->loop_iter_var.release ();
417 static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
418 static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
420 /* Both gimplify the statement T and append it to *SEQ_P. This function
421 behaves exactly as gimplify_stmt, but you don't have to pass T as a
425 gimplify_and_add (tree t, gimple_seq *seq_p)
427 gimplify_stmt (&t, seq_p);
430 /* Gimplify statement T into sequence *SEQ_P, and return the first
431 tuple in the sequence of generated tuples for this statement.
432 Return NULL if gimplifying T produced no tuples. */
435 gimplify_and_return_first (tree t, gimple_seq *seq_p)
437 gimple_stmt_iterator last = gsi_last (*seq_p);
439 gimplify_and_add (t, seq_p);
441 if (!gsi_end_p (last))
444 return gsi_stmt (last);
447 return gimple_seq_first_stmt (*seq_p);
450 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
451 LHS, or for a call argument. */
454 is_gimple_mem_rhs (tree t)
456 /* If we're dealing with a renamable type, either source or dest must be
457 a renamed variable. */
458 if (is_gimple_reg_type (TREE_TYPE (t)))
459 return is_gimple_val (t);
461 return is_gimple_val (t) || is_gimple_lvalue (t);
464 /* Return true if T is a CALL_EXPR or an expression that can be
465 assigned to a temporary. Note that this predicate should only be
466 used during gimplification. See the rationale for this in
467 gimplify_modify_expr. */
470 is_gimple_reg_rhs_or_call (tree t)
472 return (get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS
473 || TREE_CODE (t) == CALL_EXPR);
476 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
477 this predicate should only be used during gimplification. See the
478 rationale for this in gimplify_modify_expr. */
481 is_gimple_mem_rhs_or_call (tree t)
483 /* If we're dealing with a renamable type, either source or dest must be
484 a renamed variable. */
485 if (is_gimple_reg_type (TREE_TYPE (t)))
486 return is_gimple_val (t);
488 return (is_gimple_val (t) || is_gimple_lvalue (t)
489 || TREE_CODE (t) == CALL_EXPR);
492 /* Create a temporary with a name derived from VAL. Subroutine of
493 lookup_tmp_var; nobody else should call this function. */
496 create_tmp_from_val (tree val)
498 /* Drop all qualifiers and address-space information from the value type. */
499 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (val));
500 tree var = create_tmp_var (type, get_name (val));
501 if (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
502 || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE)
503 DECL_GIMPLE_REG_P (var) = 1;
507 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
508 an existing expression temporary. */
511 lookup_tmp_var (tree val, bool is_formal)
515 /* If not optimizing, never really reuse a temporary. local-alloc
516 won't allocate any variable that is used in more than one basic
517 block, which means it will go into memory, causing much extra
518 work in reload and final and poorer code generation, outweighing
519 the extra memory allocation here. */
520 if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
521 ret = create_tmp_from_val (val);
528 if (!gimplify_ctxp->temp_htab)
529 gimplify_ctxp->temp_htab = new hash_table<gimplify_hasher> (1000);
530 slot = gimplify_ctxp->temp_htab->find_slot (&elt, INSERT);
533 elt_p = XNEW (elt_t);
535 elt_p->temp = ret = create_tmp_from_val (val);
548 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
551 internal_get_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
552 bool is_formal, bool allow_ssa)
556 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
557 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
558 gimplify_expr (&val, pre_p, post_p, is_gimple_reg_rhs_or_call,
562 && gimplify_ctxp->into_ssa
563 && is_gimple_reg_type (TREE_TYPE (val)))
565 t = make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val)));
566 if (! gimple_in_ssa_p (cfun))
568 const char *name = get_name (val);
570 SET_SSA_NAME_VAR_OR_IDENTIFIER (t, create_tmp_var_name (name));
574 t = lookup_tmp_var (val, is_formal);
576 mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
578 SET_EXPR_LOCATION (mod, EXPR_LOC_OR_LOC (val, input_location));
580 /* gimplify_modify_expr might want to reduce this further. */
581 gimplify_and_add (mod, pre_p);
587 /* Return a formal temporary variable initialized with VAL. PRE_P is as
588 in gimplify_expr. Only use this function if:
590 1) The value of the unfactored expression represented by VAL will not
591 change between the initialization and use of the temporary, and
592 2) The temporary will not be otherwise modified.
594 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
595 and #2 means it is inappropriate for && temps.
597 For other cases, use get_initialized_tmp_var instead. */
600 get_formal_tmp_var (tree val, gimple_seq *pre_p)
602 return internal_get_tmp_var (val, pre_p, NULL, true, true);
605 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
606 are as in gimplify_expr. */
609 get_initialized_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
612 return internal_get_tmp_var (val, pre_p, post_p, false, allow_ssa);
615 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
616 generate debug info for them; otherwise don't. */
619 declare_vars (tree vars, gimple *gs, bool debug_info)
626 gbind *scope = as_a <gbind *> (gs);
628 temps = nreverse (last);
630 block = gimple_bind_block (scope);
631 gcc_assert (!block || TREE_CODE (block) == BLOCK);
632 if (!block || !debug_info)
634 DECL_CHAIN (last) = gimple_bind_vars (scope);
635 gimple_bind_set_vars (scope, temps);
639 /* We need to attach the nodes both to the BIND_EXPR and to its
640 associated BLOCK for debugging purposes. The key point here
641 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
642 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
643 if (BLOCK_VARS (block))
644 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
647 gimple_bind_set_vars (scope,
648 chainon (gimple_bind_vars (scope), temps));
649 BLOCK_VARS (block) = temps;
655 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
656 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
657 no such upper bound can be obtained. */
660 force_constant_size (tree var)
662 /* The only attempt we make is by querying the maximum size of objects
663 of the variable's type. */
665 HOST_WIDE_INT max_size;
667 gcc_assert (TREE_CODE (var) == VAR_DECL);
669 max_size = max_int_size_in_bytes (TREE_TYPE (var));
671 gcc_assert (max_size >= 0);
674 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size);
676 = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT);
679 /* Push the temporary variable TMP into the current binding. */
682 gimple_add_tmp_var_fn (struct function *fn, tree tmp)
684 gcc_assert (!DECL_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
686 /* Later processing assumes that the object size is constant, which might
687 not be true at this point. Force the use of a constant upper bound in
689 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (tmp)))
690 force_constant_size (tmp);
692 DECL_CONTEXT (tmp) = fn->decl;
693 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
695 record_vars_into (tmp, fn->decl);
698 /* Push the temporary variable TMP into the current binding. */
701 gimple_add_tmp_var (tree tmp)
703 gcc_assert (!DECL_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
705 /* Later processing assumes that the object size is constant, which might
706 not be true at this point. Force the use of a constant upper bound in
708 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (tmp)))
709 force_constant_size (tmp);
711 DECL_CONTEXT (tmp) = current_function_decl;
712 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
716 DECL_CHAIN (tmp) = gimplify_ctxp->temps;
717 gimplify_ctxp->temps = tmp;
719 /* Mark temporaries local within the nearest enclosing parallel. */
720 if (gimplify_omp_ctxp)
722 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
724 && (ctx->region_type == ORT_WORKSHARE
725 || ctx->region_type == ORT_SIMD
726 || ctx->region_type == ORT_ACC))
727 ctx = ctx->outer_context;
729 omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
738 /* This case is for nested functions. We need to expose the locals
740 body_seq = gimple_body (current_function_decl);
741 declare_vars (tmp, gimple_seq_first_stmt (body_seq), false);
747 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
748 nodes that are referenced more than once in GENERIC functions. This is
749 necessary because gimplification (translation into GIMPLE) is performed
750 by modifying tree nodes in-place, so gimplication of a shared node in a
751 first context could generate an invalid GIMPLE form in a second context.
753 This is achieved with a simple mark/copy/unmark algorithm that walks the
754 GENERIC representation top-down, marks nodes with TREE_VISITED the first
755 time it encounters them, duplicates them if they already have TREE_VISITED
756 set, and finally removes the TREE_VISITED marks it has set.
758 The algorithm works only at the function level, i.e. it generates a GENERIC
759 representation of a function with no nodes shared within the function when
760 passed a GENERIC function (except for nodes that are allowed to be shared).
762 At the global level, it is also necessary to unshare tree nodes that are
763 referenced in more than one function, for the same aforementioned reason.
764 This requires some cooperation from the front-end. There are 2 strategies:
766 1. Manual unsharing. The front-end needs to call unshare_expr on every
767 expression that might end up being shared across functions.
769 2. Deep unsharing. This is an extension of regular unsharing. Instead
770 of calling unshare_expr on expressions that might be shared across
771 functions, the front-end pre-marks them with TREE_VISITED. This will
772 ensure that they are unshared on the first reference within functions
773 when the regular unsharing algorithm runs. The counterpart is that
774 this algorithm must look deeper than for manual unsharing, which is
775 specified by LANG_HOOKS_DEEP_UNSHARING.
777 If there are only few specific cases of node sharing across functions, it is
778 probably easier for a front-end to unshare the expressions manually. On the
779 contrary, if the expressions generated at the global level are as widespread
780 as expressions generated within functions, deep unsharing is very likely the
783 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
784 These nodes model computations that must be done once. If we were to
785 unshare something like SAVE_EXPR(i++), the gimplification process would
786 create wrong code. However, if DATA is non-null, it must hold a pointer
787 set that is used to unshare the subtrees of these nodes. */
790 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
793 enum tree_code code = TREE_CODE (t);
795 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
796 copy their subtrees if we can make sure to do it only once. */
797 if (code == SAVE_EXPR || code == TARGET_EXPR || code == BIND_EXPR)
799 if (data && !((hash_set<tree> *)data)->add (t))
805 /* Stop at types, decls, constants like copy_tree_r. */
806 else if (TREE_CODE_CLASS (code) == tcc_type
807 || TREE_CODE_CLASS (code) == tcc_declaration
808 || TREE_CODE_CLASS (code) == tcc_constant
809 /* We can't do anything sensible with a BLOCK used as an
810 expression, but we also can't just die when we see it
811 because of non-expression uses. So we avert our eyes
812 and cross our fingers. Silly Java. */
816 /* Cope with the statement expression extension. */
817 else if (code == STATEMENT_LIST)
820 /* Leave the bulk of the work to copy_tree_r itself. */
822 copy_tree_r (tp, walk_subtrees, NULL);
827 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
828 If *TP has been visited already, then *TP is deeply copied by calling
829 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
832 copy_if_shared_r (tree *tp, int *walk_subtrees, void *data)
835 enum tree_code code = TREE_CODE (t);
837 /* Skip types, decls, and constants. But we do want to look at their
838 types and the bounds of types. Mark them as visited so we properly
839 unmark their subtrees on the unmark pass. If we've already seen them,
840 don't look down further. */
841 if (TREE_CODE_CLASS (code) == tcc_type
842 || TREE_CODE_CLASS (code) == tcc_declaration
843 || TREE_CODE_CLASS (code) == tcc_constant)
845 if (TREE_VISITED (t))
848 TREE_VISITED (t) = 1;
851 /* If this node has been visited already, unshare it and don't look
853 else if (TREE_VISITED (t))
855 walk_tree (tp, mostly_copy_tree_r, data, NULL);
859 /* Otherwise, mark the node as visited and keep looking. */
861 TREE_VISITED (t) = 1;
866 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
867 copy_if_shared_r callback unmodified. */
870 copy_if_shared (tree *tp, void *data)
872 walk_tree (tp, copy_if_shared_r, data, NULL);
875 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
876 any nested functions. */
879 unshare_body (tree fndecl)
881 struct cgraph_node *cgn = cgraph_node::get (fndecl);
882 /* If the language requires deep unsharing, we need a pointer set to make
883 sure we don't repeatedly unshare subtrees of unshareable nodes. */
884 hash_set<tree> *visited
885 = lang_hooks.deep_unsharing ? new hash_set<tree> : NULL;
887 copy_if_shared (&DECL_SAVED_TREE (fndecl), visited);
888 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl)), visited);
889 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl)), visited);
894 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
895 unshare_body (cgn->decl);
898 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
899 Subtrees are walked until the first unvisited node is encountered. */
902 unmark_visited_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
906 /* If this node has been visited, unmark it and keep looking. */
907 if (TREE_VISITED (t))
908 TREE_VISITED (t) = 0;
910 /* Otherwise, don't look any deeper. */
917 /* Unmark the visited trees rooted at *TP. */
920 unmark_visited (tree *tp)
922 walk_tree (tp, unmark_visited_r, NULL, NULL);
925 /* Likewise, but mark all trees as not visited. */
928 unvisit_body (tree fndecl)
930 struct cgraph_node *cgn = cgraph_node::get (fndecl);
932 unmark_visited (&DECL_SAVED_TREE (fndecl));
933 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl)));
934 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl)));
937 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
938 unvisit_body (cgn->decl);
941 /* Unconditionally make an unshared copy of EXPR. This is used when using
942 stored expressions which span multiple functions, such as BINFO_VTABLE,
943 as the normal unsharing process can't tell that they're shared. */
946 unshare_expr (tree expr)
948 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
952 /* Worker for unshare_expr_without_location. */
955 prune_expr_location (tree *tp, int *walk_subtrees, void *)
958 SET_EXPR_LOCATION (*tp, UNKNOWN_LOCATION);
964 /* Similar to unshare_expr but also prune all expression locations
968 unshare_expr_without_location (tree expr)
970 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
972 walk_tree (&expr, prune_expr_location, NULL, NULL);
976 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
977 contain statements and have a value. Assign its value to a temporary
978 and give it void_type_node. Return the temporary, or NULL_TREE if
979 WRAPPER was already void. */
982 voidify_wrapper_expr (tree wrapper, tree temp)
984 tree type = TREE_TYPE (wrapper);
985 if (type && !VOID_TYPE_P (type))
989 /* Set p to point to the body of the wrapper. Loop until we find
990 something that isn't a wrapper. */
991 for (p = &wrapper; p && *p; )
993 switch (TREE_CODE (*p))
996 TREE_SIDE_EFFECTS (*p) = 1;
997 TREE_TYPE (*p) = void_type_node;
998 /* For a BIND_EXPR, the body is operand 1. */
999 p = &BIND_EXPR_BODY (*p);
1002 case CLEANUP_POINT_EXPR:
1003 case TRY_FINALLY_EXPR:
1004 case TRY_CATCH_EXPR:
1005 TREE_SIDE_EFFECTS (*p) = 1;
1006 TREE_TYPE (*p) = void_type_node;
1007 p = &TREE_OPERAND (*p, 0);
1010 case STATEMENT_LIST:
1012 tree_stmt_iterator i = tsi_last (*p);
1013 TREE_SIDE_EFFECTS (*p) = 1;
1014 TREE_TYPE (*p) = void_type_node;
1015 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
1020 /* Advance to the last statement. Set all container types to
1022 for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
1024 TREE_SIDE_EFFECTS (*p) = 1;
1025 TREE_TYPE (*p) = void_type_node;
1029 case TRANSACTION_EXPR:
1030 TREE_SIDE_EFFECTS (*p) = 1;
1031 TREE_TYPE (*p) = void_type_node;
1032 p = &TRANSACTION_EXPR_BODY (*p);
1036 /* Assume that any tree upon which voidify_wrapper_expr is
1037 directly called is a wrapper, and that its body is op0. */
1040 TREE_SIDE_EFFECTS (*p) = 1;
1041 TREE_TYPE (*p) = void_type_node;
1042 p = &TREE_OPERAND (*p, 0);
1050 if (p == NULL || IS_EMPTY_STMT (*p))
1054 /* The wrapper is on the RHS of an assignment that we're pushing
1056 gcc_assert (TREE_CODE (temp) == INIT_EXPR
1057 || TREE_CODE (temp) == MODIFY_EXPR);
1058 TREE_OPERAND (temp, 1) = *p;
1063 temp = create_tmp_var (type, "retval");
1064 *p = build2 (INIT_EXPR, type, temp, *p);
1073 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1074 a temporary through which they communicate. */
1077 build_stack_save_restore (gcall **save, gcall **restore)
1081 *save = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE), 0);
1082 tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
1083 gimple_call_set_lhs (*save, tmp_var);
1086 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE),
1090 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1092 static enum gimplify_status
1093 gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
1095 tree bind_expr = *expr_p;
1096 bool old_keep_stack = gimplify_ctxp->keep_stack;
1097 bool old_save_stack = gimplify_ctxp->save_stack;
1100 gimple_seq body, cleanup;
1102 location_t start_locus = 0, end_locus = 0;
1103 tree ret_clauses = NULL;
1105 tree temp = voidify_wrapper_expr (bind_expr, NULL);
1107 /* Mark variables seen in this bind expr. */
1108 for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
1110 if (TREE_CODE (t) == VAR_DECL)
1112 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1114 /* Mark variable as local. */
1115 if (ctx && ctx->region_type != ORT_NONE && !DECL_EXTERNAL (t)
1116 && (! DECL_SEEN_IN_BIND_EXPR_P (t)
1117 || splay_tree_lookup (ctx->variables,
1118 (splay_tree_key) t) == NULL))
1120 if (ctx->region_type == ORT_SIMD
1121 && TREE_ADDRESSABLE (t)
1122 && !TREE_STATIC (t))
1123 omp_add_variable (ctx, t, GOVD_PRIVATE | GOVD_SEEN);
1125 omp_add_variable (ctx, t, GOVD_LOCAL | GOVD_SEEN);
1128 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
1130 if (DECL_HARD_REGISTER (t) && !is_global_var (t) && cfun)
1131 cfun->has_local_explicit_reg_vars = true;
1134 /* Preliminarily mark non-addressed complex variables as eligible
1135 for promotion to gimple registers. We'll transform their uses
1137 if ((TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
1138 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
1139 && !TREE_THIS_VOLATILE (t)
1140 && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
1141 && !needs_to_live_in_memory (t))
1142 DECL_GIMPLE_REG_P (t) = 1;
1145 bind_stmt = gimple_build_bind (BIND_EXPR_VARS (bind_expr), NULL,
1146 BIND_EXPR_BLOCK (bind_expr));
1147 gimple_push_bind_expr (bind_stmt);
1149 gimplify_ctxp->keep_stack = false;
1150 gimplify_ctxp->save_stack = false;
1152 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1154 gimplify_stmt (&BIND_EXPR_BODY (bind_expr), &body);
1155 gimple_bind_set_body (bind_stmt, body);
1157 /* Source location wise, the cleanup code (stack_restore and clobbers)
1158 belongs to the end of the block, so propagate what we have. The
1159 stack_save operation belongs to the beginning of block, which we can
1160 infer from the bind_expr directly if the block has no explicit
1162 if (BIND_EXPR_BLOCK (bind_expr))
1164 end_locus = BLOCK_SOURCE_END_LOCATION (BIND_EXPR_BLOCK (bind_expr));
1165 start_locus = BLOCK_SOURCE_LOCATION (BIND_EXPR_BLOCK (bind_expr));
1167 if (start_locus == 0)
1168 start_locus = EXPR_LOCATION (bind_expr);
1173 /* If the code both contains VLAs and calls alloca, then we cannot reclaim
1174 the stack space allocated to the VLAs. */
1175 if (gimplify_ctxp->save_stack && !gimplify_ctxp->keep_stack)
1177 gcall *stack_restore;
1179 /* Save stack on entry and restore it on exit. Add a try_finally
1180 block to achieve this. */
1181 build_stack_save_restore (&stack_save, &stack_restore);
1183 gimple_set_location (stack_save, start_locus);
1184 gimple_set_location (stack_restore, end_locus);
1186 gimplify_seq_add_stmt (&cleanup, stack_restore);
1189 /* Add clobbers for all variables that go out of scope. */
1190 for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
1192 if (TREE_CODE (t) == VAR_DECL
1193 && !is_global_var (t)
1194 && DECL_CONTEXT (t) == current_function_decl
1195 && !DECL_HARD_REGISTER (t)
1196 && !TREE_THIS_VOLATILE (t)
1197 && !DECL_HAS_VALUE_EXPR_P (t)
1198 /* Only care for variables that have to be in memory. Others
1199 will be rewritten into SSA names, hence moved to the top-level. */
1200 && !is_gimple_reg (t)
1201 && flag_stack_reuse != SR_NONE)
1203 tree clobber = build_constructor (TREE_TYPE (t), NULL);
1204 gimple *clobber_stmt;
1205 TREE_THIS_VOLATILE (clobber) = 1;
1206 clobber_stmt = gimple_build_assign (t, clobber);
1207 gimple_set_location (clobber_stmt, end_locus);
1208 gimplify_seq_add_stmt (&cleanup, clobber_stmt);
1210 if (flag_openacc && oacc_declare_returns != NULL)
1212 tree *c = oacc_declare_returns->get (t);
1216 OMP_CLAUSE_CHAIN (*c) = ret_clauses;
1220 oacc_declare_returns->remove (t);
1222 if (oacc_declare_returns->elements () == 0)
1224 delete oacc_declare_returns;
1225 oacc_declare_returns = NULL;
1235 gimple_stmt_iterator si = gsi_start (cleanup);
1237 stmt = gimple_build_omp_target (NULL, GF_OMP_TARGET_KIND_OACC_DECLARE,
1239 gsi_insert_seq_before_without_update (&si, stmt, GSI_NEW_STMT);
1245 gimple_seq new_body;
1248 gs = gimple_build_try (gimple_bind_body (bind_stmt), cleanup,
1249 GIMPLE_TRY_FINALLY);
1252 gimplify_seq_add_stmt (&new_body, stack_save);
1253 gimplify_seq_add_stmt (&new_body, gs);
1254 gimple_bind_set_body (bind_stmt, new_body);
1257 /* keep_stack propagates all the way up to the outermost BIND_EXPR. */
1258 if (!gimplify_ctxp->keep_stack)
1259 gimplify_ctxp->keep_stack = old_keep_stack;
1260 gimplify_ctxp->save_stack = old_save_stack;
1262 gimple_pop_bind_expr ();
1264 gimplify_seq_add_stmt (pre_p, bind_stmt);
1272 *expr_p = NULL_TREE;
1276 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1277 GIMPLE value, it is assigned to a new temporary and the statement is
1278 re-written to return the temporary.
1280 PRE_P points to the sequence where side effects that must happen before
1281 STMT should be stored. */
1283 static enum gimplify_status
1284 gimplify_return_expr (tree stmt, gimple_seq *pre_p)
1287 tree ret_expr = TREE_OPERAND (stmt, 0);
1288 tree result_decl, result;
1290 if (ret_expr == error_mark_node)
1293 /* Implicit _Cilk_sync must be inserted right before any return statement
1294 if there is a _Cilk_spawn in the function. If the user has provided a
1295 _Cilk_sync, the optimizer should remove this duplicate one. */
1296 if (fn_contains_cilk_spawn_p (cfun))
1298 tree impl_sync = build0 (CILK_SYNC_STMT, void_type_node);
1299 gimplify_and_add (impl_sync, pre_p);
1303 || TREE_CODE (ret_expr) == RESULT_DECL
1304 || ret_expr == error_mark_node)
1306 greturn *ret = gimple_build_return (ret_expr);
1307 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1308 gimplify_seq_add_stmt (pre_p, ret);
1312 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1313 result_decl = NULL_TREE;
1316 result_decl = TREE_OPERAND (ret_expr, 0);
1318 /* See through a return by reference. */
1319 if (TREE_CODE (result_decl) == INDIRECT_REF)
1320 result_decl = TREE_OPERAND (result_decl, 0);
1322 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
1323 || TREE_CODE (ret_expr) == INIT_EXPR)
1324 && TREE_CODE (result_decl) == RESULT_DECL);
1327 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1328 Recall that aggregate_value_p is FALSE for any aggregate type that is
1329 returned in registers. If we're returning values in registers, then
1330 we don't want to extend the lifetime of the RESULT_DECL, particularly
1331 across another call. In addition, for those aggregates for which
1332 hard_function_value generates a PARALLEL, we'll die during normal
1333 expansion of structure assignments; there's special code in expand_return
1334 to handle this case that does not exist in expand_expr. */
1337 else if (aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1339 if (TREE_CODE (DECL_SIZE (result_decl)) != INTEGER_CST)
1341 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl)))
1342 gimplify_type_sizes (TREE_TYPE (result_decl), pre_p);
1343 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1344 should be effectively allocated by the caller, i.e. all calls to
1345 this function must be subject to the Return Slot Optimization. */
1346 gimplify_one_sizepos (&DECL_SIZE (result_decl), pre_p);
1347 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl), pre_p);
1349 result = result_decl;
1351 else if (gimplify_ctxp->return_temp)
1352 result = gimplify_ctxp->return_temp;
1355 result = create_tmp_reg (TREE_TYPE (result_decl));
1357 /* ??? With complex control flow (usually involving abnormal edges),
1358 we can wind up warning about an uninitialized value for this. Due
1359 to how this variable is constructed and initialized, this is never
1360 true. Give up and never warn. */
1361 TREE_NO_WARNING (result) = 1;
1363 gimplify_ctxp->return_temp = result;
1366 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1367 Then gimplify the whole thing. */
1368 if (result != result_decl)
1369 TREE_OPERAND (ret_expr, 0) = result;
1371 gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1373 ret = gimple_build_return (result);
1374 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1375 gimplify_seq_add_stmt (pre_p, ret);
1380 /* Gimplify a variable-length array DECL. */
1383 gimplify_vla_decl (tree decl, gimple_seq *seq_p)
1385 /* This is a variable-sized decl. Simplify its size and mark it
1386 for deferred expansion. */
1387 tree t, addr, ptr_type;
1389 gimplify_one_sizepos (&DECL_SIZE (decl), seq_p);
1390 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), seq_p);
1392 /* Don't mess with a DECL_VALUE_EXPR set by the front-end. */
1393 if (DECL_HAS_VALUE_EXPR_P (decl))
1396 /* All occurrences of this decl in final gimplified code will be
1397 replaced by indirection. Setting DECL_VALUE_EXPR does two
1398 things: First, it lets the rest of the gimplifier know what
1399 replacement to use. Second, it lets the debug info know
1400 where to find the value. */
1401 ptr_type = build_pointer_type (TREE_TYPE (decl));
1402 addr = create_tmp_var (ptr_type, get_name (decl));
1403 DECL_IGNORED_P (addr) = 0;
1404 t = build_fold_indirect_ref (addr);
1405 TREE_THIS_NOTRAP (t) = 1;
1406 SET_DECL_VALUE_EXPR (decl, t);
1407 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1409 t = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN);
1410 t = build_call_expr (t, 2, DECL_SIZE_UNIT (decl),
1411 size_int (DECL_ALIGN (decl)));
1412 /* The call has been built for a variable-sized object. */
1413 CALL_ALLOCA_FOR_VAR_P (t) = 1;
1414 t = fold_convert (ptr_type, t);
1415 t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
1417 gimplify_and_add (t, seq_p);
1420 /* A helper function to be called via walk_tree. Mark all labels under *TP
1421 as being forced. To be called for DECL_INITIAL of static variables. */
1424 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1428 if (TREE_CODE (*tp) == LABEL_DECL)
1430 FORCED_LABEL (*tp) = 1;
1431 cfun->has_forced_label_in_static = 1;
1437 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1438 and initialization explicit. */
1440 static enum gimplify_status
1441 gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p)
1443 tree stmt = *stmt_p;
1444 tree decl = DECL_EXPR_DECL (stmt);
1446 *stmt_p = NULL_TREE;
1448 if (TREE_TYPE (decl) == error_mark_node)
1451 if ((TREE_CODE (decl) == TYPE_DECL
1452 || TREE_CODE (decl) == VAR_DECL)
1453 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1455 gimplify_type_sizes (TREE_TYPE (decl), seq_p);
1456 if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
1457 gimplify_type_sizes (TREE_TYPE (TREE_TYPE (decl)), seq_p);
1460 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1461 in case its size expressions contain problematic nodes like CALL_EXPR. */
1462 if (TREE_CODE (decl) == TYPE_DECL
1463 && DECL_ORIGINAL_TYPE (decl)
1464 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl)))
1466 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl), seq_p);
1467 if (TREE_CODE (DECL_ORIGINAL_TYPE (decl)) == REFERENCE_TYPE)
1468 gimplify_type_sizes (TREE_TYPE (DECL_ORIGINAL_TYPE (decl)), seq_p);
1471 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1473 tree init = DECL_INITIAL (decl);
1475 if (TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1476 || (!TREE_STATIC (decl)
1477 && flag_stack_check == GENERIC_STACK_CHECK
1478 && compare_tree_int (DECL_SIZE_UNIT (decl),
1479 STACK_CHECK_MAX_VAR_SIZE) > 0))
1480 gimplify_vla_decl (decl, seq_p);
1482 /* Some front ends do not explicitly declare all anonymous
1483 artificial variables. We compensate here by declaring the
1484 variables, though it would be better if the front ends would
1485 explicitly declare them. */
1486 if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1487 && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1488 gimple_add_tmp_var (decl);
1490 if (init && init != error_mark_node)
1492 if (!TREE_STATIC (decl))
1494 DECL_INITIAL (decl) = NULL_TREE;
1495 init = build2 (INIT_EXPR, void_type_node, decl, init);
1496 gimplify_and_add (init, seq_p);
1500 /* We must still examine initializers for static variables
1501 as they may contain a label address. */
1502 walk_tree (&init, force_labels_r, NULL, NULL);
1509 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1510 and replacing the LOOP_EXPR with goto, but if the loop contains an
1511 EXIT_EXPR, we need to append a label for it to jump to. */
1513 static enum gimplify_status
1514 gimplify_loop_expr (tree *expr_p, gimple_seq *pre_p)
1516 tree saved_label = gimplify_ctxp->exit_label;
1517 tree start_label = create_artificial_label (UNKNOWN_LOCATION);
1519 gimplify_seq_add_stmt (pre_p, gimple_build_label (start_label));
1521 gimplify_ctxp->exit_label = NULL_TREE;
1523 gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1525 gimplify_seq_add_stmt (pre_p, gimple_build_goto (start_label));
1527 if (gimplify_ctxp->exit_label)
1528 gimplify_seq_add_stmt (pre_p,
1529 gimple_build_label (gimplify_ctxp->exit_label));
1531 gimplify_ctxp->exit_label = saved_label;
1537 /* Gimplify a statement list onto a sequence. These may be created either
1538 by an enlightened front-end, or by shortcut_cond_expr. */
1540 static enum gimplify_status
1541 gimplify_statement_list (tree *expr_p, gimple_seq *pre_p)
1543 tree temp = voidify_wrapper_expr (*expr_p, NULL);
1545 tree_stmt_iterator i = tsi_start (*expr_p);
1547 while (!tsi_end_p (i))
1549 gimplify_stmt (tsi_stmt_ptr (i), pre_p);
1562 /* Callback for walk_gimple_seq. */
1565 warn_switch_unreachable_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
1566 struct walk_stmt_info *wi)
1568 gimple *stmt = gsi_stmt (*gsi_p);
1570 *handled_ops_p = true;
1571 switch (gimple_code (stmt))
1574 /* A compiler-generated cleanup or a user-written try block.
1575 If it's empty, don't dive into it--that would result in
1576 worse location info. */
1577 if (gimple_try_eval (stmt) == NULL)
1580 return integer_zero_node;
1585 case GIMPLE_EH_FILTER:
1586 case GIMPLE_TRANSACTION:
1587 /* Walk the sub-statements. */
1588 *handled_ops_p = false;
1591 /* Save the first "real" statement (not a decl/lexical scope/...). */
1593 return integer_zero_node;
1598 /* Possibly warn about unreachable statements between switch's controlling
1599 expression and the first case. SEQ is the body of a switch expression. */
1602 maybe_warn_switch_unreachable (gimple_seq seq)
1604 if (!warn_switch_unreachable
1605 /* This warning doesn't play well with Fortran when optimizations
1607 || lang_GNU_Fortran ()
1611 struct walk_stmt_info wi;
1612 memset (&wi, 0, sizeof (wi));
1613 walk_gimple_seq (seq, warn_switch_unreachable_r, NULL, &wi);
1614 gimple *stmt = (gimple *) wi.info;
1616 if (stmt && gimple_code (stmt) != GIMPLE_LABEL)
1618 if (gimple_code (stmt) == GIMPLE_GOTO
1619 && TREE_CODE (gimple_goto_dest (stmt)) == LABEL_DECL
1620 && DECL_ARTIFICIAL (gimple_goto_dest (stmt)))
1621 /* Don't warn for compiler-generated gotos. These occur
1622 in Duff's devices, for example. */;
1624 warning_at (gimple_location (stmt), OPT_Wswitch_unreachable,
1625 "statement will never be executed");
1630 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
1633 static enum gimplify_status
1634 gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
1636 tree switch_expr = *expr_p;
1637 gimple_seq switch_body_seq = NULL;
1638 enum gimplify_status ret;
1639 tree index_type = TREE_TYPE (switch_expr);
1640 if (index_type == NULL_TREE)
1641 index_type = TREE_TYPE (SWITCH_COND (switch_expr));
1643 ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, is_gimple_val,
1645 if (ret == GS_ERROR || ret == GS_UNHANDLED)
1648 if (SWITCH_BODY (switch_expr))
1651 vec<tree> saved_labels;
1652 tree default_case = NULL_TREE;
1653 gswitch *switch_stmt;
1655 /* If someone can be bothered to fill in the labels, they can
1656 be bothered to null out the body too. */
1657 gcc_assert (!SWITCH_LABELS (switch_expr));
1659 /* Save old labels, get new ones from body, then restore the old
1660 labels. Save all the things from the switch body to append after. */
1661 saved_labels = gimplify_ctxp->case_labels;
1662 gimplify_ctxp->case_labels.create (8);
1664 gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq);
1666 maybe_warn_switch_unreachable (switch_body_seq);
1668 labels = gimplify_ctxp->case_labels;
1669 gimplify_ctxp->case_labels = saved_labels;
1671 preprocess_case_label_vec_for_gimple (labels, index_type,
1676 glabel *new_default;
1679 = build_case_label (NULL_TREE, NULL_TREE,
1680 create_artificial_label (UNKNOWN_LOCATION));
1681 new_default = gimple_build_label (CASE_LABEL (default_case));
1682 gimplify_seq_add_stmt (&switch_body_seq, new_default);
1685 switch_stmt = gimple_build_switch (SWITCH_COND (switch_expr),
1686 default_case, labels);
1687 gimplify_seq_add_stmt (pre_p, switch_stmt);
1688 gimplify_seq_add_seq (pre_p, switch_body_seq);
1692 gcc_assert (SWITCH_LABELS (switch_expr));
1697 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
1699 static enum gimplify_status
1700 gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
1702 struct gimplify_ctx *ctxp;
1705 /* Invalid programs can play Duff's Device type games with, for example,
1706 #pragma omp parallel. At least in the C front end, we don't
1707 detect such invalid branches until after gimplification, in the
1708 diagnose_omp_blocks pass. */
1709 for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
1710 if (ctxp->case_labels.exists ())
1713 label_stmt = gimple_build_label (CASE_LABEL (*expr_p));
1714 ctxp->case_labels.safe_push (*expr_p);
1715 gimplify_seq_add_stmt (pre_p, label_stmt);
1720 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1724 build_and_jump (tree *label_p)
1726 if (label_p == NULL)
1727 /* If there's nowhere to jump, just fall through. */
1730 if (*label_p == NULL_TREE)
1732 tree label = create_artificial_label (UNKNOWN_LOCATION);
1736 return build1 (GOTO_EXPR, void_type_node, *label_p);
1739 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1740 This also involves building a label to jump to and communicating it to
1741 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1743 static enum gimplify_status
1744 gimplify_exit_expr (tree *expr_p)
1746 tree cond = TREE_OPERAND (*expr_p, 0);
1749 expr = build_and_jump (&gimplify_ctxp->exit_label);
1750 expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1756 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1757 different from its canonical type, wrap the whole thing inside a
1758 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1761 The canonical type of a COMPONENT_REF is the type of the field being
1762 referenced--unless the field is a bit-field which can be read directly
1763 in a smaller mode, in which case the canonical type is the
1764 sign-appropriate type corresponding to that mode. */
1767 canonicalize_component_ref (tree *expr_p)
1769 tree expr = *expr_p;
1772 gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
1774 if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1775 type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1777 type = TREE_TYPE (TREE_OPERAND (expr, 1));
1779 /* One could argue that all the stuff below is not necessary for
1780 the non-bitfield case and declare it a FE error if type
1781 adjustment would be needed. */
1782 if (TREE_TYPE (expr) != type)
1784 #ifdef ENABLE_TYPES_CHECKING
1785 tree old_type = TREE_TYPE (expr);
1789 /* We need to preserve qualifiers and propagate them from
1791 type_quals = TYPE_QUALS (type)
1792 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
1793 if (TYPE_QUALS (type) != type_quals)
1794 type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
1796 /* Set the type of the COMPONENT_REF to the underlying type. */
1797 TREE_TYPE (expr) = type;
1799 #ifdef ENABLE_TYPES_CHECKING
1800 /* It is now a FE error, if the conversion from the canonical
1801 type to the original expression type is not useless. */
1802 gcc_assert (useless_type_conversion_p (old_type, type));
1807 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1808 to foo, embed that change in the ADDR_EXPR by converting
1813 where L is the lower bound. For simplicity, only do this for constant
1815 The constraint is that the type of &array[L] is trivially convertible
1819 canonicalize_addr_expr (tree *expr_p)
1821 tree expr = *expr_p;
1822 tree addr_expr = TREE_OPERAND (expr, 0);
1823 tree datype, ddatype, pddatype;
1825 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1826 if (!POINTER_TYPE_P (TREE_TYPE (expr))
1827 || TREE_CODE (addr_expr) != ADDR_EXPR)
1830 /* The addr_expr type should be a pointer to an array. */
1831 datype = TREE_TYPE (TREE_TYPE (addr_expr));
1832 if (TREE_CODE (datype) != ARRAY_TYPE)
1835 /* The pointer to element type shall be trivially convertible to
1836 the expression pointer type. */
1837 ddatype = TREE_TYPE (datype);
1838 pddatype = build_pointer_type (ddatype);
1839 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)),
1843 /* The lower bound and element sizes must be constant. */
1844 if (!TYPE_SIZE_UNIT (ddatype)
1845 || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
1846 || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1847 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1850 /* All checks succeeded. Build a new node to merge the cast. */
1851 *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
1852 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1853 NULL_TREE, NULL_TREE);
1854 *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
1856 /* We can have stripped a required restrict qualifier above. */
1857 if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
1858 *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
1861 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1862 underneath as appropriate. */
1864 static enum gimplify_status
1865 gimplify_conversion (tree *expr_p)
1867 location_t loc = EXPR_LOCATION (*expr_p);
1868 gcc_assert (CONVERT_EXPR_P (*expr_p));
1870 /* Then strip away all but the outermost conversion. */
1871 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1873 /* And remove the outermost conversion if it's useless. */
1874 if (tree_ssa_useless_type_conversion (*expr_p))
1875 *expr_p = TREE_OPERAND (*expr_p, 0);
1877 /* If we still have a conversion at the toplevel,
1878 then canonicalize some constructs. */
1879 if (CONVERT_EXPR_P (*expr_p))
1881 tree sub = TREE_OPERAND (*expr_p, 0);
1883 /* If a NOP conversion is changing the type of a COMPONENT_REF
1884 expression, then canonicalize its type now in order to expose more
1885 redundant conversions. */
1886 if (TREE_CODE (sub) == COMPONENT_REF)
1887 canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1889 /* If a NOP conversion is changing a pointer to array of foo
1890 to a pointer to foo, embed that change in the ADDR_EXPR. */
1891 else if (TREE_CODE (sub) == ADDR_EXPR)
1892 canonicalize_addr_expr (expr_p);
1895 /* If we have a conversion to a non-register type force the
1896 use of a VIEW_CONVERT_EXPR instead. */
1897 if (CONVERT_EXPR_P (*expr_p) && !is_gimple_reg_type (TREE_TYPE (*expr_p)))
1898 *expr_p = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (*expr_p),
1899 TREE_OPERAND (*expr_p, 0));
1901 /* Canonicalize CONVERT_EXPR to NOP_EXPR. */
1902 if (TREE_CODE (*expr_p) == CONVERT_EXPR)
1903 TREE_SET_CODE (*expr_p, NOP_EXPR);
1908 /* Nonlocal VLAs seen in the current function. */
1909 static hash_set<tree> *nonlocal_vlas;
1911 /* The VAR_DECLs created for nonlocal VLAs for debug info purposes. */
1912 static tree nonlocal_vla_vars;
1914 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
1915 DECL_VALUE_EXPR, and it's worth re-examining things. */
1917 static enum gimplify_status
1918 gimplify_var_or_parm_decl (tree *expr_p)
1920 tree decl = *expr_p;
1922 /* ??? If this is a local variable, and it has not been seen in any
1923 outer BIND_EXPR, then it's probably the result of a duplicate
1924 declaration, for which we've already issued an error. It would
1925 be really nice if the front end wouldn't leak these at all.
1926 Currently the only known culprit is C++ destructors, as seen
1927 in g++.old-deja/g++.jason/binding.C. */
1928 if (TREE_CODE (decl) == VAR_DECL
1929 && !DECL_SEEN_IN_BIND_EXPR_P (decl)
1930 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
1931 && decl_function_context (decl) == current_function_decl)
1933 gcc_assert (seen_error ());
1937 /* When within an OMP context, notice uses of variables. */
1938 if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
1941 /* If the decl is an alias for another expression, substitute it now. */
1942 if (DECL_HAS_VALUE_EXPR_P (decl))
1944 tree value_expr = DECL_VALUE_EXPR (decl);
1946 /* For referenced nonlocal VLAs add a decl for debugging purposes
1947 to the current function. */
1948 if (TREE_CODE (decl) == VAR_DECL
1949 && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1950 && nonlocal_vlas != NULL
1951 && TREE_CODE (value_expr) == INDIRECT_REF
1952 && TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
1953 && decl_function_context (decl) != current_function_decl)
1955 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1957 && (ctx->region_type == ORT_WORKSHARE
1958 || ctx->region_type == ORT_SIMD
1959 || ctx->region_type == ORT_ACC))
1960 ctx = ctx->outer_context;
1961 if (!ctx && !nonlocal_vlas->add (decl))
1963 tree copy = copy_node (decl);
1965 lang_hooks.dup_lang_specific_decl (copy);
1966 SET_DECL_RTL (copy, 0);
1967 TREE_USED (copy) = 1;
1968 DECL_CHAIN (copy) = nonlocal_vla_vars;
1969 nonlocal_vla_vars = copy;
1970 SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
1971 DECL_HAS_VALUE_EXPR_P (copy) = 1;
1975 *expr_p = unshare_expr (value_expr);
1982 /* Recalculate the value of the TREE_SIDE_EFFECTS flag for T. */
1985 recalculate_side_effects (tree t)
1987 enum tree_code code = TREE_CODE (t);
1988 int len = TREE_OPERAND_LENGTH (t);
1991 switch (TREE_CODE_CLASS (code))
1993 case tcc_expression:
1999 case PREDECREMENT_EXPR:
2000 case PREINCREMENT_EXPR:
2001 case POSTDECREMENT_EXPR:
2002 case POSTINCREMENT_EXPR:
2003 /* All of these have side-effects, no matter what their
2012 case tcc_comparison: /* a comparison expression */
2013 case tcc_unary: /* a unary arithmetic expression */
2014 case tcc_binary: /* a binary arithmetic expression */
2015 case tcc_reference: /* a reference */
2016 case tcc_vl_exp: /* a function call */
2017 TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
2018 for (i = 0; i < len; ++i)
2020 tree op = TREE_OPERAND (t, i);
2021 if (op && TREE_SIDE_EFFECTS (op))
2022 TREE_SIDE_EFFECTS (t) = 1;
2027 /* No side-effects. */
2035 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
2039 : min_lval '[' val ']'
2041 | compound_lval '[' val ']'
2042 | compound_lval '.' ID
2044 This is not part of the original SIMPLE definition, which separates
2045 array and member references, but it seems reasonable to handle them
2046 together. Also, this way we don't run into problems with union
2047 aliasing; gcc requires that for accesses through a union to alias, the
2048 union reference must be explicit, which was not always the case when we
2049 were splitting up array and member refs.
2051 PRE_P points to the sequence where side effects that must happen before
2052 *EXPR_P should be stored.
2054 POST_P points to the sequence where side effects that must happen after
2055 *EXPR_P should be stored. */
2057 static enum gimplify_status
2058 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2059 fallback_t fallback)
2062 enum gimplify_status ret = GS_ALL_DONE, tret;
2064 location_t loc = EXPR_LOCATION (*expr_p);
2065 tree expr = *expr_p;
2067 /* Create a stack of the subexpressions so later we can walk them in
2068 order from inner to outer. */
2069 auto_vec<tree, 10> expr_stack;
2071 /* We can handle anything that get_inner_reference can deal with. */
2072 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
2075 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2076 if (TREE_CODE (*p) == INDIRECT_REF)
2077 *p = fold_indirect_ref_loc (loc, *p);
2079 if (handled_component_p (*p))
2081 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2082 additional COMPONENT_REFs. */
2083 else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
2084 && gimplify_var_or_parm_decl (p) == GS_OK)
2089 expr_stack.safe_push (*p);
2092 gcc_assert (expr_stack.length ());
2094 /* Now EXPR_STACK is a stack of pointers to all the refs we've
2095 walked through and P points to the innermost expression.
2097 Java requires that we elaborated nodes in source order. That
2098 means we must gimplify the inner expression followed by each of
2099 the indices, in order. But we can't gimplify the inner
2100 expression until we deal with any variable bounds, sizes, or
2101 positions in order to deal with PLACEHOLDER_EXPRs.
2103 So we do this in three steps. First we deal with the annotations
2104 for any variables in the components, then we gimplify the base,
2105 then we gimplify any indices, from left to right. */
2106 for (i = expr_stack.length () - 1; i >= 0; i--)
2108 tree t = expr_stack[i];
2110 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2112 /* Gimplify the low bound and element type size and put them into
2113 the ARRAY_REF. If these values are set, they have already been
2115 if (TREE_OPERAND (t, 2) == NULL_TREE)
2117 tree low = unshare_expr (array_ref_low_bound (t));
2118 if (!is_gimple_min_invariant (low))
2120 TREE_OPERAND (t, 2) = low;
2121 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2122 post_p, is_gimple_reg,
2124 ret = MIN (ret, tret);
2129 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2130 is_gimple_reg, fb_rvalue);
2131 ret = MIN (ret, tret);
2134 if (TREE_OPERAND (t, 3) == NULL_TREE)
2136 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
2137 tree elmt_size = unshare_expr (array_ref_element_size (t));
2138 tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
2140 /* Divide the element size by the alignment of the element
2143 = size_binop_loc (loc, EXACT_DIV_EXPR, elmt_size, factor);
2145 if (!is_gimple_min_invariant (elmt_size))
2147 TREE_OPERAND (t, 3) = elmt_size;
2148 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
2149 post_p, is_gimple_reg,
2151 ret = MIN (ret, tret);
2156 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
2157 is_gimple_reg, fb_rvalue);
2158 ret = MIN (ret, tret);
2161 else if (TREE_CODE (t) == COMPONENT_REF)
2163 /* Set the field offset into T and gimplify it. */
2164 if (TREE_OPERAND (t, 2) == NULL_TREE)
2166 tree offset = unshare_expr (component_ref_field_offset (t));
2167 tree field = TREE_OPERAND (t, 1);
2169 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
2171 /* Divide the offset by its alignment. */
2172 offset = size_binop_loc (loc, EXACT_DIV_EXPR, offset, factor);
2174 if (!is_gimple_min_invariant (offset))
2176 TREE_OPERAND (t, 2) = offset;
2177 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2178 post_p, is_gimple_reg,
2180 ret = MIN (ret, tret);
2185 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2186 is_gimple_reg, fb_rvalue);
2187 ret = MIN (ret, tret);
2192 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2193 so as to match the min_lval predicate. Failure to do so may result
2194 in the creation of large aggregate temporaries. */
2195 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
2196 fallback | fb_lvalue);
2197 ret = MIN (ret, tret);
2199 /* And finally, the indices and operands of ARRAY_REF. During this
2200 loop we also remove any useless conversions. */
2201 for (; expr_stack.length () > 0; )
2203 tree t = expr_stack.pop ();
2205 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2207 /* Gimplify the dimension. */
2208 if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
2210 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2211 is_gimple_val, fb_rvalue);
2212 ret = MIN (ret, tret);
2216 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
2218 /* The innermost expression P may have originally had
2219 TREE_SIDE_EFFECTS set which would have caused all the outer
2220 expressions in *EXPR_P leading to P to also have had
2221 TREE_SIDE_EFFECTS set. */
2222 recalculate_side_effects (t);
2225 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2226 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
2228 canonicalize_component_ref (expr_p);
2231 expr_stack.release ();
2233 gcc_assert (*expr_p == expr || ret != GS_ALL_DONE);
2238 /* Gimplify the self modifying expression pointed to by EXPR_P
2241 PRE_P points to the list where side effects that must happen before
2242 *EXPR_P should be stored.
2244 POST_P points to the list where side effects that must happen after
2245 *EXPR_P should be stored.
2247 WANT_VALUE is nonzero iff we want to use the value of this expression
2248 in another expression.
2250 ARITH_TYPE is the type the computation should be performed in. */
2252 enum gimplify_status
2253 gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2254 bool want_value, tree arith_type)
2256 enum tree_code code;
2257 tree lhs, lvalue, rhs, t1;
2258 gimple_seq post = NULL, *orig_post_p = post_p;
2260 enum tree_code arith_code;
2261 enum gimplify_status ret;
2262 location_t loc = EXPR_LOCATION (*expr_p);
2264 code = TREE_CODE (*expr_p);
2266 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
2267 || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
2269 /* Prefix or postfix? */
2270 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
2271 /* Faster to treat as prefix if result is not used. */
2272 postfix = want_value;
2276 /* For postfix, make sure the inner expression's post side effects
2277 are executed after side effects from this expression. */
2281 /* Add or subtract? */
2282 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2283 arith_code = PLUS_EXPR;
2285 arith_code = MINUS_EXPR;
2287 /* Gimplify the LHS into a GIMPLE lvalue. */
2288 lvalue = TREE_OPERAND (*expr_p, 0);
2289 ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
2290 if (ret == GS_ERROR)
2293 /* Extract the operands to the arithmetic operation. */
2295 rhs = TREE_OPERAND (*expr_p, 1);
2297 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2298 that as the result value and in the postqueue operation. */
2301 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
2302 if (ret == GS_ERROR)
2305 lhs = get_initialized_tmp_var (lhs, pre_p, NULL);
2308 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2309 if (POINTER_TYPE_P (TREE_TYPE (lhs)))
2311 rhs = convert_to_ptrofftype_loc (loc, rhs);
2312 if (arith_code == MINUS_EXPR)
2313 rhs = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (rhs), rhs);
2314 t1 = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (*expr_p), lhs, rhs);
2317 t1 = fold_convert (TREE_TYPE (*expr_p),
2318 fold_build2 (arith_code, arith_type,
2319 fold_convert (arith_type, lhs),
2320 fold_convert (arith_type, rhs)));
2324 gimplify_assign (lvalue, t1, pre_p);
2325 gimplify_seq_add_seq (orig_post_p, post);
2331 *expr_p = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
2336 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2339 maybe_with_size_expr (tree *expr_p)
2341 tree expr = *expr_p;
2342 tree type = TREE_TYPE (expr);
2345 /* If we've already wrapped this or the type is error_mark_node, we can't do
2347 if (TREE_CODE (expr) == WITH_SIZE_EXPR
2348 || type == error_mark_node)
2351 /* If the size isn't known or is a constant, we have nothing to do. */
2352 size = TYPE_SIZE_UNIT (type);
2353 if (!size || TREE_CODE (size) == INTEGER_CST)
2356 /* Otherwise, make a WITH_SIZE_EXPR. */
2357 size = unshare_expr (size);
2358 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
2359 *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
2362 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2363 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2364 the CALL_EXPR. If ALLOW_SSA is set the actual parameter may be
2365 gimplified to an SSA name. */
2367 enum gimplify_status
2368 gimplify_arg (tree *arg_p, gimple_seq *pre_p, location_t call_location,
2371 bool (*test) (tree);
2374 /* In general, we allow lvalues for function arguments to avoid
2375 extra overhead of copying large aggregates out of even larger
2376 aggregates into temporaries only to copy the temporaries to
2377 the argument list. Make optimizers happy by pulling out to
2378 temporaries those types that fit in registers. */
2379 if (is_gimple_reg_type (TREE_TYPE (*arg_p)))
2380 test = is_gimple_val, fb = fb_rvalue;
2383 test = is_gimple_lvalue, fb = fb_either;
2384 /* Also strip a TARGET_EXPR that would force an extra copy. */
2385 if (TREE_CODE (*arg_p) == TARGET_EXPR)
2387 tree init = TARGET_EXPR_INITIAL (*arg_p);
2389 && !VOID_TYPE_P (TREE_TYPE (init)))
2394 /* If this is a variable sized type, we must remember the size. */
2395 maybe_with_size_expr (arg_p);
2397 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2398 /* Make sure arguments have the same location as the function call
2400 protected_set_expr_location (*arg_p, call_location);
2402 /* There is a sequence point before a function call. Side effects in
2403 the argument list must occur before the actual call. So, when
2404 gimplifying arguments, force gimplify_expr to use an internal
2405 post queue which is then appended to the end of PRE_P. */
2406 return gimplify_expr (arg_p, pre_p, NULL, test, fb, allow_ssa);
2409 /* Don't fold inside offloading or taskreg regions: it can break code by
2410 adding decl references that weren't in the source. We'll do it during
2411 omplower pass instead. */
2414 maybe_fold_stmt (gimple_stmt_iterator *gsi)
2416 struct gimplify_omp_ctx *ctx;
2417 for (ctx = gimplify_omp_ctxp; ctx; ctx = ctx->outer_context)
2418 if ((ctx->region_type & (ORT_TARGET | ORT_PARALLEL | ORT_TASK)) != 0)
2420 return fold_stmt (gsi);
2423 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2424 WANT_VALUE is true if the result of the call is desired. */
2426 static enum gimplify_status
2427 gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
2429 tree fndecl, parms, p, fnptrtype;
2430 enum gimplify_status ret;
2433 bool builtin_va_start_p = false;
2434 location_t loc = EXPR_LOCATION (*expr_p);
2436 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2438 /* For reliable diagnostics during inlining, it is necessary that
2439 every call_expr be annotated with file and line. */
2440 if (! EXPR_HAS_LOCATION (*expr_p))
2441 SET_EXPR_LOCATION (*expr_p, input_location);
2443 /* Gimplify internal functions created in the FEs. */
2444 if (CALL_EXPR_FN (*expr_p) == NULL_TREE)
2449 nargs = call_expr_nargs (*expr_p);
2450 enum internal_fn ifn = CALL_EXPR_IFN (*expr_p);
2451 auto_vec<tree> vargs (nargs);
2453 for (i = 0; i < nargs; i++)
2455 gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
2456 EXPR_LOCATION (*expr_p));
2457 vargs.quick_push (CALL_EXPR_ARG (*expr_p, i));
2459 gimple *call = gimple_build_call_internal_vec (ifn, vargs);
2460 gimplify_seq_add_stmt (pre_p, call);
2464 /* This may be a call to a builtin function.
2466 Builtin function calls may be transformed into different
2467 (and more efficient) builtin function calls under certain
2468 circumstances. Unfortunately, gimplification can muck things
2469 up enough that the builtin expanders are not aware that certain
2470 transformations are still valid.
2472 So we attempt transformation/gimplification of the call before
2473 we gimplify the CALL_EXPR. At this time we do not manage to
2474 transform all calls in the same manner as the expanders do, but
2475 we do transform most of them. */
2476 fndecl = get_callee_fndecl (*expr_p);
2478 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
2479 switch (DECL_FUNCTION_CODE (fndecl))
2481 case BUILT_IN_ALLOCA:
2482 case BUILT_IN_ALLOCA_WITH_ALIGN:
2483 /* If the call has been built for a variable-sized object, then we
2484 want to restore the stack level when the enclosing BIND_EXPR is
2485 exited to reclaim the allocated space; otherwise, we precisely
2486 need to do the opposite and preserve the latest stack level. */
2487 if (CALL_ALLOCA_FOR_VAR_P (*expr_p))
2488 gimplify_ctxp->save_stack = true;
2490 gimplify_ctxp->keep_stack = true;
2493 case BUILT_IN_VA_START:
2495 builtin_va_start_p = TRUE;
2496 if (call_expr_nargs (*expr_p) < 2)
2498 error ("too few arguments to function %<va_start%>");
2499 *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2503 if (fold_builtin_next_arg (*expr_p, true))
2505 *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2514 if (fndecl && DECL_BUILT_IN (fndecl))
2516 tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2517 if (new_tree && new_tree != *expr_p)
2519 /* There was a transformation of this call which computes the
2520 same value, but in a more efficient way. Return and try
2527 /* Remember the original function pointer type. */
2528 fnptrtype = TREE_TYPE (CALL_EXPR_FN (*expr_p));
2530 /* There is a sequence point before the call, so any side effects in
2531 the calling expression must occur before the actual call. Force
2532 gimplify_expr to use an internal post queue. */
2533 ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
2534 is_gimple_call_addr, fb_rvalue);
2536 nargs = call_expr_nargs (*expr_p);
2538 /* Get argument types for verification. */
2539 fndecl = get_callee_fndecl (*expr_p);
2542 parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2544 parms = TYPE_ARG_TYPES (TREE_TYPE (fnptrtype));
2546 if (fndecl && DECL_ARGUMENTS (fndecl))
2547 p = DECL_ARGUMENTS (fndecl);
2552 for (i = 0; i < nargs && p; i++, p = TREE_CHAIN (p))
2555 /* If the last argument is __builtin_va_arg_pack () and it is not
2556 passed as a named argument, decrease the number of CALL_EXPR
2557 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2560 && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
2562 tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
2563 tree last_arg_fndecl = get_callee_fndecl (last_arg);
2566 && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
2567 && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
2568 && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
2570 tree call = *expr_p;
2573 *expr_p = build_call_array_loc (loc, TREE_TYPE (call),
2574 CALL_EXPR_FN (call),
2575 nargs, CALL_EXPR_ARGP (call));
2577 /* Copy all CALL_EXPR flags, location and block, except
2578 CALL_EXPR_VA_ARG_PACK flag. */
2579 CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
2580 CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
2581 CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
2582 = CALL_EXPR_RETURN_SLOT_OPT (call);
2583 CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
2584 SET_EXPR_LOCATION (*expr_p, EXPR_LOCATION (call));
2586 /* Set CALL_EXPR_VA_ARG_PACK. */
2587 CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
2591 /* If the call returns twice then after building the CFG the call
2592 argument computations will no longer dominate the call because
2593 we add an abnormal incoming edge to the call. So do not use SSA
2595 bool returns_twice = call_expr_flags (*expr_p) & ECF_RETURNS_TWICE;
2597 /* Gimplify the function arguments. */
2600 for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
2601 PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
2602 PUSH_ARGS_REVERSED ? i-- : i++)
2604 enum gimplify_status t;
2606 /* Avoid gimplifying the second argument to va_start, which needs to
2607 be the plain PARM_DECL. */
2608 if ((i != 1) || !builtin_va_start_p)
2610 t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
2611 EXPR_LOCATION (*expr_p), ! returns_twice);
2619 /* Gimplify the static chain. */
2620 if (CALL_EXPR_STATIC_CHAIN (*expr_p))
2622 if (fndecl && !DECL_STATIC_CHAIN (fndecl))
2623 CALL_EXPR_STATIC_CHAIN (*expr_p) = NULL;
2626 enum gimplify_status t;
2627 t = gimplify_arg (&CALL_EXPR_STATIC_CHAIN (*expr_p), pre_p,
2628 EXPR_LOCATION (*expr_p), ! returns_twice);
2634 /* Verify the function result. */
2635 if (want_value && fndecl
2636 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype))))
2638 error_at (loc, "using result of function returning %<void%>");
2642 /* Try this again in case gimplification exposed something. */
2643 if (ret != GS_ERROR)
2645 tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2647 if (new_tree && new_tree != *expr_p)
2649 /* There was a transformation of this call which computes the
2650 same value, but in a more efficient way. Return and try
2658 *expr_p = error_mark_node;
2662 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2663 decl. This allows us to eliminate redundant or useless
2664 calls to "const" functions. */
2665 if (TREE_CODE (*expr_p) == CALL_EXPR)
2667 int flags = call_expr_flags (*expr_p);
2668 if (flags & (ECF_CONST | ECF_PURE)
2669 /* An infinite loop is considered a side effect. */
2670 && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
2671 TREE_SIDE_EFFECTS (*expr_p) = 0;
2674 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2675 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2676 form and delegate the creation of a GIMPLE_CALL to
2677 gimplify_modify_expr. This is always possible because when
2678 WANT_VALUE is true, the caller wants the result of this call into
2679 a temporary, which means that we will emit an INIT_EXPR in
2680 internal_get_tmp_var which will then be handled by
2681 gimplify_modify_expr. */
2684 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2685 have to do is replicate it as a GIMPLE_CALL tuple. */
2686 gimple_stmt_iterator gsi;
2687 call = gimple_build_call_from_tree (*expr_p);
2688 gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
2689 notice_special_calls (call);
2690 gimplify_seq_add_stmt (pre_p, call);
2691 gsi = gsi_last (*pre_p);
2692 maybe_fold_stmt (&gsi);
2693 *expr_p = NULL_TREE;
2696 /* Remember the original function type. */
2697 CALL_EXPR_FN (*expr_p) = build1 (NOP_EXPR, fnptrtype,
2698 CALL_EXPR_FN (*expr_p));
2703 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2704 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2706 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2707 condition is true or false, respectively. If null, we should generate
2708 our own to skip over the evaluation of this specific expression.
2710 LOCUS is the source location of the COND_EXPR.
2712 This function is the tree equivalent of do_jump.
2714 shortcut_cond_r should only be called by shortcut_cond_expr. */
2717 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p,
2720 tree local_label = NULL_TREE;
2721 tree t, expr = NULL;
2723 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2724 retain the shortcut semantics. Just insert the gotos here;
2725 shortcut_cond_expr will append the real blocks later. */
2726 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2728 location_t new_locus;
2730 /* Turn if (a && b) into
2732 if (a); else goto no;
2733 if (b) goto yes; else goto no;
2736 if (false_label_p == NULL)
2737 false_label_p = &local_label;
2739 /* Keep the original source location on the first 'if'. */
2740 t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p, locus);
2741 append_to_statement_list (t, &expr);
2743 /* Set the source location of the && on the second 'if'. */
2744 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2745 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2747 append_to_statement_list (t, &expr);
2749 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2751 location_t new_locus;
2753 /* Turn if (a || b) into
2756 if (b) goto yes; else goto no;
2759 if (true_label_p == NULL)
2760 true_label_p = &local_label;
2762 /* Keep the original source location on the first 'if'. */
2763 t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL, locus);
2764 append_to_statement_list (t, &expr);
2766 /* Set the source location of the || on the second 'if'. */
2767 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2768 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2770 append_to_statement_list (t, &expr);
2772 else if (TREE_CODE (pred) == COND_EXPR
2773 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 1)))
2774 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 2))))
2776 location_t new_locus;
2778 /* As long as we're messing with gotos, turn if (a ? b : c) into
2780 if (b) goto yes; else goto no;
2782 if (c) goto yes; else goto no;
2784 Don't do this if one of the arms has void type, which can happen
2785 in C++ when the arm is throw. */
2787 /* Keep the original source location on the first 'if'. Set the source
2788 location of the ? on the second 'if'. */
2789 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2790 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2791 shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2792 false_label_p, locus),
2793 shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2794 false_label_p, new_locus));
2798 expr = build3 (COND_EXPR, void_type_node, pred,
2799 build_and_jump (true_label_p),
2800 build_and_jump (false_label_p));
2801 SET_EXPR_LOCATION (expr, locus);
2806 t = build1 (LABEL_EXPR, void_type_node, local_label);
2807 append_to_statement_list (t, &expr);
2813 /* Given a conditional expression EXPR with short-circuit boolean
2814 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2815 predicate apart into the equivalent sequence of conditionals. */
2818 shortcut_cond_expr (tree expr)
2820 tree pred = TREE_OPERAND (expr, 0);
2821 tree then_ = TREE_OPERAND (expr, 1);
2822 tree else_ = TREE_OPERAND (expr, 2);
2823 tree true_label, false_label, end_label, t;
2825 tree *false_label_p;
2826 bool emit_end, emit_false, jump_over_else;
2827 bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2828 bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2830 /* First do simple transformations. */
2833 /* If there is no 'else', turn
2836 if (a) if (b) then c. */
2837 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2839 /* Keep the original source location on the first 'if'. */
2840 location_t locus = EXPR_LOC_OR_LOC (expr, input_location);
2841 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2842 /* Set the source location of the && on the second 'if'. */
2843 if (EXPR_HAS_LOCATION (pred))
2844 SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2845 then_ = shortcut_cond_expr (expr);
2846 then_se = then_ && TREE_SIDE_EFFECTS (then_);
2847 pred = TREE_OPERAND (pred, 0);
2848 expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2849 SET_EXPR_LOCATION (expr, locus);
2855 /* If there is no 'then', turn
2858 if (a); else if (b); else d. */
2859 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2861 /* Keep the original source location on the first 'if'. */
2862 location_t locus = EXPR_LOC_OR_LOC (expr, input_location);
2863 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2864 /* Set the source location of the || on the second 'if'. */
2865 if (EXPR_HAS_LOCATION (pred))
2866 SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2867 else_ = shortcut_cond_expr (expr);
2868 else_se = else_ && TREE_SIDE_EFFECTS (else_);
2869 pred = TREE_OPERAND (pred, 0);
2870 expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2871 SET_EXPR_LOCATION (expr, locus);
2875 /* If we're done, great. */
2876 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2877 && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2880 /* Otherwise we need to mess with gotos. Change
2883 if (a); else goto no;
2886 and recursively gimplify the condition. */
2888 true_label = false_label = end_label = NULL_TREE;
2890 /* If our arms just jump somewhere, hijack those labels so we don't
2891 generate jumps to jumps. */
2894 && TREE_CODE (then_) == GOTO_EXPR
2895 && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2897 true_label = GOTO_DESTINATION (then_);
2903 && TREE_CODE (else_) == GOTO_EXPR
2904 && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2906 false_label = GOTO_DESTINATION (else_);
2911 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2913 true_label_p = &true_label;
2915 true_label_p = NULL;
2917 /* The 'else' branch also needs a label if it contains interesting code. */
2918 if (false_label || else_se)
2919 false_label_p = &false_label;
2921 false_label_p = NULL;
2923 /* If there was nothing else in our arms, just forward the label(s). */
2924 if (!then_se && !else_se)
2925 return shortcut_cond_r (pred, true_label_p, false_label_p,
2926 EXPR_LOC_OR_LOC (expr, input_location));
2928 /* If our last subexpression already has a terminal label, reuse it. */
2930 t = expr_last (else_);
2932 t = expr_last (then_);
2935 if (t && TREE_CODE (t) == LABEL_EXPR)
2936 end_label = LABEL_EXPR_LABEL (t);
2938 /* If we don't care about jumping to the 'else' branch, jump to the end
2939 if the condition is false. */
2941 false_label_p = &end_label;
2943 /* We only want to emit these labels if we aren't hijacking them. */
2944 emit_end = (end_label == NULL_TREE);
2945 emit_false = (false_label == NULL_TREE);
2947 /* We only emit the jump over the else clause if we have to--if the
2948 then clause may fall through. Otherwise we can wind up with a
2949 useless jump and a useless label at the end of gimplified code,
2950 which will cause us to think that this conditional as a whole
2951 falls through even if it doesn't. If we then inline a function
2952 which ends with such a condition, that can cause us to issue an
2953 inappropriate warning about control reaching the end of a
2954 non-void function. */
2955 jump_over_else = block_may_fallthru (then_);
2957 pred = shortcut_cond_r (pred, true_label_p, false_label_p,
2958 EXPR_LOC_OR_LOC (expr, input_location));
2961 append_to_statement_list (pred, &expr);
2963 append_to_statement_list (then_, &expr);
2968 tree last = expr_last (expr);
2969 t = build_and_jump (&end_label);
2970 if (EXPR_HAS_LOCATION (last))
2971 SET_EXPR_LOCATION (t, EXPR_LOCATION (last));
2972 append_to_statement_list (t, &expr);
2976 t = build1 (LABEL_EXPR, void_type_node, false_label);
2977 append_to_statement_list (t, &expr);
2979 append_to_statement_list (else_, &expr);
2981 if (emit_end && end_label)
2983 t = build1 (LABEL_EXPR, void_type_node, end_label);
2984 append_to_statement_list (t, &expr);
2990 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2993 gimple_boolify (tree expr)
2995 tree type = TREE_TYPE (expr);
2996 location_t loc = EXPR_LOCATION (expr);
2998 if (TREE_CODE (expr) == NE_EXPR
2999 && TREE_CODE (TREE_OPERAND (expr, 0)) == CALL_EXPR
3000 && integer_zerop (TREE_OPERAND (expr, 1)))
3002 tree call = TREE_OPERAND (expr, 0);
3003 tree fn = get_callee_fndecl (call);
3005 /* For __builtin_expect ((long) (x), y) recurse into x as well
3006 if x is truth_value_p. */
3008 && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
3009 && DECL_FUNCTION_CODE (fn) == BUILT_IN_EXPECT
3010 && call_expr_nargs (call) == 2)
3012 tree arg = CALL_EXPR_ARG (call, 0);
3015 if (TREE_CODE (arg) == NOP_EXPR
3016 && TREE_TYPE (arg) == TREE_TYPE (call))
3017 arg = TREE_OPERAND (arg, 0);
3018 if (truth_value_p (TREE_CODE (arg)))
3020 arg = gimple_boolify (arg);
3021 CALL_EXPR_ARG (call, 0)
3022 = fold_convert_loc (loc, TREE_TYPE (call), arg);
3028 switch (TREE_CODE (expr))
3030 case TRUTH_AND_EXPR:
3032 case TRUTH_XOR_EXPR:
3033 case TRUTH_ANDIF_EXPR:
3034 case TRUTH_ORIF_EXPR:
3035 /* Also boolify the arguments of truth exprs. */
3036 TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
3039 case TRUTH_NOT_EXPR:
3040 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
3042 /* These expressions always produce boolean results. */
3043 if (TREE_CODE (type) != BOOLEAN_TYPE)
3044 TREE_TYPE (expr) = boolean_type_node;
3048 switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)))
3050 case annot_expr_ivdep_kind:
3051 case annot_expr_no_vector_kind:
3052 case annot_expr_vector_kind:
3053 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
3054 if (TREE_CODE (type) != BOOLEAN_TYPE)
3055 TREE_TYPE (expr) = boolean_type_node;
3062 if (COMPARISON_CLASS_P (expr))
3064 /* There expressions always prduce boolean results. */
3065 if (TREE_CODE (type) != BOOLEAN_TYPE)
3066 TREE_TYPE (expr) = boolean_type_node;
3069 /* Other expressions that get here must have boolean values, but
3070 might need to be converted to the appropriate mode. */
3071 if (TREE_CODE (type) == BOOLEAN_TYPE)
3073 return fold_convert_loc (loc, boolean_type_node, expr);
3077 /* Given a conditional expression *EXPR_P without side effects, gimplify
3078 its operands. New statements are inserted to PRE_P. */
3080 static enum gimplify_status
3081 gimplify_pure_cond_expr (tree *expr_p, gimple_seq *pre_p)
3083 tree expr = *expr_p, cond;
3084 enum gimplify_status ret, tret;
3085 enum tree_code code;
3087 cond = gimple_boolify (COND_EXPR_COND (expr));
3089 /* We need to handle && and || specially, as their gimplification
3090 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
3091 code = TREE_CODE (cond);
3092 if (code == TRUTH_ANDIF_EXPR)
3093 TREE_SET_CODE (cond, TRUTH_AND_EXPR);
3094 else if (code == TRUTH_ORIF_EXPR)
3095 TREE_SET_CODE (cond, TRUTH_OR_EXPR);
3096 ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
3097 COND_EXPR_COND (*expr_p) = cond;
3099 tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
3100 is_gimple_val, fb_rvalue);
3101 ret = MIN (ret, tret);
3102 tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
3103 is_gimple_val, fb_rvalue);
3105 return MIN (ret, tret);
3108 /* Return true if evaluating EXPR could trap.
3109 EXPR is GENERIC, while tree_could_trap_p can be called
3113 generic_expr_could_trap_p (tree expr)
3117 if (!expr || is_gimple_val (expr))
3120 if (!EXPR_P (expr) || tree_could_trap_p (expr))
3123 n = TREE_OPERAND_LENGTH (expr);
3124 for (i = 0; i < n; i++)
3125 if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
3131 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3140 The second form is used when *EXPR_P is of type void.
3142 PRE_P points to the list where side effects that must happen before
3143 *EXPR_P should be stored. */
3145 static enum gimplify_status
3146 gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
3148 tree expr = *expr_p;
3149 tree type = TREE_TYPE (expr);
3150 location_t loc = EXPR_LOCATION (expr);
3151 tree tmp, arm1, arm2;
3152 enum gimplify_status ret;
3153 tree label_true, label_false, label_cont;
3154 bool have_then_clause_p, have_else_clause_p;
3156 enum tree_code pred_code;
3157 gimple_seq seq = NULL;
3159 /* If this COND_EXPR has a value, copy the values into a temporary within
3161 if (!VOID_TYPE_P (type))
3163 tree then_ = TREE_OPERAND (expr, 1), else_ = TREE_OPERAND (expr, 2);
3166 /* If either an rvalue is ok or we do not require an lvalue, create the
3167 temporary. But we cannot do that if the type is addressable. */
3168 if (((fallback & fb_rvalue) || !(fallback & fb_lvalue))
3169 && !TREE_ADDRESSABLE (type))
3171 if (gimplify_ctxp->allow_rhs_cond_expr
3172 /* If either branch has side effects or could trap, it can't be
3173 evaluated unconditionally. */
3174 && !TREE_SIDE_EFFECTS (then_)
3175 && !generic_expr_could_trap_p (then_)
3176 && !TREE_SIDE_EFFECTS (else_)
3177 && !generic_expr_could_trap_p (else_))
3178 return gimplify_pure_cond_expr (expr_p, pre_p);
3180 tmp = create_tmp_var (type, "iftmp");
3184 /* Otherwise, only create and copy references to the values. */
3187 type = build_pointer_type (type);
3189 if (!VOID_TYPE_P (TREE_TYPE (then_)))
3190 then_ = build_fold_addr_expr_loc (loc, then_);
3192 if (!VOID_TYPE_P (TREE_TYPE (else_)))
3193 else_ = build_fold_addr_expr_loc (loc, else_);
3196 = build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), then_, else_);
3198 tmp = create_tmp_var (type, "iftmp");
3199 result = build_simple_mem_ref_loc (loc, tmp);
3202 /* Build the new then clause, `tmp = then_;'. But don't build the
3203 assignment if the value is void; in C++ it can be if it's a throw. */
3204 if (!VOID_TYPE_P (TREE_TYPE (then_)))
3205 TREE_OPERAND (expr, 1) = build2 (MODIFY_EXPR, type, tmp, then_);
3207 /* Similarly, build the new else clause, `tmp = else_;'. */
3208 if (!VOID_TYPE_P (TREE_TYPE (else_)))
3209 TREE_OPERAND (expr, 2) = build2 (MODIFY_EXPR, type, tmp, else_);
3211 TREE_TYPE (expr) = void_type_node;
3212 recalculate_side_effects (expr);
3214 /* Move the COND_EXPR to the prequeue. */
3215 gimplify_stmt (&expr, pre_p);
3221 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
3222 STRIP_TYPE_NOPS (TREE_OPERAND (expr, 0));
3223 if (TREE_CODE (TREE_OPERAND (expr, 0)) == COMPOUND_EXPR)
3224 gimplify_compound_expr (&TREE_OPERAND (expr, 0), pre_p, true);
3226 /* Make sure the condition has BOOLEAN_TYPE. */
3227 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
3229 /* Break apart && and || conditions. */
3230 if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
3231 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
3233 expr = shortcut_cond_expr (expr);
3235 if (expr != *expr_p)
3239 /* We can't rely on gimplify_expr to re-gimplify the expanded
3240 form properly, as cleanups might cause the target labels to be
3241 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3242 set up a conditional context. */
3243 gimple_push_condition ();
3244 gimplify_stmt (expr_p, &seq);
3245 gimple_pop_condition (pre_p);
3246 gimple_seq_add_seq (pre_p, seq);
3252 /* Now do the normal gimplification. */
3254 /* Gimplify condition. */
3255 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, is_gimple_condexpr,
3257 if (ret == GS_ERROR)
3259 gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
3261 gimple_push_condition ();
3263 have_then_clause_p = have_else_clause_p = false;
3264 if (TREE_OPERAND (expr, 1) != NULL
3265 && TREE_CODE (TREE_OPERAND (expr, 1)) == GOTO_EXPR
3266 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 1))) == LABEL_DECL
3267 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 1)))
3268 == current_function_decl)
3269 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3270 have different locations, otherwise we end up with incorrect
3271 location information on the branches. */
3273 || !EXPR_HAS_LOCATION (expr)
3274 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 1))
3275 || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 1))))
3277 label_true = GOTO_DESTINATION (TREE_OPERAND (expr, 1));
3278 have_then_clause_p = true;
3281 label_true = create_artificial_label (UNKNOWN_LOCATION);
3282 if (TREE_OPERAND (expr, 2) != NULL
3283 && TREE_CODE (TREE_OPERAND (expr, 2)) == GOTO_EXPR
3284 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 2))) == LABEL_DECL
3285 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 2)))
3286 == current_function_decl)
3287 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3288 have different locations, otherwise we end up with incorrect
3289 location information on the branches. */
3291 || !EXPR_HAS_LOCATION (expr)
3292 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 2))
3293 || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 2))))
3295 label_false = GOTO_DESTINATION (TREE_OPERAND (expr, 2));
3296 have_else_clause_p = true;
3299 label_false = create_artificial_label (UNKNOWN_LOCATION);
3301 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
3303 cond_stmt = gimple_build_cond (pred_code, arm1, arm2, label_true,
3305 gimple_set_no_warning (cond_stmt, TREE_NO_WARNING (COND_EXPR_COND (expr)));
3306 gimplify_seq_add_stmt (&seq, cond_stmt);
3307 gimple_stmt_iterator gsi = gsi_last (seq);
3308 maybe_fold_stmt (&gsi);
3310 label_cont = NULL_TREE;
3311 if (!have_then_clause_p)
3313 /* For if (...) {} else { code; } put label_true after
3315 if (TREE_OPERAND (expr, 1) == NULL_TREE
3316 && !have_else_clause_p
3317 && TREE_OPERAND (expr, 2) != NULL_TREE)
3318 label_cont = label_true;
3321 gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
3322 have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
3323 /* For if (...) { code; } else {} or
3324 if (...) { code; } else goto label; or
3325 if (...) { code; return; } else { ... }
3326 label_cont isn't needed. */
3327 if (!have_else_clause_p
3328 && TREE_OPERAND (expr, 2) != NULL_TREE
3329 && gimple_seq_may_fallthru (seq))
3332 label_cont = create_artificial_label (UNKNOWN_LOCATION);
3334 g = gimple_build_goto (label_cont);
3336 /* GIMPLE_COND's are very low level; they have embedded
3337 gotos. This particular embedded goto should not be marked
3338 with the location of the original COND_EXPR, as it would
3339 correspond to the COND_EXPR's condition, not the ELSE or the
3340 THEN arms. To avoid marking it with the wrong location, flag
3341 it as "no location". */
3342 gimple_set_do_not_emit_location (g);
3344 gimplify_seq_add_stmt (&seq, g);
3348 if (!have_else_clause_p)
3350 gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
3351 have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
3354 gimplify_seq_add_stmt (&seq, gimple_build_label (label_cont));
3356 gimple_pop_condition (pre_p);
3357 gimple_seq_add_seq (pre_p, seq);
3359 if (ret == GS_ERROR)
3361 else if (have_then_clause_p || have_else_clause_p)
3365 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3366 expr = TREE_OPERAND (expr, 0);
3367 gimplify_stmt (&expr, pre_p);
3374 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3375 to be marked addressable.
3377 We cannot rely on such an expression being directly markable if a temporary
3378 has been created by the gimplification. In this case, we create another
3379 temporary and initialize it with a copy, which will become a store after we
3380 mark it addressable. This can happen if the front-end passed us something
3381 that it could not mark addressable yet, like a Fortran pass-by-reference
3382 parameter (int) floatvar. */
3385 prepare_gimple_addressable (tree *expr_p, gimple_seq *seq_p)
3387 while (handled_component_p (*expr_p))
3388 expr_p = &TREE_OPERAND (*expr_p, 0);
3389 if (is_gimple_reg (*expr_p))
3391 /* Do not allow an SSA name as the temporary. */
3392 tree var = get_initialized_tmp_var (*expr_p, seq_p, NULL, false);
3393 DECL_GIMPLE_REG_P (var) = 0;
3398 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3399 a call to __builtin_memcpy. */
3401 static enum gimplify_status
3402 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
3405 tree t, to, to_ptr, from, from_ptr;
3407 location_t loc = EXPR_LOCATION (*expr_p);
3409 to = TREE_OPERAND (*expr_p, 0);
3410 from = TREE_OPERAND (*expr_p, 1);
3412 /* Mark the RHS addressable. Beware that it may not be possible to do so
3413 directly if a temporary has been created by the gimplification. */
3414 prepare_gimple_addressable (&from, seq_p);
3416 mark_addressable (from);
3417 from_ptr = build_fold_addr_expr_loc (loc, from);
3418 gimplify_arg (&from_ptr, seq_p, loc);
3420 mark_addressable (to);
3421 to_ptr = build_fold_addr_expr_loc (loc, to);
3422 gimplify_arg (&to_ptr, seq_p, loc);
3424 t = builtin_decl_implicit (BUILT_IN_MEMCPY);
3426 gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
3430 /* tmp = memcpy() */
3431 t = create_tmp_var (TREE_TYPE (to_ptr));
3432 gimple_call_set_lhs (gs, t);
3433 gimplify_seq_add_stmt (seq_p, gs);
3435 *expr_p = build_simple_mem_ref (t);
3439 gimplify_seq_add_stmt (seq_p, gs);
3444 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3445 a call to __builtin_memset. In this case we know that the RHS is
3446 a CONSTRUCTOR with an empty element list. */
3448 static enum gimplify_status
3449 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
3452 tree t, from, to, to_ptr;
3454 location_t loc = EXPR_LOCATION (*expr_p);
3456 /* Assert our assumptions, to abort instead of producing wrong code
3457 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3458 not be immediately exposed. */
3459 from = TREE_OPERAND (*expr_p, 1);
3460 if (TREE_CODE (from) == WITH_SIZE_EXPR)
3461 from = TREE_OPERAND (from, 0);
3463 gcc_assert (TREE_CODE (from) == CONSTRUCTOR
3464 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from)));
3467 to = TREE_OPERAND (*expr_p, 0);
3469 to_ptr = build_fold_addr_expr_loc (loc, to);
3470 gimplify_arg (&to_ptr, seq_p, loc);
3471 t = builtin_decl_implicit (BUILT_IN_MEMSET);
3473 gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
3477 /* tmp = memset() */
3478 t = create_tmp_var (TREE_TYPE (to_ptr));
3479 gimple_call_set_lhs (gs, t);
3480 gimplify_seq_add_stmt (seq_p, gs);
3482 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3486 gimplify_seq_add_stmt (seq_p, gs);
3491 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3492 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3493 assignment. Return non-null if we detect a potential overlap. */
3495 struct gimplify_init_ctor_preeval_data
3497 /* The base decl of the lhs object. May be NULL, in which case we
3498 have to assume the lhs is indirect. */
3501 /* The alias set of the lhs object. */
3502 alias_set_type lhs_alias_set;
3506 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
3508 struct gimplify_init_ctor_preeval_data *data
3509 = (struct gimplify_init_ctor_preeval_data *) xdata;
3512 /* If we find the base object, obviously we have overlap. */
3513 if (data->lhs_base_decl == t)
3516 /* If the constructor component is indirect, determine if we have a
3517 potential overlap with the lhs. The only bits of information we
3518 have to go on at this point are addressability and alias sets. */
3519 if ((INDIRECT_REF_P (t)
3520 || TREE_CODE (t) == MEM_REF)
3521 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3522 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
3525 /* If the constructor component is a call, determine if it can hide a
3526 potential overlap with the lhs through an INDIRECT_REF like above.
3527 ??? Ugh - this is completely broken. In fact this whole analysis
3528 doesn't look conservative. */
3529 if (TREE_CODE (t) == CALL_EXPR)
3531 tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
3533 for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
3534 if (POINTER_TYPE_P (TREE_VALUE (type))
3535 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3536 && alias_sets_conflict_p (data->lhs_alias_set,
3538 (TREE_TYPE (TREE_VALUE (type)))))
3542 if (IS_TYPE_OR_DECL_P (t))
3547 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3548 force values that overlap with the lhs (as described by *DATA)
3549 into temporaries. */
3552 gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3553 struct gimplify_init_ctor_preeval_data *data)
3555 enum gimplify_status one;
3557 /* If the value is constant, then there's nothing to pre-evaluate. */
3558 if (TREE_CONSTANT (*expr_p))
3560 /* Ensure it does not have side effects, it might contain a reference to
3561 the object we're initializing. */
3562 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
3566 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3567 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
3570 /* Recurse for nested constructors. */
3571 if (TREE_CODE (*expr_p) == CONSTRUCTOR)
3573 unsigned HOST_WIDE_INT ix;
3574 constructor_elt *ce;
3575 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (*expr_p);
3577 FOR_EACH_VEC_SAFE_ELT (v, ix, ce)
3578 gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
3583 /* If this is a variable sized type, we must remember the size. */
3584 maybe_with_size_expr (expr_p);
3586 /* Gimplify the constructor element to something appropriate for the rhs
3587 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3588 the gimplifier will consider this a store to memory. Doing this
3589 gimplification now means that we won't have to deal with complicated
3590 language-specific trees, nor trees like SAVE_EXPR that can induce
3591 exponential search behavior. */
3592 one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
3593 if (one == GS_ERROR)
3599 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3600 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3601 always be true for all scalars, since is_gimple_mem_rhs insists on a
3602 temporary variable for them. */
3603 if (DECL_P (*expr_p))
3606 /* If this is of variable size, we have no choice but to assume it doesn't
3607 overlap since we can't make a temporary for it. */
3608 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
3611 /* Otherwise, we must search for overlap ... */
3612 if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
3615 /* ... and if found, force the value into a temporary. */
3616 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
3619 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3620 a RANGE_EXPR in a CONSTRUCTOR for an array.
3624 object[var] = value;
3631 We increment var _after_ the loop exit check because we might otherwise
3632 fail if upper == TYPE_MAX_VALUE (type for upper).
3634 Note that we never have to deal with SAVE_EXPRs here, because this has
3635 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3637 static void gimplify_init_ctor_eval (tree, vec<constructor_elt, va_gc> *,
3638 gimple_seq *, bool);
3641 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
3642 tree value, tree array_elt_type,
3643 gimple_seq *pre_p, bool cleared)
3645 tree loop_entry_label, loop_exit_label, fall_thru_label;
3646 tree var, var_type, cref, tmp;
3648 loop_entry_label = create_artificial_label (UNKNOWN_LOCATION);
3649 loop_exit_label = create_artificial_label (UNKNOWN_LOCATION);
3650 fall_thru_label = create_artificial_label (UNKNOWN_LOCATION);
3652 /* Create and initialize the index variable. */
3653 var_type = TREE_TYPE (upper);
3654 var = create_tmp_var (var_type);
3655 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
3657 /* Add the loop entry label. */
3658 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
3660 /* Build the reference. */
3661 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3662 var, NULL_TREE, NULL_TREE);
3664 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3665 the store. Otherwise just assign value to the reference. */
3667 if (TREE_CODE (value) == CONSTRUCTOR)
3668 /* NB we might have to call ourself recursively through
3669 gimplify_init_ctor_eval if the value is a constructor. */
3670 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3673 gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
3675 /* We exit the loop when the index var is equal to the upper bound. */
3676 gimplify_seq_add_stmt (pre_p,
3677 gimple_build_cond (EQ_EXPR, var, upper,
3678 loop_exit_label, fall_thru_label));
3680 gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
3682 /* Otherwise, increment the index var... */
3683 tmp = build2 (PLUS_EXPR, var_type, var,
3684 fold_convert (var_type, integer_one_node));
3685 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
3687 /* ...and jump back to the loop entry. */
3688 gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
3690 /* Add the loop exit label. */
3691 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
3694 /* Return true if FDECL is accessing a field that is zero sized. */
3697 zero_sized_field_decl (const_tree fdecl)
3699 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
3700 && integer_zerop (DECL_SIZE (fdecl)))
3705 /* Return true if TYPE is zero sized. */
3708 zero_sized_type (const_tree type)
3710 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
3711 && integer_zerop (TYPE_SIZE (type)))
3716 /* A subroutine of gimplify_init_constructor. Generate individual
3717 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3718 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3719 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3723 gimplify_init_ctor_eval (tree object, vec<constructor_elt, va_gc> *elts,
3724 gimple_seq *pre_p, bool cleared)
3726 tree array_elt_type = NULL;
3727 unsigned HOST_WIDE_INT ix;
3728 tree purpose, value;
3730 if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
3731 array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
3733 FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
3737 /* NULL values are created above for gimplification errors. */
3741 if (cleared && initializer_zerop (value))
3744 /* ??? Here's to hoping the front end fills in all of the indices,
3745 so we don't have to figure out what's missing ourselves. */
3746 gcc_assert (purpose);
3748 /* Skip zero-sized fields, unless value has side-effects. This can
3749 happen with calls to functions returning a zero-sized type, which
3750 we shouldn't discard. As a number of downstream passes don't
3751 expect sets of zero-sized fields, we rely on the gimplification of
3752 the MODIFY_EXPR we make below to drop the assignment statement. */
3753 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
3756 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3758 if (TREE_CODE (purpose) == RANGE_EXPR)
3760 tree lower = TREE_OPERAND (purpose, 0);
3761 tree upper = TREE_OPERAND (purpose, 1);
3763 /* If the lower bound is equal to upper, just treat it as if
3764 upper was the index. */
3765 if (simple_cst_equal (lower, upper))
3769 gimplify_init_ctor_eval_range (object, lower, upper, value,
3770 array_elt_type, pre_p, cleared);
3777 /* Do not use bitsizetype for ARRAY_REF indices. */
3778 if (TYPE_DOMAIN (TREE_TYPE (object)))
3780 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
3782 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3783 purpose, NULL_TREE, NULL_TREE);
3787 gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
3788 cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
3789 unshare_expr (object), purpose, NULL_TREE);
3792 if (TREE_CODE (value) == CONSTRUCTOR
3793 && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
3794 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3798 tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
3799 gimplify_and_add (init, pre_p);
3805 /* Return the appropriate RHS predicate for this LHS. */
3808 rhs_predicate_for (tree lhs)
3810 if (is_gimple_reg (lhs))
3811 return is_gimple_reg_rhs_or_call;
3813 return is_gimple_mem_rhs_or_call;
3816 /* Return the initial guess for an appropriate RHS predicate for this LHS,
3817 before the LHS has been gimplified. */
3819 static gimple_predicate
3820 initial_rhs_predicate_for (tree lhs)
3822 if (is_gimple_reg_type (TREE_TYPE (lhs)))
3823 return is_gimple_reg_rhs_or_call;
3825 return is_gimple_mem_rhs_or_call;
3828 /* Gimplify a C99 compound literal expression. This just means adding
3829 the DECL_EXPR before the current statement and using its anonymous
3832 static enum gimplify_status
3833 gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p,
3834 bool (*gimple_test_f) (tree),
3835 fallback_t fallback)
3837 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
3838 tree decl = DECL_EXPR_DECL (decl_s);
3839 tree init = DECL_INITIAL (decl);
3840 /* Mark the decl as addressable if the compound literal
3841 expression is addressable now, otherwise it is marked too late
3842 after we gimplify the initialization expression. */
3843 if (TREE_ADDRESSABLE (*expr_p))
3844 TREE_ADDRESSABLE (decl) = 1;
3845 /* Otherwise, if we don't need an lvalue and have a literal directly
3846 substitute it. Check if it matches the gimple predicate, as
3847 otherwise we'd generate a new temporary, and we can as well just
3848 use the decl we already have. */
3849 else if (!TREE_ADDRESSABLE (decl)
3851 && (fallback & fb_lvalue) == 0
3852 && gimple_test_f (init))
3858 /* Preliminarily mark non-addressed complex variables as eligible
3859 for promotion to gimple registers. We'll transform their uses
3861 if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
3862 || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
3863 && !TREE_THIS_VOLATILE (decl)
3864 && !needs_to_live_in_memory (decl))
3865 DECL_GIMPLE_REG_P (decl) = 1;
3867 /* If the decl is not addressable, then it is being used in some
3868 expression or on the right hand side of a statement, and it can
3869 be put into a readonly data section. */
3870 if (!TREE_ADDRESSABLE (decl) && (fallback & fb_lvalue) == 0)
3871 TREE_READONLY (decl) = 1;
3873 /* This decl isn't mentioned in the enclosing block, so add it to the
3874 list of temps. FIXME it seems a bit of a kludge to say that
3875 anonymous artificial vars aren't pushed, but everything else is. */
3876 if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
3877 gimple_add_tmp_var (decl);
3879 gimplify_and_add (decl_s, pre_p);
3884 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3885 return a new CONSTRUCTOR if something changed. */
3888 optimize_compound_literals_in_ctor (tree orig_ctor)
3890 tree ctor = orig_ctor;
3891 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ctor);
3892 unsigned int idx, num = vec_safe_length (elts);
3894 for (idx = 0; idx < num; idx++)
3896 tree value = (*elts)[idx].value;
3897 tree newval = value;
3898 if (TREE_CODE (value) == CONSTRUCTOR)
3899 newval = optimize_compound_literals_in_ctor (value);
3900 else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
3902 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (value);
3903 tree decl = DECL_EXPR_DECL (decl_s);
3904 tree init = DECL_INITIAL (decl);
3906 if (!TREE_ADDRESSABLE (value)
3907 && !TREE_ADDRESSABLE (decl)
3909 && TREE_CODE (init) == CONSTRUCTOR)
3910 newval = optimize_compound_literals_in_ctor (init);
3912 if (newval == value)
3915 if (ctor == orig_ctor)
3917 ctor = copy_node (orig_ctor);
3918 CONSTRUCTOR_ELTS (ctor) = vec_safe_copy (elts);
3919 elts = CONSTRUCTOR_ELTS (ctor);
3921 (*elts)[idx].value = newval;
3926 /* A subroutine of gimplify_modify_expr. Break out elements of a
3927 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3929 Note that we still need to clear any elements that don't have explicit
3930 initializers, so if not all elements are initialized we keep the
3931 original MODIFY_EXPR, we just remove all of the constructor elements.
3933 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3934 GS_ERROR if we would have to create a temporary when gimplifying
3935 this constructor. Otherwise, return GS_OK.
3937 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3939 static enum gimplify_status
3940 gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3941 bool want_value, bool notify_temp_creation)
3943 tree object, ctor, type;
3944 enum gimplify_status ret;
3945 vec<constructor_elt, va_gc> *elts;
3947 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR);
3949 if (!notify_temp_creation)
3951 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3952 is_gimple_lvalue, fb_lvalue);
3953 if (ret == GS_ERROR)
3957 object = TREE_OPERAND (*expr_p, 0);
3958 ctor = TREE_OPERAND (*expr_p, 1) =
3959 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p, 1));
3960 type = TREE_TYPE (ctor);
3961 elts = CONSTRUCTOR_ELTS (ctor);
3964 switch (TREE_CODE (type))
3968 case QUAL_UNION_TYPE:
3971 struct gimplify_init_ctor_preeval_data preeval_data;
3972 HOST_WIDE_INT num_ctor_elements, num_nonzero_elements;
3973 bool cleared, complete_p, valid_const_initializer;
3975 /* Aggregate types must lower constructors to initialization of
3976 individual elements. The exception is that a CONSTRUCTOR node
3977 with no elements indicates zero-initialization of the whole. */
3978 if (vec_safe_is_empty (elts))
3980 if (notify_temp_creation)
3985 /* Fetch information about the constructor to direct later processing.
3986 We might want to make static versions of it in various cases, and
3987 can only do so if it known to be a valid constant initializer. */
3988 valid_const_initializer
3989 = categorize_ctor_elements (ctor, &num_nonzero_elements,
3990 &num_ctor_elements, &complete_p);
3992 /* If a const aggregate variable is being initialized, then it
3993 should never be a lose to promote the variable to be static. */
3994 if (valid_const_initializer
3995 && num_nonzero_elements > 1
3996 && TREE_READONLY (object)
3997 && TREE_CODE (object) == VAR_DECL
3998 && (flag_merge_constants >= 2 || !TREE_ADDRESSABLE (object)))
4000 if (notify_temp_creation)
4002 DECL_INITIAL (object) = ctor;
4003 TREE_STATIC (object) = 1;
4004 if (!DECL_NAME (object))
4005 DECL_NAME (object) = create_tmp_var_name ("C");
4006 walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
4008 /* ??? C++ doesn't automatically append a .<number> to the
4009 assembler name, and even when it does, it looks at FE private
4010 data structures to figure out what that number should be,
4011 which are not set for this variable. I suppose this is
4012 important for local statics for inline functions, which aren't
4013 "local" in the object file sense. So in order to get a unique
4014 TU-local symbol, we must invoke the lhd version now. */
4015 lhd_set_decl_assembler_name (object);
4017 *expr_p = NULL_TREE;
4021 /* If there are "lots" of initialized elements, even discounting
4022 those that are not address constants (and thus *must* be
4023 computed at runtime), then partition the constructor into
4024 constant and non-constant parts. Block copy the constant
4025 parts in, then generate code for the non-constant parts. */
4026 /* TODO. There's code in cp/typeck.c to do this. */
4028 if (int_size_in_bytes (TREE_TYPE (ctor)) < 0)
4029 /* store_constructor will ignore the clearing of variable-sized
4030 objects. Initializers for such objects must explicitly set
4031 every field that needs to be set. */
4033 else if (!complete_p && !CONSTRUCTOR_NO_CLEARING (ctor))
4034 /* If the constructor isn't complete, clear the whole object
4035 beforehand, unless CONSTRUCTOR_NO_CLEARING is set on it.
4037 ??? This ought not to be needed. For any element not present
4038 in the initializer, we should simply set them to zero. Except
4039 we'd need to *find* the elements that are not present, and that
4040 requires trickery to avoid quadratic compile-time behavior in
4041 large cases or excessive memory use in small cases. */
4043 else if (num_ctor_elements - num_nonzero_elements
4044 > CLEAR_RATIO (optimize_function_for_speed_p (cfun))
4045 && num_nonzero_elements < num_ctor_elements / 4)
4046 /* If there are "lots" of zeros, it's more efficient to clear
4047 the memory and then set the nonzero elements. */
4052 /* If there are "lots" of initialized elements, and all of them
4053 are valid address constants, then the entire initializer can
4054 be dropped to memory, and then memcpy'd out. Don't do this
4055 for sparse arrays, though, as it's more efficient to follow
4056 the standard CONSTRUCTOR behavior of memset followed by
4057 individual element initialization. Also don't do this for small
4058 all-zero initializers (which aren't big enough to merit
4059 clearing), and don't try to make bitwise copies of
4060 TREE_ADDRESSABLE types.
4062 We cannot apply such transformation when compiling chkp static
4063 initializer because creation of initializer image in the memory
4064 will require static initialization of bounds for it. It should
4065 result in another gimplification of similar initializer and we
4066 may fall into infinite loop. */
4067 if (valid_const_initializer
4068 && !(cleared || num_nonzero_elements == 0)
4069 && !TREE_ADDRESSABLE (type)
4070 && (!current_function_decl
4071 || !lookup_attribute ("chkp ctor",
4072 DECL_ATTRIBUTES (current_function_decl))))
4074 HOST_WIDE_INT size = int_size_in_bytes (type);
4077 /* ??? We can still get unbounded array types, at least
4078 from the C++ front end. This seems wrong, but attempt
4079 to work around it for now. */
4082 size = int_size_in_bytes (TREE_TYPE (object));
4084 TREE_TYPE (ctor) = type = TREE_TYPE (object);
4087 /* Find the maximum alignment we can assume for the object. */
4088 /* ??? Make use of DECL_OFFSET_ALIGN. */
4089 if (DECL_P (object))
4090 align = DECL_ALIGN (object);
4092 align = TYPE_ALIGN (type);
4094 /* Do a block move either if the size is so small as to make
4095 each individual move a sub-unit move on average, or if it
4096 is so large as to make individual moves inefficient. */
4098 && num_nonzero_elements > 1
4099 && (size < num_nonzero_elements
4100 || !can_move_by_pieces (size, align)))
4102 if (notify_temp_creation)
4105 walk_tree (&ctor, force_labels_r, NULL, NULL);
4106 ctor = tree_output_constant_def (ctor);
4107 if (!useless_type_conversion_p (type, TREE_TYPE (ctor)))
4108 ctor = build1 (VIEW_CONVERT_EXPR, type, ctor);
4109 TREE_OPERAND (*expr_p, 1) = ctor;
4111 /* This is no longer an assignment of a CONSTRUCTOR, but
4112 we still may have processing to do on the LHS. So
4113 pretend we didn't do anything here to let that happen. */
4114 return GS_UNHANDLED;
4118 /* If the target is volatile, we have non-zero elements and more than
4119 one field to assign, initialize the target from a temporary. */
4120 if (TREE_THIS_VOLATILE (object)
4121 && !TREE_ADDRESSABLE (type)
4122 && num_nonzero_elements > 0
4123 && vec_safe_length (elts) > 1)
4125 tree temp = create_tmp_var (TYPE_MAIN_VARIANT (type));
4126 TREE_OPERAND (*expr_p, 0) = temp;
4127 *expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
4129 build2 (MODIFY_EXPR, void_type_node,
4134 if (notify_temp_creation)
4137 /* If there are nonzero elements and if needed, pre-evaluate to capture
4138 elements overlapping with the lhs into temporaries. We must do this
4139 before clearing to fetch the values before they are zeroed-out. */
4140 if (num_nonzero_elements > 0 && TREE_CODE (*expr_p) != INIT_EXPR)
4142 preeval_data.lhs_base_decl = get_base_address (object);
4143 if (!DECL_P (preeval_data.lhs_base_decl))
4144 preeval_data.lhs_base_decl = NULL;
4145 preeval_data.lhs_alias_set = get_alias_set (object);
4147 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
4148 pre_p, post_p, &preeval_data);
4151 bool ctor_has_side_effects_p
4152 = TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1));
4156 /* Zap the CONSTRUCTOR element list, which simplifies this case.
4157 Note that we still have to gimplify, in order to handle the
4158 case of variable sized types. Avoid shared tree structures. */
4159 CONSTRUCTOR_ELTS (ctor) = NULL;
4160 TREE_SIDE_EFFECTS (ctor) = 0;
4161 object = unshare_expr (object);
4162 gimplify_stmt (expr_p, pre_p);
4165 /* If we have not block cleared the object, or if there are nonzero
4166 elements in the constructor, or if the constructor has side effects,
4167 add assignments to the individual scalar fields of the object. */
4169 || num_nonzero_elements > 0
4170 || ctor_has_side_effects_p)
4171 gimplify_init_ctor_eval (object, elts, pre_p, cleared);
4173 *expr_p = NULL_TREE;
4181 if (notify_temp_creation)
4184 /* Extract the real and imaginary parts out of the ctor. */
4185 gcc_assert (elts->length () == 2);
4186 r = (*elts)[0].value;
4187 i = (*elts)[1].value;
4188 if (r == NULL || i == NULL)
4190 tree zero = build_zero_cst (TREE_TYPE (type));
4197 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
4198 represent creation of a complex value. */
4199 if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
4201 ctor = build_complex (type, r, i);
4202 TREE_OPERAND (*expr_p, 1) = ctor;
4206 ctor = build2 (COMPLEX_EXPR, type, r, i);
4207 TREE_OPERAND (*expr_p, 1) = ctor;
4208 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1),
4211 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
4219 unsigned HOST_WIDE_INT ix;
4220 constructor_elt *ce;
4222 if (notify_temp_creation)
4225 /* Go ahead and simplify constant constructors to VECTOR_CST. */
4226 if (TREE_CONSTANT (ctor))
4228 bool constant_p = true;
4231 /* Even when ctor is constant, it might contain non-*_CST
4232 elements, such as addresses or trapping values like
4233 1.0/0.0 - 1.0/0.0. Such expressions don't belong
4234 in VECTOR_CST nodes. */
4235 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
4236 if (!CONSTANT_CLASS_P (value))
4244 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
4248 TREE_CONSTANT (ctor) = 0;
4251 /* Vector types use CONSTRUCTOR all the way through gimple
4252 compilation as a general initializer. */
4253 FOR_EACH_VEC_SAFE_ELT (elts, ix, ce)
4255 enum gimplify_status tret;
4256 tret = gimplify_expr (&ce->value, pre_p, post_p, is_gimple_val,
4258 if (tret == GS_ERROR)
4260 else if (TREE_STATIC (ctor)
4261 && !initializer_constant_valid_p (ce->value,
4262 TREE_TYPE (ce->value)))
4263 TREE_STATIC (ctor) = 0;
4265 if (!is_gimple_reg (TREE_OPERAND (*expr_p, 0)))
4266 TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
4271 /* So how did we get a CONSTRUCTOR for a scalar type? */
4275 if (ret == GS_ERROR)
4277 else if (want_value)
4284 /* If we have gimplified both sides of the initializer but have
4285 not emitted an assignment, do so now. */
4288 tree lhs = TREE_OPERAND (*expr_p, 0);
4289 tree rhs = TREE_OPERAND (*expr_p, 1);
4290 gassign *init = gimple_build_assign (lhs, rhs);
4291 gimplify_seq_add_stmt (pre_p, init);
4299 /* Given a pointer value OP0, return a simplified version of an
4300 indirection through OP0, or NULL_TREE if no simplification is
4301 possible. This may only be applied to a rhs of an expression.
4302 Note that the resulting type may be different from the type pointed
4303 to in the sense that it is still compatible from the langhooks
4307 gimple_fold_indirect_ref_rhs (tree t)
4309 return gimple_fold_indirect_ref (t);
4312 /* Subroutine of gimplify_modify_expr to do simplifications of
4313 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4314 something changes. */
4316 static enum gimplify_status
4317 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p,
4318 gimple_seq *pre_p, gimple_seq *post_p,
4321 enum gimplify_status ret = GS_UNHANDLED;
4327 switch (TREE_CODE (*from_p))
4330 /* If we're assigning from a read-only variable initialized with
4331 a constructor, do the direct assignment from the constructor,
4332 but only if neither source nor target are volatile since this
4333 latter assignment might end up being done on a per-field basis. */
4334 if (DECL_INITIAL (*from_p)
4335 && TREE_READONLY (*from_p)
4336 && !TREE_THIS_VOLATILE (*from_p)
4337 && !TREE_THIS_VOLATILE (*to_p)
4338 && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
4340 tree old_from = *from_p;
4341 enum gimplify_status subret;
4343 /* Move the constructor into the RHS. */
4344 *from_p = unshare_expr (DECL_INITIAL (*from_p));
4346 /* Let's see if gimplify_init_constructor will need to put
4348 subret = gimplify_init_constructor (expr_p, NULL, NULL,
4350 if (subret == GS_ERROR)
4352 /* If so, revert the change. */
4364 /* If we have code like
4368 where the type of "x" is a (possibly cv-qualified variant
4369 of "A"), treat the entire expression as identical to "x".
4370 This kind of code arises in C++ when an object is bound
4371 to a const reference, and if "x" is a TARGET_EXPR we want
4372 to take advantage of the optimization below. */
4373 bool volatile_p = TREE_THIS_VOLATILE (*from_p);
4374 tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
4377 if (TREE_THIS_VOLATILE (t) != volatile_p)
4380 t = build_simple_mem_ref_loc (EXPR_LOCATION (*from_p),
4381 build_fold_addr_expr (t));
4382 if (REFERENCE_CLASS_P (t))
4383 TREE_THIS_VOLATILE (t) = volatile_p;
4394 /* If we are initializing something from a TARGET_EXPR, strip the
4395 TARGET_EXPR and initialize it directly, if possible. This can't
4396 be done if the initializer is void, since that implies that the
4397 temporary is set in some non-trivial way.
4399 ??? What about code that pulls out the temp and uses it
4400 elsewhere? I think that such code never uses the TARGET_EXPR as
4401 an initializer. If I'm wrong, we'll die because the temp won't
4402 have any RTL. In that case, I guess we'll need to replace
4403 references somehow. */
4404 tree init = TARGET_EXPR_INITIAL (*from_p);
4407 && !VOID_TYPE_P (TREE_TYPE (init)))
4417 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4419 gimplify_compound_expr (from_p, pre_p, true);
4425 /* If we already made some changes, let the front end have a
4426 crack at this before we break it down. */
4427 if (ret != GS_UNHANDLED)
4429 /* If we're initializing from a CONSTRUCTOR, break this into
4430 individual MODIFY_EXPRs. */
4431 return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
4435 /* If we're assigning to a non-register type, push the assignment
4436 down into the branches. This is mandatory for ADDRESSABLE types,
4437 since we cannot generate temporaries for such, but it saves a
4438 copy in other cases as well. */
4439 if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
4441 /* This code should mirror the code in gimplify_cond_expr. */
4442 enum tree_code code = TREE_CODE (*expr_p);
4443 tree cond = *from_p;
4444 tree result = *to_p;
4446 ret = gimplify_expr (&result, pre_p, post_p,
4447 is_gimple_lvalue, fb_lvalue);
4448 if (ret != GS_ERROR)
4451 if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
4452 TREE_OPERAND (cond, 1)
4453 = build2 (code, void_type_node, result,
4454 TREE_OPERAND (cond, 1));
4455 if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
4456 TREE_OPERAND (cond, 2)
4457 = build2 (code, void_type_node, unshare_expr (result),
4458 TREE_OPERAND (cond, 2));
4460 TREE_TYPE (cond) = void_type_node;
4461 recalculate_side_effects (cond);
4465 gimplify_and_add (cond, pre_p);
4466 *expr_p = unshare_expr (result);
4475 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4476 return slot so that we don't generate a temporary. */
4477 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
4478 && aggregate_value_p (*from_p, *from_p))
4482 if (!(rhs_predicate_for (*to_p))(*from_p))
4483 /* If we need a temporary, *to_p isn't accurate. */
4485 /* It's OK to use the return slot directly unless it's an NRV. */
4486 else if (TREE_CODE (*to_p) == RESULT_DECL
4487 && DECL_NAME (*to_p) == NULL_TREE
4488 && needs_to_live_in_memory (*to_p))
4490 else if (is_gimple_reg_type (TREE_TYPE (*to_p))
4491 || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
4492 /* Don't force regs into memory. */
4494 else if (TREE_CODE (*expr_p) == INIT_EXPR)
4495 /* It's OK to use the target directly if it's being
4498 else if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (*to_p)))
4500 /* Always use the target and thus RSO for variable-sized types.
4501 GIMPLE cannot deal with a variable-sized assignment
4502 embedded in a call statement. */
4504 else if (TREE_CODE (*to_p) != SSA_NAME
4505 && (!is_gimple_variable (*to_p)
4506 || needs_to_live_in_memory (*to_p)))
4507 /* Don't use the original target if it's already addressable;
4508 if its address escapes, and the called function uses the
4509 NRV optimization, a conforming program could see *to_p
4510 change before the called function returns; see c++/19317.
4511 When optimizing, the return_slot pass marks more functions
4512 as safe after we have escape info. */
4519 CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
4520 mark_addressable (*to_p);
4525 case WITH_SIZE_EXPR:
4526 /* Likewise for calls that return an aggregate of non-constant size,
4527 since we would not be able to generate a temporary at all. */
4528 if (TREE_CODE (TREE_OPERAND (*from_p, 0)) == CALL_EXPR)
4530 *from_p = TREE_OPERAND (*from_p, 0);
4531 /* We don't change ret in this case because the
4532 WITH_SIZE_EXPR might have been added in
4533 gimplify_modify_expr, so returning GS_OK would lead to an
4539 /* If we're initializing from a container, push the initialization
4541 case CLEANUP_POINT_EXPR:
4543 case STATEMENT_LIST:
4545 tree wrap = *from_p;
4548 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
4550 if (ret != GS_ERROR)
4553 t = voidify_wrapper_expr (wrap, *expr_p);
4554 gcc_assert (t == *expr_p);
4558 gimplify_and_add (wrap, pre_p);
4559 *expr_p = unshare_expr (*to_p);
4566 case COMPOUND_LITERAL_EXPR:
4568 tree complit = TREE_OPERAND (*expr_p, 1);
4569 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (complit);
4570 tree decl = DECL_EXPR_DECL (decl_s);
4571 tree init = DECL_INITIAL (decl);
4573 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4574 into struct T x = { 0, 1, 2 } if the address of the
4575 compound literal has never been taken. */
4576 if (!TREE_ADDRESSABLE (complit)
4577 && !TREE_ADDRESSABLE (decl)
4580 *expr_p = copy_node (*expr_p);
4581 TREE_OPERAND (*expr_p, 1) = init;
4596 /* Return true if T looks like a valid GIMPLE statement. */
4599 is_gimple_stmt (tree t)
4601 const enum tree_code code = TREE_CODE (t);
4606 /* The only valid NOP_EXPR is the empty statement. */
4607 return IS_EMPTY_STMT (t);
4611 /* These are only valid if they're void. */
4612 return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
4618 case CASE_LABEL_EXPR:
4619 case TRY_CATCH_EXPR:
4620 case TRY_FINALLY_EXPR:
4621 case EH_FILTER_EXPR:
4624 case STATEMENT_LIST:
4628 case OACC_HOST_DATA:
4631 case OACC_ENTER_DATA:
4632 case OACC_EXIT_DATA:
4638 case OMP_DISTRIBUTE:
4649 case OMP_TARGET_DATA:
4650 case OMP_TARGET_UPDATE:
4651 case OMP_TARGET_ENTER_DATA:
4652 case OMP_TARGET_EXIT_DATA:
4655 /* These are always void. */
4661 /* These are valid regardless of their type. */
4670 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4671 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4672 DECL_GIMPLE_REG_P set.
4674 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4675 other, unmodified part of the complex object just before the total store.
4676 As a consequence, if the object is still uninitialized, an undefined value
4677 will be loaded into a register, which may result in a spurious exception
4678 if the register is floating-point and the value happens to be a signaling
4679 NaN for example. Then the fully-fledged complex operations lowering pass
4680 followed by a DCE pass are necessary in order to fix things up. */
4682 static enum gimplify_status
4683 gimplify_modify_expr_complex_part (tree *expr_p, gimple_seq *pre_p,
4686 enum tree_code code, ocode;
4687 tree lhs, rhs, new_rhs, other, realpart, imagpart;
4689 lhs = TREE_OPERAND (*expr_p, 0);
4690 rhs = TREE_OPERAND (*expr_p, 1);
4691 code = TREE_CODE (lhs);
4692 lhs = TREE_OPERAND (lhs, 0);
4694 ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR;
4695 other = build1 (ocode, TREE_TYPE (rhs), lhs);
4696 TREE_NO_WARNING (other) = 1;
4697 other = get_formal_tmp_var (other, pre_p);
4699 realpart = code == REALPART_EXPR ? rhs : other;
4700 imagpart = code == REALPART_EXPR ? other : rhs;
4702 if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart))
4703 new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart);
4705 new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
4707 gimplify_seq_add_stmt (pre_p, gimple_build_assign (lhs, new_rhs));
4708 *expr_p = (want_value) ? rhs : NULL_TREE;
4713 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4719 PRE_P points to the list where side effects that must happen before
4720 *EXPR_P should be stored.
4722 POST_P points to the list where side effects that must happen after
4723 *EXPR_P should be stored.
4725 WANT_VALUE is nonzero iff we want to use the value of this expression
4726 in another expression. */
4728 static enum gimplify_status
4729 gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
4732 tree *from_p = &TREE_OPERAND (*expr_p, 1);
4733 tree *to_p = &TREE_OPERAND (*expr_p, 0);
4734 enum gimplify_status ret = GS_UNHANDLED;
4736 location_t loc = EXPR_LOCATION (*expr_p);
4737 gimple_stmt_iterator gsi;
4739 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
4740 || TREE_CODE (*expr_p) == INIT_EXPR);
4742 /* Trying to simplify a clobber using normal logic doesn't work,
4743 so handle it here. */
4744 if (TREE_CLOBBER_P (*from_p))
4746 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
4747 if (ret == GS_ERROR)
4749 gcc_assert (!want_value
4750 && (TREE_CODE (*to_p) == VAR_DECL
4751 || TREE_CODE (*to_p) == MEM_REF));
4752 gimplify_seq_add_stmt (pre_p, gimple_build_assign (*to_p, *from_p));
4757 /* Insert pointer conversions required by the middle-end that are not
4758 required by the frontend. This fixes middle-end type checking for
4759 for example gcc.dg/redecl-6.c. */
4760 if (POINTER_TYPE_P (TREE_TYPE (*to_p)))
4762 STRIP_USELESS_TYPE_CONVERSION (*from_p);
4763 if (!useless_type_conversion_p (TREE_TYPE (*to_p), TREE_TYPE (*from_p)))
4764 *from_p = fold_convert_loc (loc, TREE_TYPE (*to_p), *from_p);
4767 /* See if any simplifications can be done based on what the RHS is. */
4768 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
4770 if (ret != GS_UNHANDLED)
4773 /* For zero sized types only gimplify the left hand side and right hand
4774 side as statements and throw away the assignment. Do this after
4775 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4777 if (zero_sized_type (TREE_TYPE (*from_p)) && !want_value)
4779 gimplify_stmt (from_p, pre_p);
4780 gimplify_stmt (to_p, pre_p);
4781 *expr_p = NULL_TREE;
4785 /* If the value being copied is of variable width, compute the length
4786 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4787 before gimplifying any of the operands so that we can resolve any
4788 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4789 the size of the expression to be copied, not of the destination, so
4790 that is what we must do here. */
4791 maybe_with_size_expr (from_p);
4793 /* As a special case, we have to temporarily allow for assignments
4794 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4795 a toplevel statement, when gimplifying the GENERIC expression
4796 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4797 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4799 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4800 prevent gimplify_expr from trying to create a new temporary for
4801 foo's LHS, we tell it that it should only gimplify until it
4802 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4803 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4804 and all we need to do here is set 'a' to be its LHS. */
4806 /* Gimplify the RHS first for C++17 and bug 71104. */
4807 gimple_predicate initial_pred = initial_rhs_predicate_for (*to_p);
4808 ret = gimplify_expr (from_p, pre_p, post_p, initial_pred, fb_rvalue);
4809 if (ret == GS_ERROR)
4812 /* Then gimplify the LHS. */
4813 /* If we gimplified the RHS to a CALL_EXPR and that call may return
4814 twice we have to make sure to gimplify into non-SSA as otherwise
4815 the abnormal edge added later will make those defs not dominate
4817 ??? Technically this applies only to the registers used in the
4818 resulting non-register *TO_P. */
4819 bool saved_into_ssa = gimplify_ctxp->into_ssa;
4821 && TREE_CODE (*from_p) == CALL_EXPR
4822 && call_expr_flags (*from_p) & ECF_RETURNS_TWICE)
4823 gimplify_ctxp->into_ssa = false;
4824 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
4825 gimplify_ctxp->into_ssa = saved_into_ssa;
4826 if (ret == GS_ERROR)
4829 /* Now that the LHS is gimplified, re-gimplify the RHS if our initial
4830 guess for the predicate was wrong. */
4831 gimple_predicate final_pred = rhs_predicate_for (*to_p);
4832 if (final_pred != initial_pred)
4834 ret = gimplify_expr (from_p, pre_p, post_p, final_pred, fb_rvalue);
4835 if (ret == GS_ERROR)
4839 /* In case of va_arg internal fn wrappped in a WITH_SIZE_EXPR, add the type
4840 size as argument to the call. */
4841 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
4843 tree call = TREE_OPERAND (*from_p, 0);
4844 tree vlasize = TREE_OPERAND (*from_p, 1);
4846 if (TREE_CODE (call) == CALL_EXPR
4847 && CALL_EXPR_IFN (call) == IFN_VA_ARG)
4849 int nargs = call_expr_nargs (call);
4850 tree type = TREE_TYPE (call);
4851 tree ap = CALL_EXPR_ARG (call, 0);
4852 tree tag = CALL_EXPR_ARG (call, 1);
4853 tree aptag = CALL_EXPR_ARG (call, 2);
4854 tree newcall = build_call_expr_internal_loc (EXPR_LOCATION (call),
4858 TREE_OPERAND (*from_p, 0) = newcall;
4862 /* Now see if the above changed *from_p to something we handle specially. */
4863 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
4865 if (ret != GS_UNHANDLED)
4868 /* If we've got a variable sized assignment between two lvalues (i.e. does
4869 not involve a call), then we can make things a bit more straightforward
4870 by converting the assignment to memcpy or memset. */
4871 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
4873 tree from = TREE_OPERAND (*from_p, 0);
4874 tree size = TREE_OPERAND (*from_p, 1);
4876 if (TREE_CODE (from) == CONSTRUCTOR)
4877 return gimplify_modify_expr_to_memset (expr_p, size, want_value, pre_p);
4879 if (is_gimple_addressable (from))
4882 return gimplify_modify_expr_to_memcpy (expr_p, size, want_value,
4887 /* Transform partial stores to non-addressable complex variables into
4888 total stores. This allows us to use real instead of virtual operands
4889 for these variables, which improves optimization. */
4890 if ((TREE_CODE (*to_p) == REALPART_EXPR
4891 || TREE_CODE (*to_p) == IMAGPART_EXPR)
4892 && is_gimple_reg (TREE_OPERAND (*to_p, 0)))
4893 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
4895 /* Try to alleviate the effects of the gimplification creating artificial
4896 temporaries (see for example is_gimple_reg_rhs) on the debug info, but
4897 make sure not to create DECL_DEBUG_EXPR links across functions. */
4898 if (!gimplify_ctxp->into_ssa
4899 && TREE_CODE (*from_p) == VAR_DECL
4900 && DECL_IGNORED_P (*from_p)
4902 && !DECL_IGNORED_P (*to_p)
4903 && decl_function_context (*to_p) == current_function_decl)
4905 if (!DECL_NAME (*from_p) && DECL_NAME (*to_p))
4907 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p)));
4908 DECL_HAS_DEBUG_EXPR_P (*from_p) = 1;
4909 SET_DECL_DEBUG_EXPR (*from_p, *to_p);
4912 if (want_value && TREE_THIS_VOLATILE (*to_p))
4913 *from_p = get_initialized_tmp_var (*from_p, pre_p, post_p);
4915 if (TREE_CODE (*from_p) == CALL_EXPR)
4917 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4918 instead of a GIMPLE_ASSIGN. */
4920 if (CALL_EXPR_FN (*from_p) == NULL_TREE)
4922 /* Gimplify internal functions created in the FEs. */
4923 int nargs = call_expr_nargs (*from_p), i;
4924 enum internal_fn ifn = CALL_EXPR_IFN (*from_p);
4925 auto_vec<tree> vargs (nargs);
4927 for (i = 0; i < nargs; i++)
4929 gimplify_arg (&CALL_EXPR_ARG (*from_p, i), pre_p,
4930 EXPR_LOCATION (*from_p));
4931 vargs.quick_push (CALL_EXPR_ARG (*from_p, i));
4933 call_stmt = gimple_build_call_internal_vec (ifn, vargs);
4934 gimple_set_location (call_stmt, EXPR_LOCATION (*expr_p));
4938 tree fnptrtype = TREE_TYPE (CALL_EXPR_FN (*from_p));
4939 CALL_EXPR_FN (*from_p) = TREE_OPERAND (CALL_EXPR_FN (*from_p), 0);
4940 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p));
4941 tree fndecl = get_callee_fndecl (*from_p);
4943 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
4944 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT
4945 && call_expr_nargs (*from_p) == 3)
4946 call_stmt = gimple_build_call_internal (IFN_BUILTIN_EXPECT, 3,
4947 CALL_EXPR_ARG (*from_p, 0),
4948 CALL_EXPR_ARG (*from_p, 1),
4949 CALL_EXPR_ARG (*from_p, 2));
4952 call_stmt = gimple_build_call_from_tree (*from_p);
4953 gimple_call_set_fntype (call_stmt, TREE_TYPE (fnptrtype));
4956 notice_special_calls (call_stmt);
4957 if (!gimple_call_noreturn_p (call_stmt) || !should_remove_lhs_p (*to_p))
4958 gimple_call_set_lhs (call_stmt, *to_p);
4959 else if (TREE_CODE (*to_p) == SSA_NAME)
4960 /* The above is somewhat premature, avoid ICEing later for a
4961 SSA name w/o a definition. We may have uses in the GIMPLE IL.
4962 ??? This doesn't make it a default-def. */
4963 SSA_NAME_DEF_STMT (*to_p) = gimple_build_nop ();
4968 assign = gimple_build_assign (*to_p, *from_p);
4969 gimple_set_location (assign, EXPR_LOCATION (*expr_p));
4970 if (COMPARISON_CLASS_P (*from_p))
4971 gimple_set_no_warning (assign, TREE_NO_WARNING (*from_p));
4974 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
4976 /* We should have got an SSA name from the start. */
4977 gcc_assert (TREE_CODE (*to_p) == SSA_NAME
4978 || ! gimple_in_ssa_p (cfun));
4981 gimplify_seq_add_stmt (pre_p, assign);
4982 gsi = gsi_last (*pre_p);
4983 maybe_fold_stmt (&gsi);
4987 *expr_p = TREE_THIS_VOLATILE (*to_p) ? *from_p : unshare_expr (*to_p);
4996 /* Gimplify a comparison between two variable-sized objects. Do this
4997 with a call to BUILT_IN_MEMCMP. */
4999 static enum gimplify_status
5000 gimplify_variable_sized_compare (tree *expr_p)
5002 location_t loc = EXPR_LOCATION (*expr_p);
5003 tree op0 = TREE_OPERAND (*expr_p, 0);
5004 tree op1 = TREE_OPERAND (*expr_p, 1);
5005 tree t, arg, dest, src, expr;
5007 arg = TYPE_SIZE_UNIT (TREE_TYPE (op0));
5008 arg = unshare_expr (arg);
5009 arg = SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg, op0);
5010 src = build_fold_addr_expr_loc (loc, op1);
5011 dest = build_fold_addr_expr_loc (loc, op0);
5012 t = builtin_decl_implicit (BUILT_IN_MEMCMP);
5013 t = build_call_expr_loc (loc, t, 3, dest, src, arg);
5016 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
5017 SET_EXPR_LOCATION (expr, loc);
5023 /* Gimplify a comparison between two aggregate objects of integral scalar
5024 mode as a comparison between the bitwise equivalent scalar values. */
5026 static enum gimplify_status
5027 gimplify_scalar_mode_aggregate_compare (tree *expr_p)
5029 location_t loc = EXPR_LOCATION (*expr_p);
5030 tree op0 = TREE_OPERAND (*expr_p, 0);
5031 tree op1 = TREE_OPERAND (*expr_p, 1);
5033 tree type = TREE_TYPE (op0);
5034 tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1);
5036 op0 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op0);
5037 op1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op1);
5040 = fold_build2_loc (loc, TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
5045 /* Gimplify an expression sequence. This function gimplifies each
5046 expression and rewrites the original expression with the last
5047 expression of the sequence in GIMPLE form.
5049 PRE_P points to the list where the side effects for all the
5050 expressions in the sequence will be emitted.
5052 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
5054 static enum gimplify_status
5055 gimplify_compound_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
5061 tree *sub_p = &TREE_OPERAND (t, 0);
5063 if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
5064 gimplify_compound_expr (sub_p, pre_p, false);
5066 gimplify_stmt (sub_p, pre_p);
5068 t = TREE_OPERAND (t, 1);
5070 while (TREE_CODE (t) == COMPOUND_EXPR);
5077 gimplify_stmt (expr_p, pre_p);
5082 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
5083 gimplify. After gimplification, EXPR_P will point to a new temporary
5084 that holds the original value of the SAVE_EXPR node.
5086 PRE_P points to the list where side effects that must happen before
5087 *EXPR_P should be stored. */
5089 static enum gimplify_status
5090 gimplify_save_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5092 enum gimplify_status ret = GS_ALL_DONE;
5095 gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
5096 val = TREE_OPERAND (*expr_p, 0);
5098 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
5099 if (!SAVE_EXPR_RESOLVED_P (*expr_p))
5101 /* The operand may be a void-valued expression such as SAVE_EXPRs
5102 generated by the Java frontend for class initialization. It is
5103 being executed only for its side-effects. */
5104 if (TREE_TYPE (val) == void_type_node)
5106 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5107 is_gimple_stmt, fb_none);
5111 /* The temporary may not be an SSA name as later abnormal and EH
5112 control flow may invalidate use/def domination. */
5113 val = get_initialized_tmp_var (val, pre_p, post_p, false);
5115 TREE_OPERAND (*expr_p, 0) = val;
5116 SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
5124 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
5131 PRE_P points to the list where side effects that must happen before
5132 *EXPR_P should be stored.
5134 POST_P points to the list where side effects that must happen after
5135 *EXPR_P should be stored. */
5137 static enum gimplify_status
5138 gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5140 tree expr = *expr_p;
5141 tree op0 = TREE_OPERAND (expr, 0);
5142 enum gimplify_status ret;
5143 location_t loc = EXPR_LOCATION (*expr_p);
5145 switch (TREE_CODE (op0))
5149 /* Check if we are dealing with an expression of the form '&*ptr'.
5150 While the front end folds away '&*ptr' into 'ptr', these
5151 expressions may be generated internally by the compiler (e.g.,
5152 builtins like __builtin_va_end). */
5153 /* Caution: the silent array decomposition semantics we allow for
5154 ADDR_EXPR means we can't always discard the pair. */
5155 /* Gimplification of the ADDR_EXPR operand may drop
5156 cv-qualification conversions, so make sure we add them if
5159 tree op00 = TREE_OPERAND (op0, 0);
5160 tree t_expr = TREE_TYPE (expr);
5161 tree t_op00 = TREE_TYPE (op00);
5163 if (!useless_type_conversion_p (t_expr, t_op00))
5164 op00 = fold_convert_loc (loc, TREE_TYPE (expr), op00);
5170 case VIEW_CONVERT_EXPR:
5171 /* Take the address of our operand and then convert it to the type of
5174 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
5175 all clear. The impact of this transformation is even less clear. */
5177 /* If the operand is a useless conversion, look through it. Doing so
5178 guarantees that the ADDR_EXPR and its operand will remain of the
5180 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
5181 op0 = TREE_OPERAND (op0, 0);
5183 *expr_p = fold_convert_loc (loc, TREE_TYPE (expr),
5184 build_fold_addr_expr_loc (loc,
5185 TREE_OPERAND (op0, 0)));
5190 if (integer_zerop (TREE_OPERAND (op0, 1)))
5191 goto do_indirect_ref;
5196 /* If we see a call to a declared builtin or see its address
5197 being taken (we can unify those cases here) then we can mark
5198 the builtin for implicit generation by GCC. */
5199 if (TREE_CODE (op0) == FUNCTION_DECL
5200 && DECL_BUILT_IN_CLASS (op0) == BUILT_IN_NORMAL
5201 && builtin_decl_declared_p (DECL_FUNCTION_CODE (op0)))
5202 set_builtin_decl_implicit_p (DECL_FUNCTION_CODE (op0), true);
5204 /* We use fb_either here because the C frontend sometimes takes
5205 the address of a call that returns a struct; see
5206 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
5207 the implied temporary explicit. */
5209 /* Make the operand addressable. */
5210 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
5211 is_gimple_addressable, fb_either);
5212 if (ret == GS_ERROR)
5215 /* Then mark it. Beware that it may not be possible to do so directly
5216 if a temporary has been created by the gimplification. */
5217 prepare_gimple_addressable (&TREE_OPERAND (expr, 0), pre_p);
5219 op0 = TREE_OPERAND (expr, 0);
5221 /* For various reasons, the gimplification of the expression
5222 may have made a new INDIRECT_REF. */
5223 if (TREE_CODE (op0) == INDIRECT_REF)
5224 goto do_indirect_ref;
5226 mark_addressable (TREE_OPERAND (expr, 0));
5228 /* The FEs may end up building ADDR_EXPRs early on a decl with
5229 an incomplete type. Re-build ADDR_EXPRs in canonical form
5231 if (!types_compatible_p (TREE_TYPE (op0), TREE_TYPE (TREE_TYPE (expr))))
5232 *expr_p = build_fold_addr_expr (op0);
5234 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
5235 recompute_tree_invariant_for_addr_expr (*expr_p);
5237 /* If we re-built the ADDR_EXPR add a conversion to the original type
5239 if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
5240 *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
5248 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
5249 value; output operands should be a gimple lvalue. */
5251 static enum gimplify_status
5252 gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5256 const char **oconstraints;
5259 const char *constraint;
5260 bool allows_mem, allows_reg, is_inout;
5261 enum gimplify_status ret, tret;
5263 vec<tree, va_gc> *inputs;
5264 vec<tree, va_gc> *outputs;
5265 vec<tree, va_gc> *clobbers;
5266 vec<tree, va_gc> *labels;
5270 noutputs = list_length (ASM_OUTPUTS (expr));
5271 oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
5279 link_next = NULL_TREE;
5280 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = link_next)
5283 size_t constraint_len;
5285 link_next = TREE_CHAIN (link);
5289 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
5290 constraint_len = strlen (constraint);
5291 if (constraint_len == 0)
5294 ok = parse_output_constraint (&constraint, i, 0, 0,
5295 &allows_mem, &allows_reg, &is_inout);
5302 if (!allows_reg && allows_mem)
5303 mark_addressable (TREE_VALUE (link));
5305 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
5306 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
5307 fb_lvalue | fb_mayfail);
5308 if (tret == GS_ERROR)
5310 error ("invalid lvalue in asm output %d", i);
5314 /* If the constraint does not allow memory make sure we gimplify
5315 it to a register if it is not already but its base is. This
5316 happens for complex and vector components. */
5319 tree op = TREE_VALUE (link);
5320 if (! is_gimple_val (op)
5321 && is_gimple_reg_type (TREE_TYPE (op))
5322 && is_gimple_reg (get_base_address (op)))
5324 tree tem = create_tmp_reg (TREE_TYPE (op));
5328 ass = build2 (MODIFY_EXPR, TREE_TYPE (tem),
5329 tem, unshare_expr (op));
5330 gimplify_and_add (ass, pre_p);
5332 ass = build2 (MODIFY_EXPR, TREE_TYPE (tem), op, tem);
5333 gimplify_and_add (ass, post_p);
5335 TREE_VALUE (link) = tem;
5340 vec_safe_push (outputs, link);
5341 TREE_CHAIN (link) = NULL_TREE;
5345 /* An input/output operand. To give the optimizers more
5346 flexibility, split it into separate input and output
5351 /* Turn the in/out constraint into an output constraint. */
5352 char *p = xstrdup (constraint);
5354 TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
5356 /* And add a matching input constraint. */
5359 sprintf (buf, "%d", i);
5361 /* If there are multiple alternatives in the constraint,
5362 handle each of them individually. Those that allow register
5363 will be replaced with operand number, the others will stay
5365 if (strchr (p, ',') != NULL)
5367 size_t len = 0, buflen = strlen (buf);
5368 char *beg, *end, *str, *dst;
5372 end = strchr (beg, ',');
5374 end = strchr (beg, '\0');
5375 if ((size_t) (end - beg) < buflen)
5378 len += end - beg + 1;
5385 str = (char *) alloca (len);
5386 for (beg = p + 1, dst = str;;)
5389 bool mem_p, reg_p, inout_p;
5391 end = strchr (beg, ',');
5396 parse_output_constraint (&tem, i, 0, 0,
5397 &mem_p, ®_p, &inout_p);
5402 memcpy (dst, buf, buflen);
5411 memcpy (dst, beg, len);
5420 input = build_string (dst - str, str);
5423 input = build_string (strlen (buf), buf);
5426 input = build_string (constraint_len - 1, constraint + 1);
5430 input = build_tree_list (build_tree_list (NULL_TREE, input),
5431 unshare_expr (TREE_VALUE (link)));
5432 ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
5436 link_next = NULL_TREE;
5437 for (link = ASM_INPUTS (expr); link; ++i, link = link_next)
5439 link_next = TREE_CHAIN (link);
5440 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
5441 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
5442 oconstraints, &allows_mem, &allows_reg);
5444 /* If we can't make copies, we can only accept memory. */
5445 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link))))
5451 error ("impossible constraint in %<asm%>");
5452 error ("non-memory input %d must stay in memory", i);
5457 /* If the operand is a memory input, it should be an lvalue. */
5458 if (!allows_reg && allows_mem)
5460 tree inputv = TREE_VALUE (link);
5461 STRIP_NOPS (inputv);
5462 if (TREE_CODE (inputv) == PREDECREMENT_EXPR
5463 || TREE_CODE (inputv) == PREINCREMENT_EXPR
5464 || TREE_CODE (inputv) == POSTDECREMENT_EXPR
5465 || TREE_CODE (inputv) == POSTINCREMENT_EXPR
5466 || TREE_CODE (inputv) == MODIFY_EXPR)
5467 TREE_VALUE (link) = error_mark_node;
5468 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
5469 is_gimple_lvalue, fb_lvalue | fb_mayfail);
5470 if (tret != GS_ERROR)
5472 /* Unlike output operands, memory inputs are not guaranteed
5473 to be lvalues by the FE, and while the expressions are
5474 marked addressable there, if it is e.g. a statement
5475 expression, temporaries in it might not end up being
5476 addressable. They might be already used in the IL and thus
5477 it is too late to make them addressable now though. */
5478 tree x = TREE_VALUE (link);
5479 while (handled_component_p (x))
5480 x = TREE_OPERAND (x, 0);
5481 if (TREE_CODE (x) == MEM_REF
5482 && TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
5483 x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
5484 if ((TREE_CODE (x) == VAR_DECL
5485 || TREE_CODE (x) == PARM_DECL
5486 || TREE_CODE (x) == RESULT_DECL)
5487 && !TREE_ADDRESSABLE (x)
5488 && is_gimple_reg (x))
5490 warning_at (EXPR_LOC_OR_LOC (TREE_VALUE (link),
5492 "memory input %d is not directly addressable",
5494 prepare_gimple_addressable (&TREE_VALUE (link), pre_p);
5497 mark_addressable (TREE_VALUE (link));
5498 if (tret == GS_ERROR)
5500 error_at (EXPR_LOC_OR_LOC (TREE_VALUE (link), input_location),
5501 "memory input %d is not directly addressable", i);
5507 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
5508 is_gimple_asm_val, fb_rvalue);
5509 if (tret == GS_ERROR)
5513 TREE_CHAIN (link) = NULL_TREE;
5514 vec_safe_push (inputs, link);
5517 link_next = NULL_TREE;
5518 for (link = ASM_CLOBBERS (expr); link; ++i, link = link_next)
5520 link_next = TREE_CHAIN (link);
5521 TREE_CHAIN (link) = NULL_TREE;
5522 vec_safe_push (clobbers, link);
5525 link_next = NULL_TREE;
5526 for (link = ASM_LABELS (expr); link; ++i, link = link_next)
5528 link_next = TREE_CHAIN (link);
5529 TREE_CHAIN (link) = NULL_TREE;
5530 vec_safe_push (labels, link);
5533 /* Do not add ASMs with errors to the gimple IL stream. */
5534 if (ret != GS_ERROR)
5536 stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
5537 inputs, outputs, clobbers, labels);
5539 gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr) || noutputs == 0);
5540 gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
5542 gimplify_seq_add_stmt (pre_p, stmt);
5548 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
5549 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
5550 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
5551 return to this function.
5553 FIXME should we complexify the prequeue handling instead? Or use flags
5554 for all the cleanups and let the optimizer tighten them up? The current
5555 code seems pretty fragile; it will break on a cleanup within any
5556 non-conditional nesting. But any such nesting would be broken, anyway;
5557 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
5558 and continues out of it. We can do that at the RTL level, though, so
5559 having an optimizer to tighten up try/finally regions would be a Good
5562 static enum gimplify_status
5563 gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
5565 gimple_stmt_iterator iter;
5566 gimple_seq body_sequence = NULL;
5568 tree temp = voidify_wrapper_expr (*expr_p, NULL);
5570 /* We only care about the number of conditions between the innermost
5571 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5572 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5573 int old_conds = gimplify_ctxp->conditions;
5574 gimple_seq old_cleanups = gimplify_ctxp->conditional_cleanups;
5575 bool old_in_cleanup_point_expr = gimplify_ctxp->in_cleanup_point_expr;
5576 gimplify_ctxp->conditions = 0;
5577 gimplify_ctxp->conditional_cleanups = NULL;
5578 gimplify_ctxp->in_cleanup_point_expr = true;
5580 gimplify_stmt (&TREE_OPERAND (*expr_p, 0), &body_sequence);
5582 gimplify_ctxp->conditions = old_conds;
5583 gimplify_ctxp->conditional_cleanups = old_cleanups;
5584 gimplify_ctxp->in_cleanup_point_expr = old_in_cleanup_point_expr;
5586 for (iter = gsi_start (body_sequence); !gsi_end_p (iter); )
5588 gimple *wce = gsi_stmt (iter);
5590 if (gimple_code (wce) == GIMPLE_WITH_CLEANUP_EXPR)
5592 if (gsi_one_before_end_p (iter))
5594 /* Note that gsi_insert_seq_before and gsi_remove do not
5595 scan operands, unlike some other sequence mutators. */
5596 if (!gimple_wce_cleanup_eh_only (wce))
5597 gsi_insert_seq_before_without_update (&iter,
5598 gimple_wce_cleanup (wce),
5600 gsi_remove (&iter, true);
5607 enum gimple_try_flags kind;
5609 if (gimple_wce_cleanup_eh_only (wce))
5610 kind = GIMPLE_TRY_CATCH;
5612 kind = GIMPLE_TRY_FINALLY;
5613 seq = gsi_split_seq_after (iter);
5615 gtry = gimple_build_try (seq, gimple_wce_cleanup (wce), kind);
5616 /* Do not use gsi_replace here, as it may scan operands.
5617 We want to do a simple structural modification only. */
5618 gsi_set_stmt (&iter, gtry);
5619 iter = gsi_start (gtry->eval);
5626 gimplify_seq_add_seq (pre_p, body_sequence);
5639 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5640 is the cleanup action required. EH_ONLY is true if the cleanup should
5641 only be executed if an exception is thrown, not on normal exit. */
5644 gimple_push_cleanup (tree var, tree cleanup, bool eh_only, gimple_seq *pre_p)
5647 gimple_seq cleanup_stmts = NULL;
5649 /* Errors can result in improperly nested cleanups. Which results in
5650 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5654 if (gimple_conditional_context ())
5656 /* If we're in a conditional context, this is more complex. We only
5657 want to run the cleanup if we actually ran the initialization that
5658 necessitates it, but we want to run it after the end of the
5659 conditional context. So we wrap the try/finally around the
5660 condition and use a flag to determine whether or not to actually
5661 run the destructor. Thus
5665 becomes (approximately)
5669 if (test) { A::A(temp); flag = 1; val = f(temp); }
5672 if (flag) A::~A(temp);
5676 tree flag = create_tmp_var (boolean_type_node, "cleanup");
5677 gassign *ffalse = gimple_build_assign (flag, boolean_false_node);
5678 gassign *ftrue = gimple_build_assign (flag, boolean_true_node);
5680 cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
5681 gimplify_stmt (&cleanup, &cleanup_stmts);
5682 wce = gimple_build_wce (cleanup_stmts);
5684 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, ffalse);
5685 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, wce);
5686 gimplify_seq_add_stmt (pre_p, ftrue);
5688 /* Because of this manipulation, and the EH edges that jump
5689 threading cannot redirect, the temporary (VAR) will appear
5690 to be used uninitialized. Don't warn. */
5691 TREE_NO_WARNING (var) = 1;
5695 gimplify_stmt (&cleanup, &cleanup_stmts);
5696 wce = gimple_build_wce (cleanup_stmts);
5697 gimple_wce_set_cleanup_eh_only (wce, eh_only);
5698 gimplify_seq_add_stmt (pre_p, wce);
5702 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5704 static enum gimplify_status
5705 gimplify_target_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5707 tree targ = *expr_p;
5708 tree temp = TARGET_EXPR_SLOT (targ);
5709 tree init = TARGET_EXPR_INITIAL (targ);
5710 enum gimplify_status ret;
5714 tree cleanup = NULL_TREE;
5716 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5717 to the temps list. Handle also variable length TARGET_EXPRs. */
5718 if (TREE_CODE (DECL_SIZE (temp)) != INTEGER_CST)
5720 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp)))
5721 gimplify_type_sizes (TREE_TYPE (temp), pre_p);
5722 gimplify_vla_decl (temp, pre_p);
5725 gimple_add_tmp_var (temp);
5727 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5728 expression is supposed to initialize the slot. */
5729 if (VOID_TYPE_P (TREE_TYPE (init)))
5730 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
5733 tree init_expr = build2 (INIT_EXPR, void_type_node, temp, init);
5735 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
5737 ggc_free (init_expr);
5739 if (ret == GS_ERROR)
5741 /* PR c++/28266 Make sure this is expanded only once. */
5742 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
5746 gimplify_and_add (init, pre_p);
5748 /* If needed, push the cleanup for the temp. */
5749 if (TARGET_EXPR_CLEANUP (targ))
5751 if (CLEANUP_EH_ONLY (targ))
5752 gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
5753 CLEANUP_EH_ONLY (targ), pre_p);
5755 cleanup = TARGET_EXPR_CLEANUP (targ);
5758 /* Add a clobber for the temporary going out of scope, like
5759 gimplify_bind_expr. */
5760 if (gimplify_ctxp->in_cleanup_point_expr
5761 && needs_to_live_in_memory (temp)
5762 && flag_stack_reuse == SR_ALL)
5764 tree clobber = build_constructor (TREE_TYPE (temp),
5766 TREE_THIS_VOLATILE (clobber) = true;
5767 clobber = build2 (MODIFY_EXPR, TREE_TYPE (temp), temp, clobber);
5769 cleanup = build2 (COMPOUND_EXPR, void_type_node, cleanup,
5776 gimple_push_cleanup (temp, cleanup, false, pre_p);
5778 /* Only expand this once. */
5779 TREE_OPERAND (targ, 3) = init;
5780 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
5783 /* We should have expanded this before. */
5784 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
5790 /* Gimplification of expression trees. */
5792 /* Gimplify an expression which appears at statement context. The
5793 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5794 NULL, a new sequence is allocated.
5796 Return true if we actually added a statement to the queue. */
5799 gimplify_stmt (tree *stmt_p, gimple_seq *seq_p)
5801 gimple_seq_node last;
5803 last = gimple_seq_last (*seq_p);
5804 gimplify_expr (stmt_p, seq_p, NULL, is_gimple_stmt, fb_none);
5805 return last != gimple_seq_last (*seq_p);
5808 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5809 to CTX. If entries already exist, force them to be some flavor of private.
5810 If there is no enclosing parallel, do nothing. */
5813 omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl)
5817 if (decl == NULL || !DECL_P (decl) || ctx->region_type == ORT_NONE)
5822 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5825 if (n->value & GOVD_SHARED)
5826 n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
5827 else if (n->value & GOVD_MAP)
5828 n->value |= GOVD_MAP_TO_ONLY;
5832 else if ((ctx->region_type & ORT_TARGET) != 0)
5834 if (ctx->target_map_scalars_firstprivate)
5835 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
5837 omp_add_variable (ctx, decl, GOVD_MAP | GOVD_MAP_TO_ONLY);
5839 else if (ctx->region_type != ORT_WORKSHARE
5840 && ctx->region_type != ORT_SIMD
5841 && ctx->region_type != ORT_ACC
5842 && !(ctx->region_type & ORT_TARGET_DATA))
5843 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
5845 ctx = ctx->outer_context;
5850 /* Similarly for each of the type sizes of TYPE. */
5853 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type)
5855 if (type == NULL || type == error_mark_node)
5857 type = TYPE_MAIN_VARIANT (type);
5859 if (ctx->privatized_types->add (type))
5862 switch (TREE_CODE (type))
5868 case FIXED_POINT_TYPE:
5869 omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type));
5870 omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type));
5874 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
5875 omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type));
5880 case QUAL_UNION_TYPE:
5883 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5884 if (TREE_CODE (field) == FIELD_DECL)
5886 omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
5887 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
5893 case REFERENCE_TYPE:
5894 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
5901 omp_firstprivatize_variable (ctx, TYPE_SIZE (type));
5902 omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type));
5903 lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type);
5906 /* Add an entry for DECL in the OMP context CTX with FLAGS. */
5909 omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
5912 unsigned int nflags;
5915 if (error_operand_p (decl) || ctx->region_type == ORT_NONE)
5918 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5919 there are constructors involved somewhere. */
5920 if (TREE_ADDRESSABLE (TREE_TYPE (decl))
5921 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
5924 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5925 if (n != NULL && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
5927 /* We shouldn't be re-adding the decl with the same data
5929 gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
5930 nflags = n->value | flags;
5931 /* The only combination of data sharing classes we should see is
5932 FIRSTPRIVATE and LASTPRIVATE. However, OpenACC permits
5933 reduction variables to be used in data sharing clauses. */
5934 gcc_assert ((ctx->region_type & ORT_ACC) != 0
5935 || ((nflags & GOVD_DATA_SHARE_CLASS)
5936 == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE))
5937 || (flags & GOVD_DATA_SHARE_CLASS) == 0);
5942 /* When adding a variable-sized variable, we have to handle all sorts
5943 of additional bits of data: the pointer replacement variable, and
5944 the parameters of the type. */
5945 if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
5947 /* Add the pointer replacement variable as PRIVATE if the variable
5948 replacement is private, else FIRSTPRIVATE since we'll need the
5949 address of the original variable either for SHARED, or for the
5950 copy into or out of the context. */
5951 if (!(flags & GOVD_LOCAL))
5953 if (flags & GOVD_MAP)
5954 nflags = GOVD_MAP | GOVD_MAP_TO_ONLY | GOVD_EXPLICIT;
5955 else if (flags & GOVD_PRIVATE)
5956 nflags = GOVD_PRIVATE;
5957 else if ((ctx->region_type & (ORT_TARGET | ORT_TARGET_DATA)) != 0
5958 && (flags & GOVD_FIRSTPRIVATE))
5959 nflags = GOVD_PRIVATE | GOVD_EXPLICIT;
5961 nflags = GOVD_FIRSTPRIVATE;
5962 nflags |= flags & GOVD_SEEN;
5963 t = DECL_VALUE_EXPR (decl);
5964 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
5965 t = TREE_OPERAND (t, 0);
5966 gcc_assert (DECL_P (t));
5967 omp_add_variable (ctx, t, nflags);
5970 /* Add all of the variable and type parameters (which should have
5971 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5972 omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
5973 omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
5974 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
5976 /* The variable-sized variable itself is never SHARED, only some form
5977 of PRIVATE. The sharing would take place via the pointer variable
5978 which we remapped above. */
5979 if (flags & GOVD_SHARED)
5980 flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
5981 | (flags & (GOVD_SEEN | GOVD_EXPLICIT));
5983 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5984 alloca statement we generate for the variable, so make sure it
5985 is available. This isn't automatically needed for the SHARED
5986 case, since we won't be allocating local storage then.
5987 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5988 in this case omp_notice_variable will be called later
5989 on when it is gimplified. */
5990 else if (! (flags & (GOVD_LOCAL | GOVD_MAP))
5991 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl))))
5992 omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
5994 else if ((flags & (GOVD_MAP | GOVD_LOCAL)) == 0
5995 && lang_hooks.decls.omp_privatize_by_reference (decl))
5997 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
5999 /* Similar to the direct variable sized case above, we'll need the
6000 size of references being privatized. */
6001 if ((flags & GOVD_SHARED) == 0)
6003 t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
6005 omp_notice_variable (ctx, t, true);
6012 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
6015 /* Notice a threadprivate variable DECL used in OMP context CTX.
6016 This just prints out diagnostics about threadprivate variable uses
6017 in untied tasks. If DECL2 is non-NULL, prevent this warning
6018 on that variable. */
6021 omp_notice_threadprivate_variable (struct gimplify_omp_ctx *ctx, tree decl,
6025 struct gimplify_omp_ctx *octx;
6027 for (octx = ctx; octx; octx = octx->outer_context)
6028 if ((octx->region_type & ORT_TARGET) != 0)
6030 n = splay_tree_lookup (octx->variables, (splay_tree_key)decl);
6033 error ("threadprivate variable %qE used in target region",
6035 error_at (octx->location, "enclosing target region");
6036 splay_tree_insert (octx->variables, (splay_tree_key)decl, 0);
6039 splay_tree_insert (octx->variables, (splay_tree_key)decl2, 0);
6042 if (ctx->region_type != ORT_UNTIED_TASK)
6044 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
6047 error ("threadprivate variable %qE used in untied task",
6049 error_at (ctx->location, "enclosing task");
6050 splay_tree_insert (ctx->variables, (splay_tree_key)decl, 0);
6053 splay_tree_insert (ctx->variables, (splay_tree_key)decl2, 0);
6057 /* Return true if global var DECL is device resident. */
6060 device_resident_p (tree decl)
6062 tree attr = lookup_attribute ("oacc declare target", DECL_ATTRIBUTES (decl));
6067 for (tree t = TREE_VALUE (attr); t; t = TREE_PURPOSE (t))
6069 tree c = TREE_VALUE (t);
6070 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_DEVICE_RESIDENT)
6077 /* Determine outer default flags for DECL mentioned in an OMP region
6078 but not declared in an enclosing clause.
6080 ??? Some compiler-generated variables (like SAVE_EXPRs) could be
6081 remapped firstprivate instead of shared. To some extent this is
6082 addressed in omp_firstprivatize_type_sizes, but not
6086 omp_default_clause (struct gimplify_omp_ctx *ctx, tree decl,
6087 bool in_code, unsigned flags)
6089 enum omp_clause_default_kind default_kind = ctx->default_kind;
6090 enum omp_clause_default_kind kind;
6092 kind = lang_hooks.decls.omp_predetermined_sharing (decl);
6093 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
6094 default_kind = kind;
6096 switch (default_kind)
6098 case OMP_CLAUSE_DEFAULT_NONE:
6102 if (ctx->region_type & ORT_PARALLEL)
6104 else if (ctx->region_type & ORT_TASK)
6106 else if (ctx->region_type & ORT_TEAMS)
6111 error ("%qE not specified in enclosing %s",
6112 DECL_NAME (lang_hooks.decls.omp_report_decl (decl)), rtype);
6113 error_at (ctx->location, "enclosing %s", rtype);
6116 case OMP_CLAUSE_DEFAULT_SHARED:
6117 flags |= GOVD_SHARED;
6119 case OMP_CLAUSE_DEFAULT_PRIVATE:
6120 flags |= GOVD_PRIVATE;
6122 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
6123 flags |= GOVD_FIRSTPRIVATE;
6125 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
6126 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
6127 gcc_assert ((ctx->region_type & ORT_TASK) != 0);
6128 if (struct gimplify_omp_ctx *octx = ctx->outer_context)
6130 omp_notice_variable (octx, decl, in_code);
6131 for (; octx; octx = octx->outer_context)
6135 n2 = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
6136 if ((octx->region_type & (ORT_TARGET_DATA | ORT_TARGET)) != 0
6137 && (n2 == NULL || (n2->value & GOVD_DATA_SHARE_CLASS) == 0))
6139 if (n2 && (n2->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED)
6141 flags |= GOVD_FIRSTPRIVATE;
6144 if ((octx->region_type & (ORT_PARALLEL | ORT_TEAMS)) != 0)
6146 flags |= GOVD_SHARED;
6152 if (TREE_CODE (decl) == PARM_DECL
6153 || (!is_global_var (decl)
6154 && DECL_CONTEXT (decl) == current_function_decl))
6155 flags |= GOVD_FIRSTPRIVATE;
6157 flags |= GOVD_SHARED;
6169 /* Determine outer default flags for DECL mentioned in an OACC region
6170 but not declared in an enclosing clause. */
6173 oacc_default_clause (struct gimplify_omp_ctx *ctx, tree decl, unsigned flags)
6176 bool on_device = false;
6177 tree type = TREE_TYPE (decl);
6179 if (lang_hooks.decls.omp_privatize_by_reference (decl))
6180 type = TREE_TYPE (type);
6182 if ((ctx->region_type & (ORT_ACC_PARALLEL | ORT_ACC_KERNELS)) != 0
6183 && is_global_var (decl)
6184 && device_resident_p (decl))
6187 flags |= GOVD_MAP_TO_ONLY;
6190 switch (ctx->region_type)
6195 case ORT_ACC_KERNELS:
6196 /* Scalars are default 'copy' under kernels, non-scalars are default
6197 'present_or_copy'. */
6199 if (!AGGREGATE_TYPE_P (type))
6200 flags |= GOVD_MAP_FORCE;
6205 case ORT_ACC_PARALLEL:
6207 if (on_device || AGGREGATE_TYPE_P (type))
6208 /* Aggregates default to 'present_or_copy'. */
6211 /* Scalars default to 'firstprivate'. */
6212 flags |= GOVD_FIRSTPRIVATE;
6218 if (DECL_ARTIFICIAL (decl))
6219 ; /* We can get compiler-generated decls, and should not complain
6221 else if (ctx->default_kind == OMP_CLAUSE_DEFAULT_NONE)
6223 error ("%qE not specified in enclosing OpenACC %qs construct",
6224 DECL_NAME (lang_hooks.decls.omp_report_decl (decl)), rkind);
6225 inform (ctx->location, "enclosing OpenACC %qs construct", rkind);
6228 gcc_checking_assert (ctx->default_kind == OMP_CLAUSE_DEFAULT_SHARED);
6233 /* Record the fact that DECL was used within the OMP context CTX.
6234 IN_CODE is true when real code uses DECL, and false when we should
6235 merely emit default(none) errors. Return true if DECL is going to
6236 be remapped and thus DECL shouldn't be gimplified into its
6237 DECL_VALUE_EXPR (if any). */
6240 omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
6243 unsigned flags = in_code ? GOVD_SEEN : 0;
6244 bool ret = false, shared;
6246 if (error_operand_p (decl))
6249 if (ctx->region_type == ORT_NONE)
6250 return lang_hooks.decls.omp_disregard_value_expr (decl, false);
6252 if (is_global_var (decl))
6254 /* Threadprivate variables are predetermined. */
6255 if (DECL_THREAD_LOCAL_P (decl))
6256 return omp_notice_threadprivate_variable (ctx, decl, NULL_TREE);
6258 if (DECL_HAS_VALUE_EXPR_P (decl))
6260 tree value = get_base_address (DECL_VALUE_EXPR (decl));
6262 if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
6263 return omp_notice_threadprivate_variable (ctx, decl, value);
6266 if (gimplify_omp_ctxp->outer_context == NULL
6268 && get_oacc_fn_attrib (current_function_decl))
6270 location_t loc = DECL_SOURCE_LOCATION (decl);
6272 if (lookup_attribute ("omp declare target link",
6273 DECL_ATTRIBUTES (decl)))
6276 "%qE with %<link%> clause used in %<routine%> function",
6280 else if (!lookup_attribute ("omp declare target",
6281 DECL_ATTRIBUTES (decl)))
6284 "%qE requires a %<declare%> directive for use "
6285 "in a %<routine%> function", DECL_NAME (decl));
6291 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
6292 if ((ctx->region_type & ORT_TARGET) != 0)
6294 ret = lang_hooks.decls.omp_disregard_value_expr (decl, true);
6297 unsigned nflags = flags;
6298 if (ctx->target_map_pointers_as_0len_arrays
6299 || ctx->target_map_scalars_firstprivate)
6301 bool is_declare_target = false;
6302 bool is_scalar = false;
6303 if (is_global_var (decl)
6304 && varpool_node::get_create (decl)->offloadable)
6306 struct gimplify_omp_ctx *octx;
6307 for (octx = ctx->outer_context;
6308 octx; octx = octx->outer_context)
6310 n = splay_tree_lookup (octx->variables,
6311 (splay_tree_key)decl);
6313 && (n->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED
6314 && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
6317 is_declare_target = octx == NULL;
6319 if (!is_declare_target && ctx->target_map_scalars_firstprivate)
6321 tree type = TREE_TYPE (decl);
6322 if (TREE_CODE (type) == REFERENCE_TYPE)
6323 type = TREE_TYPE (type);
6324 if (TREE_CODE (type) == COMPLEX_TYPE)
6325 type = TREE_TYPE (type);
6326 if (INTEGRAL_TYPE_P (type)
6327 || SCALAR_FLOAT_TYPE_P (type)
6328 || TREE_CODE (type) == POINTER_TYPE)
6331 if (is_declare_target)
6333 else if (ctx->target_map_pointers_as_0len_arrays
6334 && (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
6335 || (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE
6336 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl)))
6338 nflags |= GOVD_MAP | GOVD_MAP_0LEN_ARRAY;
6340 nflags |= GOVD_FIRSTPRIVATE;
6343 struct gimplify_omp_ctx *octx = ctx->outer_context;
6344 if ((ctx->region_type & ORT_ACC) && octx)
6346 /* Look in outer OpenACC contexts, to see if there's a
6347 data attribute for this variable. */
6348 omp_notice_variable (octx, decl, in_code);
6350 for (; octx; octx = octx->outer_context)
6352 if (!(octx->region_type & (ORT_TARGET_DATA | ORT_TARGET)))
6355 = splay_tree_lookup (octx->variables,
6356 (splay_tree_key) decl);
6359 if (octx->region_type == ORT_ACC_HOST_DATA)
6360 error ("variable %qE declared in enclosing "
6361 "%<host_data%> region", DECL_NAME (decl));
6363 if (octx->region_type == ORT_ACC_DATA
6364 && (n2->value & GOVD_MAP_0LEN_ARRAY))
6365 nflags |= GOVD_MAP_0LEN_ARRAY;
6372 tree type = TREE_TYPE (decl);
6375 && gimplify_omp_ctxp->target_firstprivatize_array_bases
6376 && lang_hooks.decls.omp_privatize_by_reference (decl))
6377 type = TREE_TYPE (type);
6379 && !lang_hooks.types.omp_mappable_type (type))
6381 error ("%qD referenced in target region does not have "
6382 "a mappable type", decl);
6383 nflags |= GOVD_MAP | GOVD_EXPLICIT;
6385 else if (nflags == flags)
6387 if ((ctx->region_type & ORT_ACC) != 0)
6388 nflags = oacc_default_clause (ctx, decl, flags);
6394 omp_add_variable (ctx, decl, nflags);
6398 /* If nothing changed, there's nothing left to do. */
6399 if ((n->value & flags) == flags)
6409 if (ctx->region_type == ORT_WORKSHARE
6410 || ctx->region_type == ORT_SIMD
6411 || ctx->region_type == ORT_ACC
6412 || (ctx->region_type & ORT_TARGET_DATA) != 0)
6415 flags = omp_default_clause (ctx, decl, in_code, flags);
6417 if ((flags & GOVD_PRIVATE)
6418 && lang_hooks.decls.omp_private_outer_ref (decl))
6419 flags |= GOVD_PRIVATE_OUTER_REF;
6421 omp_add_variable (ctx, decl, flags);
6423 shared = (flags & GOVD_SHARED) != 0;
6424 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
6428 if ((n->value & (GOVD_SEEN | GOVD_LOCAL)) == 0
6429 && (flags & (GOVD_SEEN | GOVD_LOCAL)) == GOVD_SEEN
6430 && DECL_SIZE (decl))
6432 if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
6435 tree t = DECL_VALUE_EXPR (decl);
6436 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
6437 t = TREE_OPERAND (t, 0);
6438 gcc_assert (DECL_P (t));
6439 n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
6440 n2->value |= GOVD_SEEN;
6442 else if (lang_hooks.decls.omp_privatize_by_reference (decl)
6443 && TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)))
6444 && (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl))))
6448 tree t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
6449 gcc_assert (DECL_P (t));
6450 n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
6452 n2->value |= GOVD_SEEN;
6456 shared = ((flags | n->value) & GOVD_SHARED) != 0;
6457 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
6459 /* If nothing changed, there's nothing left to do. */
6460 if ((n->value & flags) == flags)
6466 /* If the variable is private in the current context, then we don't
6467 need to propagate anything to an outer context. */
6468 if ((flags & GOVD_PRIVATE) && !(flags & GOVD_PRIVATE_OUTER_REF))
6470 if ((flags & (GOVD_LINEAR | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
6471 == (GOVD_LINEAR | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
6473 if ((flags & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
6474 | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
6475 == (GOVD_LASTPRIVATE | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
6477 if (ctx->outer_context
6478 && omp_notice_variable (ctx->outer_context, decl, in_code))
6483 /* Verify that DECL is private within CTX. If there's specific information
6484 to the contrary in the innermost scope, generate an error. */
6487 omp_is_private (struct gimplify_omp_ctx *ctx, tree decl, int simd)
6491 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
6494 if (n->value & GOVD_SHARED)
6496 if (ctx == gimplify_omp_ctxp)
6499 error ("iteration variable %qE is predetermined linear",
6502 error ("iteration variable %qE should be private",
6504 n->value = GOVD_PRIVATE;
6510 else if ((n->value & GOVD_EXPLICIT) != 0
6511 && (ctx == gimplify_omp_ctxp
6512 || (ctx->region_type == ORT_COMBINED_PARALLEL
6513 && gimplify_omp_ctxp->outer_context == ctx)))
6515 if ((n->value & GOVD_FIRSTPRIVATE) != 0)
6516 error ("iteration variable %qE should not be firstprivate",
6518 else if ((n->value & GOVD_REDUCTION) != 0)
6519 error ("iteration variable %qE should not be reduction",
6521 else if (simd == 0 && (n->value & GOVD_LINEAR) != 0)
6522 error ("iteration variable %qE should not be linear",
6524 else if (simd == 1 && (n->value & GOVD_LASTPRIVATE) != 0)
6525 error ("iteration variable %qE should not be lastprivate",
6527 else if (simd && (n->value & GOVD_PRIVATE) != 0)
6528 error ("iteration variable %qE should not be private",
6530 else if (simd == 2 && (n->value & GOVD_LINEAR) != 0)
6531 error ("iteration variable %qE is predetermined linear",
6534 return (ctx == gimplify_omp_ctxp
6535 || (ctx->region_type == ORT_COMBINED_PARALLEL
6536 && gimplify_omp_ctxp->outer_context == ctx));
6539 if (ctx->region_type != ORT_WORKSHARE
6540 && ctx->region_type != ORT_SIMD
6541 && ctx->region_type != ORT_ACC)
6543 else if (ctx->outer_context)
6544 return omp_is_private (ctx->outer_context, decl, simd);
6548 /* Return true if DECL is private within a parallel region
6549 that binds to the current construct's context or in parallel
6550 region's REDUCTION clause. */
6553 omp_check_private (struct gimplify_omp_ctx *ctx, tree decl, bool copyprivate)
6559 ctx = ctx->outer_context;
6562 if (is_global_var (decl))
6565 /* References might be private, but might be shared too,
6566 when checking for copyprivate, assume they might be
6567 private, otherwise assume they might be shared. */
6571 if (lang_hooks.decls.omp_privatize_by_reference (decl))
6574 /* Treat C++ privatized non-static data members outside
6575 of the privatization the same. */
6576 if (omp_member_access_dummy_var (decl))
6582 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
6584 if ((ctx->region_type & (ORT_TARGET | ORT_TARGET_DATA)) != 0
6585 && (n == NULL || (n->value & GOVD_DATA_SHARE_CLASS) == 0))
6590 if ((n->value & GOVD_LOCAL) != 0
6591 && omp_member_access_dummy_var (decl))
6593 return (n->value & GOVD_SHARED) == 0;
6596 while (ctx->region_type == ORT_WORKSHARE
6597 || ctx->region_type == ORT_SIMD
6598 || ctx->region_type == ORT_ACC);
6602 /* Return true if the CTX is combined with distribute and thus
6603 lastprivate can't be supported. */
6606 omp_no_lastprivate (struct gimplify_omp_ctx *ctx)
6610 if (ctx->outer_context == NULL)
6612 ctx = ctx->outer_context;
6613 switch (ctx->region_type)
6616 if (!ctx->combined_loop)
6618 if (ctx->distribute)
6619 return lang_GNU_Fortran ();
6621 case ORT_COMBINED_PARALLEL:
6623 case ORT_COMBINED_TEAMS:
6624 return lang_GNU_Fortran ();
6632 /* Callback for walk_tree to find a DECL_EXPR for the given DECL. */
6635 find_decl_expr (tree *tp, int *walk_subtrees, void *data)
6639 /* If this node has been visited, unmark it and keep looking. */
6640 if (TREE_CODE (t) == DECL_EXPR && DECL_EXPR_DECL (t) == (tree) data)
6643 if (IS_TYPE_OR_DECL_P (t))
6648 /* Scan the OMP clauses in *LIST_P, installing mappings into a new
6649 and previous omp contexts. */
6652 gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
6653 enum omp_region_type region_type,
6654 enum tree_code code)
6656 struct gimplify_omp_ctx *ctx, *outer_ctx;
6658 hash_map<tree, tree> *struct_map_to_clause = NULL;
6659 tree *prev_list_p = NULL;
6661 ctx = new_omp_context (region_type);
6662 outer_ctx = ctx->outer_context;
6663 if (code == OMP_TARGET && !lang_GNU_Fortran ())
6665 ctx->target_map_pointers_as_0len_arrays = true;
6666 /* FIXME: For Fortran we want to set this too, when
6667 the Fortran FE is updated to OpenMP 4.5. */
6668 ctx->target_map_scalars_firstprivate = true;
6670 if (!lang_GNU_Fortran ())
6674 case OMP_TARGET_DATA:
6675 case OMP_TARGET_ENTER_DATA:
6676 case OMP_TARGET_EXIT_DATA:
6677 case OACC_HOST_DATA:
6678 ctx->target_firstprivatize_array_bases = true;
6683 while ((c = *list_p) != NULL)
6685 bool remove = false;
6686 bool notice_outer = true;
6687 const char *check_non_private = NULL;
6691 switch (OMP_CLAUSE_CODE (c))
6693 case OMP_CLAUSE_PRIVATE:
6694 flags = GOVD_PRIVATE | GOVD_EXPLICIT;
6695 if (lang_hooks.decls.omp_private_outer_ref (OMP_CLAUSE_DECL (c)))
6697 flags |= GOVD_PRIVATE_OUTER_REF;
6698 OMP_CLAUSE_PRIVATE_OUTER_REF (c) = 1;
6701 notice_outer = false;
6703 case OMP_CLAUSE_SHARED:
6704 flags = GOVD_SHARED | GOVD_EXPLICIT;
6706 case OMP_CLAUSE_FIRSTPRIVATE:
6707 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
6708 check_non_private = "firstprivate";
6710 case OMP_CLAUSE_LASTPRIVATE:
6711 flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
6712 check_non_private = "lastprivate";
6713 decl = OMP_CLAUSE_DECL (c);
6714 if (omp_no_lastprivate (ctx))
6716 notice_outer = false;
6717 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
6719 else if (error_operand_p (decl))
6722 && (outer_ctx->region_type == ORT_COMBINED_PARALLEL
6723 || outer_ctx->region_type == ORT_COMBINED_TEAMS)
6724 && splay_tree_lookup (outer_ctx->variables,
6725 (splay_tree_key) decl) == NULL)
6727 omp_add_variable (outer_ctx, decl, GOVD_SHARED | GOVD_SEEN);
6728 if (outer_ctx->outer_context)
6729 omp_notice_variable (outer_ctx->outer_context, decl, true);
6732 && (outer_ctx->region_type & ORT_TASK) != 0
6733 && outer_ctx->combined_loop
6734 && splay_tree_lookup (outer_ctx->variables,
6735 (splay_tree_key) decl) == NULL)
6737 omp_add_variable (outer_ctx, decl, GOVD_LASTPRIVATE | GOVD_SEEN);
6738 if (outer_ctx->outer_context)
6739 omp_notice_variable (outer_ctx->outer_context, decl, true);
6742 && (outer_ctx->region_type == ORT_WORKSHARE
6743 || outer_ctx->region_type == ORT_ACC)
6744 && outer_ctx->combined_loop
6745 && splay_tree_lookup (outer_ctx->variables,
6746 (splay_tree_key) decl) == NULL
6747 && !omp_check_private (outer_ctx, decl, false))
6749 omp_add_variable (outer_ctx, decl, GOVD_LASTPRIVATE | GOVD_SEEN);
6750 if (outer_ctx->outer_context
6751 && (outer_ctx->outer_context->region_type
6752 == ORT_COMBINED_PARALLEL)
6753 && splay_tree_lookup (outer_ctx->outer_context->variables,
6754 (splay_tree_key) decl) == NULL)
6756 struct gimplify_omp_ctx *octx = outer_ctx->outer_context;
6757 omp_add_variable (octx, decl, GOVD_SHARED | GOVD_SEEN);
6758 if (octx->outer_context)
6759 omp_notice_variable (octx->outer_context, decl, true);
6761 else if (outer_ctx->outer_context)
6762 omp_notice_variable (outer_ctx->outer_context, decl, true);
6765 case OMP_CLAUSE_REDUCTION:
6766 flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
6767 /* OpenACC permits reductions on private variables. */
6768 if (!(region_type & ORT_ACC))
6769 check_non_private = "reduction";
6770 decl = OMP_CLAUSE_DECL (c);
6771 if (TREE_CODE (decl) == MEM_REF)
6773 tree type = TREE_TYPE (decl);
6774 if (gimplify_expr (&TYPE_MAX_VALUE (TYPE_DOMAIN (type)), pre_p,
6775 NULL, is_gimple_val, fb_rvalue, false)
6781 tree v = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
6784 omp_firstprivatize_variable (ctx, v);
6785 omp_notice_variable (ctx, v, true);
6787 decl = TREE_OPERAND (decl, 0);
6788 if (TREE_CODE (decl) == POINTER_PLUS_EXPR)
6790 if (gimplify_expr (&TREE_OPERAND (decl, 1), pre_p,
6791 NULL, is_gimple_val, fb_rvalue, false)
6797 v = TREE_OPERAND (decl, 1);
6800 omp_firstprivatize_variable (ctx, v);
6801 omp_notice_variable (ctx, v, true);
6803 decl = TREE_OPERAND (decl, 0);
6805 if (TREE_CODE (decl) == ADDR_EXPR
6806 || TREE_CODE (decl) == INDIRECT_REF)
6807 decl = TREE_OPERAND (decl, 0);
6810 case OMP_CLAUSE_LINEAR:
6811 if (gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c), pre_p, NULL,
6812 is_gimple_val, fb_rvalue) == GS_ERROR)
6819 if (code == OMP_SIMD
6820 && !OMP_CLAUSE_LINEAR_NO_COPYIN (c))
6822 struct gimplify_omp_ctx *octx = outer_ctx;
6824 && octx->region_type == ORT_WORKSHARE
6825 && octx->combined_loop
6826 && !octx->distribute)
6828 if (octx->outer_context
6829 && (octx->outer_context->region_type
6830 == ORT_COMBINED_PARALLEL))
6831 octx = octx->outer_context->outer_context;
6833 octx = octx->outer_context;
6836 && octx->region_type == ORT_WORKSHARE
6837 && octx->combined_loop
6839 && !lang_GNU_Fortran ())
6841 error_at (OMP_CLAUSE_LOCATION (c),
6842 "%<linear%> clause for variable other than "
6843 "loop iterator specified on construct "
6844 "combined with %<distribute%>");
6849 /* For combined #pragma omp parallel for simd, need to put
6850 lastprivate and perhaps firstprivate too on the
6851 parallel. Similarly for #pragma omp for simd. */
6852 struct gimplify_omp_ctx *octx = outer_ctx;
6854 if (omp_no_lastprivate (ctx))
6855 OMP_CLAUSE_LINEAR_NO_COPYOUT (c) = 1;
6858 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c)
6859 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
6861 decl = OMP_CLAUSE_DECL (c);
6862 if (error_operand_p (decl))
6868 if (!OMP_CLAUSE_LINEAR_NO_COPYIN (c))
6869 flags |= GOVD_FIRSTPRIVATE;
6870 if (!OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
6871 flags |= GOVD_LASTPRIVATE;
6873 && octx->region_type == ORT_WORKSHARE
6874 && octx->combined_loop)
6876 if (octx->outer_context
6877 && (octx->outer_context->region_type
6878 == ORT_COMBINED_PARALLEL))
6879 octx = octx->outer_context;
6880 else if (omp_check_private (octx, decl, false))
6884 && (octx->region_type & ORT_TASK) != 0
6885 && octx->combined_loop)
6888 && octx->region_type == ORT_COMBINED_PARALLEL
6889 && ctx->region_type == ORT_WORKSHARE
6890 && octx == outer_ctx)
6891 flags = GOVD_SEEN | GOVD_SHARED;
6893 && octx->region_type == ORT_COMBINED_TEAMS)
6894 flags = GOVD_SEEN | GOVD_SHARED;
6896 && octx->region_type == ORT_COMBINED_TARGET)
6898 flags &= ~GOVD_LASTPRIVATE;
6899 if (flags == GOVD_SEEN)
6905 = splay_tree_lookup (octx->variables,
6906 (splay_tree_key) decl);
6907 if (on && (on->value & GOVD_DATA_SHARE_CLASS) != 0)
6912 omp_add_variable (octx, decl, flags);
6913 if (octx->outer_context == NULL)
6915 octx = octx->outer_context;
6920 && (!OMP_CLAUSE_LINEAR_NO_COPYIN (c)
6921 || !OMP_CLAUSE_LINEAR_NO_COPYOUT (c)))
6922 omp_notice_variable (octx, decl, true);
6924 flags = GOVD_LINEAR | GOVD_EXPLICIT;
6925 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c)
6926 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
6928 notice_outer = false;
6929 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
6933 case OMP_CLAUSE_MAP:
6934 decl = OMP_CLAUSE_DECL (c);
6935 if (error_operand_p (decl))
6942 if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
6945 case OMP_TARGET_DATA:
6946 case OMP_TARGET_ENTER_DATA:
6947 case OMP_TARGET_EXIT_DATA:
6948 case OACC_ENTER_DATA:
6949 case OACC_EXIT_DATA:
6950 case OACC_HOST_DATA:
6951 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER
6952 || (OMP_CLAUSE_MAP_KIND (c)
6953 == GOMP_MAP_FIRSTPRIVATE_REFERENCE))
6954 /* For target {,enter ,exit }data only the array slice is
6955 mapped, but not the pointer to it. */
6963 if (DECL_P (decl) && outer_ctx && (region_type & ORT_ACC))
6965 struct gimplify_omp_ctx *octx;
6966 for (octx = outer_ctx; octx; octx = octx->outer_context)
6968 if (octx->region_type != ORT_ACC_HOST_DATA)
6971 = splay_tree_lookup (octx->variables,
6972 (splay_tree_key) decl);
6974 error_at (OMP_CLAUSE_LOCATION (c), "variable %qE "
6975 "declared in enclosing %<host_data%> region",
6979 if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
6980 OMP_CLAUSE_SIZE (c) = DECL_P (decl) ? DECL_SIZE_UNIT (decl)
6981 : TYPE_SIZE_UNIT (TREE_TYPE (decl));
6982 if (gimplify_expr (&OMP_CLAUSE_SIZE (c), pre_p,
6983 NULL, is_gimple_val, fb_rvalue) == GS_ERROR)
6988 else if ((OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER
6989 || (OMP_CLAUSE_MAP_KIND (c)
6990 == GOMP_MAP_FIRSTPRIVATE_REFERENCE))
6991 && TREE_CODE (OMP_CLAUSE_SIZE (c)) != INTEGER_CST)
6994 = get_initialized_tmp_var (OMP_CLAUSE_SIZE (c), pre_p, NULL,
6996 omp_add_variable (ctx, OMP_CLAUSE_SIZE (c),
6997 GOVD_FIRSTPRIVATE | GOVD_SEEN);
7002 if (TREE_CODE (d) == ARRAY_REF)
7004 while (TREE_CODE (d) == ARRAY_REF)
7005 d = TREE_OPERAND (d, 0);
7006 if (TREE_CODE (d) == COMPONENT_REF
7007 && TREE_CODE (TREE_TYPE (d)) == ARRAY_TYPE)
7010 pd = &OMP_CLAUSE_DECL (c);
7012 && TREE_CODE (decl) == INDIRECT_REF
7013 && TREE_CODE (TREE_OPERAND (decl, 0)) == COMPONENT_REF
7014 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl, 0)))
7017 pd = &TREE_OPERAND (decl, 0);
7018 decl = TREE_OPERAND (decl, 0);
7020 if (TREE_CODE (decl) == COMPONENT_REF)
7022 while (TREE_CODE (decl) == COMPONENT_REF)
7023 decl = TREE_OPERAND (decl, 0);
7024 if (TREE_CODE (decl) == INDIRECT_REF
7025 && DECL_P (TREE_OPERAND (decl, 0))
7026 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl, 0)))
7028 decl = TREE_OPERAND (decl, 0);
7030 if (gimplify_expr (pd, pre_p, NULL, is_gimple_lvalue, fb_lvalue)
7038 if (error_operand_p (decl))
7044 tree stype = TREE_TYPE (decl);
7045 if (TREE_CODE (stype) == REFERENCE_TYPE)
7046 stype = TREE_TYPE (stype);
7047 if (TYPE_SIZE_UNIT (stype) == NULL
7048 || TREE_CODE (TYPE_SIZE_UNIT (stype)) != INTEGER_CST)
7050 error_at (OMP_CLAUSE_LOCATION (c),
7051 "mapping field %qE of variable length "
7052 "structure", OMP_CLAUSE_DECL (c));
7057 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_POINTER)
7059 /* Error recovery. */
7060 if (prev_list_p == NULL)
7065 if (OMP_CLAUSE_CHAIN (*prev_list_p) != c)
7067 tree ch = OMP_CLAUSE_CHAIN (*prev_list_p);
7068 if (ch == NULL_TREE || OMP_CLAUSE_CHAIN (ch) != c)
7077 HOST_WIDE_INT bitsize, bitpos;
7079 int unsignedp, reversep, volatilep = 0;
7080 tree base = OMP_CLAUSE_DECL (c);
7081 while (TREE_CODE (base) == ARRAY_REF)
7082 base = TREE_OPERAND (base, 0);
7083 if (TREE_CODE (base) == INDIRECT_REF)
7084 base = TREE_OPERAND (base, 0);
7085 base = get_inner_reference (base, &bitsize, &bitpos, &offset,
7086 &mode, &unsignedp, &reversep,
7088 tree orig_base = base;
7089 if ((TREE_CODE (base) == INDIRECT_REF
7090 || (TREE_CODE (base) == MEM_REF
7091 && integer_zerop (TREE_OPERAND (base, 1))))
7092 && DECL_P (TREE_OPERAND (base, 0))
7093 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0)))
7095 base = TREE_OPERAND (base, 0);
7096 gcc_assert (base == decl
7097 && (offset == NULL_TREE
7098 || TREE_CODE (offset) == INTEGER_CST));
7101 = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
7102 bool ptr = (OMP_CLAUSE_MAP_KIND (c)
7103 == GOMP_MAP_ALWAYS_POINTER);
7104 if (n == NULL || (n->value & GOVD_MAP) == 0)
7106 tree l = build_omp_clause (OMP_CLAUSE_LOCATION (c),
7108 OMP_CLAUSE_SET_MAP_KIND (l, GOMP_MAP_STRUCT);
7109 if (orig_base != base)
7110 OMP_CLAUSE_DECL (l) = unshare_expr (orig_base);
7112 OMP_CLAUSE_DECL (l) = decl;
7113 OMP_CLAUSE_SIZE (l) = size_int (1);
7114 if (struct_map_to_clause == NULL)
7115 struct_map_to_clause = new hash_map<tree, tree>;
7116 struct_map_to_clause->put (decl, l);
7119 enum gomp_map_kind mkind
7120 = code == OMP_TARGET_EXIT_DATA
7121 ? GOMP_MAP_RELEASE : GOMP_MAP_ALLOC;
7122 tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
7124 OMP_CLAUSE_SET_MAP_KIND (c2, mkind);
7125 OMP_CLAUSE_DECL (c2)
7126 = unshare_expr (OMP_CLAUSE_DECL (c));
7127 OMP_CLAUSE_CHAIN (c2) = *prev_list_p;
7128 OMP_CLAUSE_SIZE (c2)
7129 = TYPE_SIZE_UNIT (ptr_type_node);
7130 OMP_CLAUSE_CHAIN (l) = c2;
7131 if (OMP_CLAUSE_CHAIN (*prev_list_p) != c)
7133 tree c4 = OMP_CLAUSE_CHAIN (*prev_list_p);
7135 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
7137 OMP_CLAUSE_SET_MAP_KIND (c3, mkind);
7138 OMP_CLAUSE_DECL (c3)
7139 = unshare_expr (OMP_CLAUSE_DECL (c4));
7140 OMP_CLAUSE_SIZE (c3)
7141 = TYPE_SIZE_UNIT (ptr_type_node);
7142 OMP_CLAUSE_CHAIN (c3) = *prev_list_p;
7143 OMP_CLAUSE_CHAIN (c2) = c3;
7150 OMP_CLAUSE_CHAIN (l) = c;
7152 list_p = &OMP_CLAUSE_CHAIN (l);
7154 if (orig_base != base && code == OMP_TARGET)
7156 tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
7158 enum gomp_map_kind mkind
7159 = GOMP_MAP_FIRSTPRIVATE_REFERENCE;
7160 OMP_CLAUSE_SET_MAP_KIND (c2, mkind);
7161 OMP_CLAUSE_DECL (c2) = decl;
7162 OMP_CLAUSE_SIZE (c2) = size_zero_node;
7163 OMP_CLAUSE_CHAIN (c2) = OMP_CLAUSE_CHAIN (l);
7164 OMP_CLAUSE_CHAIN (l) = c2;
7166 flags = GOVD_MAP | GOVD_EXPLICIT;
7167 if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c)) || ptr)
7173 tree *osc = struct_map_to_clause->get (decl);
7174 tree *sc = NULL, *scp = NULL;
7175 if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c)) || ptr)
7176 n->value |= GOVD_SEEN;
7179 o1 = wi::to_offset (offset);
7183 o1 = o1 + bitpos / BITS_PER_UNIT;
7184 sc = &OMP_CLAUSE_CHAIN (*osc);
7186 && (OMP_CLAUSE_MAP_KIND (*sc)
7187 == GOMP_MAP_FIRSTPRIVATE_REFERENCE))
7188 sc = &OMP_CLAUSE_CHAIN (*sc);
7189 for (; *sc != c; sc = &OMP_CLAUSE_CHAIN (*sc))
7190 if (ptr && sc == prev_list_p)
7192 else if (TREE_CODE (OMP_CLAUSE_DECL (*sc))
7194 && (TREE_CODE (OMP_CLAUSE_DECL (*sc))
7196 && (TREE_CODE (OMP_CLAUSE_DECL (*sc))
7202 HOST_WIDE_INT bitsize2, bitpos2;
7203 base = OMP_CLAUSE_DECL (*sc);
7204 if (TREE_CODE (base) == ARRAY_REF)
7206 while (TREE_CODE (base) == ARRAY_REF)
7207 base = TREE_OPERAND (base, 0);
7208 if (TREE_CODE (base) != COMPONENT_REF
7209 || (TREE_CODE (TREE_TYPE (base))
7213 else if (TREE_CODE (base) == INDIRECT_REF
7214 && (TREE_CODE (TREE_OPERAND (base, 0))
7216 && (TREE_CODE (TREE_TYPE
7217 (TREE_OPERAND (base, 0)))
7219 base = TREE_OPERAND (base, 0);
7220 base = get_inner_reference (base, &bitsize2,
7223 &reversep, &volatilep);
7224 if ((TREE_CODE (base) == INDIRECT_REF
7225 || (TREE_CODE (base) == MEM_REF
7226 && integer_zerop (TREE_OPERAND (base,
7228 && DECL_P (TREE_OPERAND (base, 0))
7229 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base,
7232 base = TREE_OPERAND (base, 0);
7237 gcc_assert (offset == NULL_TREE
7238 || TREE_CODE (offset) == INTEGER_CST);
7239 tree d1 = OMP_CLAUSE_DECL (*sc);
7240 tree d2 = OMP_CLAUSE_DECL (c);
7241 while (TREE_CODE (d1) == ARRAY_REF)
7242 d1 = TREE_OPERAND (d1, 0);
7243 while (TREE_CODE (d2) == ARRAY_REF)
7244 d2 = TREE_OPERAND (d2, 0);
7245 if (TREE_CODE (d1) == INDIRECT_REF)
7246 d1 = TREE_OPERAND (d1, 0);
7247 if (TREE_CODE (d2) == INDIRECT_REF)
7248 d2 = TREE_OPERAND (d2, 0);
7249 while (TREE_CODE (d1) == COMPONENT_REF)
7250 if (TREE_CODE (d2) == COMPONENT_REF
7251 && TREE_OPERAND (d1, 1)
7252 == TREE_OPERAND (d2, 1))
7254 d1 = TREE_OPERAND (d1, 0);
7255 d2 = TREE_OPERAND (d2, 0);
7261 error_at (OMP_CLAUSE_LOCATION (c),
7262 "%qE appears more than once in map "
7263 "clauses", OMP_CLAUSE_DECL (c));
7268 o2 = wi::to_offset (offset2);
7272 o2 = o2 + bitpos2 / BITS_PER_UNIT;
7273 if (wi::ltu_p (o1, o2)
7274 || (wi::eq_p (o1, o2) && bitpos < bitpos2))
7284 OMP_CLAUSE_SIZE (*osc)
7285 = size_binop (PLUS_EXPR, OMP_CLAUSE_SIZE (*osc),
7289 tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
7291 tree cl = NULL_TREE;
7292 enum gomp_map_kind mkind
7293 = code == OMP_TARGET_EXIT_DATA
7294 ? GOMP_MAP_RELEASE : GOMP_MAP_ALLOC;
7295 OMP_CLAUSE_SET_MAP_KIND (c2, mkind);
7296 OMP_CLAUSE_DECL (c2)
7297 = unshare_expr (OMP_CLAUSE_DECL (c));
7298 OMP_CLAUSE_CHAIN (c2) = scp ? *scp : *prev_list_p;
7299 OMP_CLAUSE_SIZE (c2)
7300 = TYPE_SIZE_UNIT (ptr_type_node);
7301 cl = scp ? *prev_list_p : c2;
7302 if (OMP_CLAUSE_CHAIN (*prev_list_p) != c)
7304 tree c4 = OMP_CLAUSE_CHAIN (*prev_list_p);
7306 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
7308 OMP_CLAUSE_SET_MAP_KIND (c3, mkind);
7309 OMP_CLAUSE_DECL (c3)
7310 = unshare_expr (OMP_CLAUSE_DECL (c4));
7311 OMP_CLAUSE_SIZE (c3)
7312 = TYPE_SIZE_UNIT (ptr_type_node);
7313 OMP_CLAUSE_CHAIN (c3) = *prev_list_p;
7315 OMP_CLAUSE_CHAIN (c2) = c3;
7321 if (sc == prev_list_p)
7328 *prev_list_p = OMP_CLAUSE_CHAIN (c);
7329 list_p = prev_list_p;
7331 OMP_CLAUSE_CHAIN (c) = *sc;
7338 *list_p = OMP_CLAUSE_CHAIN (c);
7339 OMP_CLAUSE_CHAIN (c) = *sc;
7346 && OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_ALWAYS_POINTER
7347 && OMP_CLAUSE_CHAIN (c)
7348 && OMP_CLAUSE_CODE (OMP_CLAUSE_CHAIN (c)) == OMP_CLAUSE_MAP
7349 && (OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (c))
7350 == GOMP_MAP_ALWAYS_POINTER))
7351 prev_list_p = list_p;
7354 flags = GOVD_MAP | GOVD_EXPLICIT;
7355 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_TO
7356 || OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_TOFROM)
7357 flags |= GOVD_MAP_ALWAYS_TO;
7360 case OMP_CLAUSE_DEPEND:
7361 if (OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SINK
7362 || OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SOURCE)
7364 /* Nothing to do. OMP_CLAUSE_DECL will be lowered in
7368 if (TREE_CODE (OMP_CLAUSE_DECL (c)) == COMPOUND_EXPR)
7370 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (c), 0), pre_p,
7371 NULL, is_gimple_val, fb_rvalue);
7372 OMP_CLAUSE_DECL (c) = TREE_OPERAND (OMP_CLAUSE_DECL (c), 1);
7374 if (error_operand_p (OMP_CLAUSE_DECL (c)))
7379 OMP_CLAUSE_DECL (c) = build_fold_addr_expr (OMP_CLAUSE_DECL (c));
7380 if (gimplify_expr (&OMP_CLAUSE_DECL (c), pre_p, NULL,
7381 is_gimple_val, fb_rvalue) == GS_ERROR)
7389 case OMP_CLAUSE_FROM:
7390 case OMP_CLAUSE__CACHE_:
7391 decl = OMP_CLAUSE_DECL (c);
7392 if (error_operand_p (decl))
7397 if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
7398 OMP_CLAUSE_SIZE (c) = DECL_P (decl) ? DECL_SIZE_UNIT (decl)
7399 : TYPE_SIZE_UNIT (TREE_TYPE (decl));
7400 if (gimplify_expr (&OMP_CLAUSE_SIZE (c), pre_p,
7401 NULL, is_gimple_val, fb_rvalue) == GS_ERROR)
7408 if (gimplify_expr (&OMP_CLAUSE_DECL (c), pre_p,
7409 NULL, is_gimple_lvalue, fb_lvalue)
7419 case OMP_CLAUSE_USE_DEVICE_PTR:
7420 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
7422 case OMP_CLAUSE_IS_DEVICE_PTR:
7423 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
7427 decl = OMP_CLAUSE_DECL (c);
7429 if (error_operand_p (decl))
7434 if (DECL_NAME (decl) == NULL_TREE && (flags & GOVD_SHARED) == 0)
7436 tree t = omp_member_access_dummy_var (decl);
7439 tree v = DECL_VALUE_EXPR (decl);
7440 DECL_NAME (decl) = DECL_NAME (TREE_OPERAND (v, 1));
7442 omp_notice_variable (outer_ctx, t, true);
7445 if (code == OACC_DATA
7446 && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
7447 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
7448 flags |= GOVD_MAP_0LEN_ARRAY;
7449 omp_add_variable (ctx, decl, flags);
7450 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
7451 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
7453 omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
7454 GOVD_LOCAL | GOVD_SEEN);
7455 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c)
7456 && walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c),
7458 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c),
7460 omp_add_variable (ctx,
7461 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c),
7462 GOVD_LOCAL | GOVD_SEEN);
7463 gimplify_omp_ctxp = ctx;
7464 push_gimplify_context ();
7466 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = NULL;
7467 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = NULL;
7469 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c),
7470 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
7471 pop_gimplify_context
7472 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c)));
7473 push_gimplify_context ();
7474 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c),
7475 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c));
7476 pop_gimplify_context
7477 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c)));
7478 OMP_CLAUSE_REDUCTION_INIT (c) = NULL_TREE;
7479 OMP_CLAUSE_REDUCTION_MERGE (c) = NULL_TREE;
7481 gimplify_omp_ctxp = outer_ctx;
7483 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
7484 && OMP_CLAUSE_LASTPRIVATE_STMT (c))
7486 gimplify_omp_ctxp = ctx;
7487 push_gimplify_context ();
7488 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c)) != BIND_EXPR)
7490 tree bind = build3 (BIND_EXPR, void_type_node, NULL,
7492 TREE_SIDE_EFFECTS (bind) = 1;
7493 BIND_EXPR_BODY (bind) = OMP_CLAUSE_LASTPRIVATE_STMT (c);
7494 OMP_CLAUSE_LASTPRIVATE_STMT (c) = bind;
7496 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c),
7497 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
7498 pop_gimplify_context
7499 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c)));
7500 OMP_CLAUSE_LASTPRIVATE_STMT (c) = NULL_TREE;
7502 gimplify_omp_ctxp = outer_ctx;
7504 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
7505 && OMP_CLAUSE_LINEAR_STMT (c))
7507 gimplify_omp_ctxp = ctx;
7508 push_gimplify_context ();
7509 if (TREE_CODE (OMP_CLAUSE_LINEAR_STMT (c)) != BIND_EXPR)
7511 tree bind = build3 (BIND_EXPR, void_type_node, NULL,
7513 TREE_SIDE_EFFECTS (bind) = 1;
7514 BIND_EXPR_BODY (bind) = OMP_CLAUSE_LINEAR_STMT (c);
7515 OMP_CLAUSE_LINEAR_STMT (c) = bind;
7517 gimplify_and_add (OMP_CLAUSE_LINEAR_STMT (c),
7518 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c));
7519 pop_gimplify_context
7520 (gimple_seq_first_stmt (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c)));
7521 OMP_CLAUSE_LINEAR_STMT (c) = NULL_TREE;
7523 gimplify_omp_ctxp = outer_ctx;
7529 case OMP_CLAUSE_COPYIN:
7530 case OMP_CLAUSE_COPYPRIVATE:
7531 decl = OMP_CLAUSE_DECL (c);
7532 if (error_operand_p (decl))
7537 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_COPYPRIVATE
7539 && !omp_check_private (ctx, decl, true))
7542 if (is_global_var (decl))
7544 if (DECL_THREAD_LOCAL_P (decl))
7546 else if (DECL_HAS_VALUE_EXPR_P (decl))
7548 tree value = get_base_address (DECL_VALUE_EXPR (decl));
7552 && DECL_THREAD_LOCAL_P (value))
7557 error_at (OMP_CLAUSE_LOCATION (c),
7558 "copyprivate variable %qE is not threadprivate"
7559 " or private in outer context", DECL_NAME (decl));
7563 omp_notice_variable (outer_ctx, decl, true);
7564 if (check_non_private
7565 && region_type == ORT_WORKSHARE
7566 && (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_REDUCTION
7567 || decl == OMP_CLAUSE_DECL (c)
7568 || (TREE_CODE (OMP_CLAUSE_DECL (c)) == MEM_REF
7569 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c), 0))
7571 || (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c), 0))
7572 == POINTER_PLUS_EXPR
7573 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND
7574 (OMP_CLAUSE_DECL (c), 0), 0))
7576 && omp_check_private (ctx, decl, false))
7578 error ("%s variable %qE is private in outer context",
7579 check_non_private, DECL_NAME (decl));
7585 if (OMP_CLAUSE_IF_MODIFIER (c) != ERROR_MARK
7586 && OMP_CLAUSE_IF_MODIFIER (c) != code)
7589 for (int i = 0; i < 2; i++)
7590 switch (i ? OMP_CLAUSE_IF_MODIFIER (c) : code)
7592 case OMP_PARALLEL: p[i] = "parallel"; break;
7593 case OMP_TASK: p[i] = "task"; break;
7594 case OMP_TASKLOOP: p[i] = "taskloop"; break;
7595 case OMP_TARGET_DATA: p[i] = "target data"; break;
7596 case OMP_TARGET: p[i] = "target"; break;
7597 case OMP_TARGET_UPDATE: p[i] = "target update"; break;
7598 case OMP_TARGET_ENTER_DATA:
7599 p[i] = "target enter data"; break;
7600 case OMP_TARGET_EXIT_DATA: p[i] = "target exit data"; break;
7601 default: gcc_unreachable ();
7603 error_at (OMP_CLAUSE_LOCATION (c),
7604 "expected %qs %<if%> clause modifier rather than %qs",
7610 case OMP_CLAUSE_FINAL:
7611 OMP_CLAUSE_OPERAND (c, 0)
7612 = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
7615 case OMP_CLAUSE_SCHEDULE:
7616 case OMP_CLAUSE_NUM_THREADS:
7617 case OMP_CLAUSE_NUM_TEAMS:
7618 case OMP_CLAUSE_THREAD_LIMIT:
7619 case OMP_CLAUSE_DIST_SCHEDULE:
7620 case OMP_CLAUSE_DEVICE:
7621 case OMP_CLAUSE_PRIORITY:
7622 case OMP_CLAUSE_GRAINSIZE:
7623 case OMP_CLAUSE_NUM_TASKS:
7624 case OMP_CLAUSE_HINT:
7625 case OMP_CLAUSE__CILK_FOR_COUNT_:
7626 case OMP_CLAUSE_ASYNC:
7627 case OMP_CLAUSE_WAIT:
7628 case OMP_CLAUSE_NUM_GANGS:
7629 case OMP_CLAUSE_NUM_WORKERS:
7630 case OMP_CLAUSE_VECTOR_LENGTH:
7631 case OMP_CLAUSE_WORKER:
7632 case OMP_CLAUSE_VECTOR:
7633 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
7634 is_gimple_val, fb_rvalue) == GS_ERROR)
7638 case OMP_CLAUSE_GANG:
7639 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
7640 is_gimple_val, fb_rvalue) == GS_ERROR)
7642 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 1), pre_p, NULL,
7643 is_gimple_val, fb_rvalue) == GS_ERROR)
7647 case OMP_CLAUSE_TILE:
7648 for (tree list = OMP_CLAUSE_TILE_LIST (c); !remove && list;
7649 list = TREE_CHAIN (list))
7651 if (gimplify_expr (&TREE_VALUE (list), pre_p, NULL,
7652 is_gimple_val, fb_rvalue) == GS_ERROR)
7657 case OMP_CLAUSE_NOWAIT:
7658 case OMP_CLAUSE_ORDERED:
7659 case OMP_CLAUSE_UNTIED:
7660 case OMP_CLAUSE_COLLAPSE:
7661 case OMP_CLAUSE_AUTO:
7662 case OMP_CLAUSE_SEQ:
7663 case OMP_CLAUSE_INDEPENDENT:
7664 case OMP_CLAUSE_MERGEABLE:
7665 case OMP_CLAUSE_PROC_BIND:
7666 case OMP_CLAUSE_SAFELEN:
7667 case OMP_CLAUSE_SIMDLEN:
7668 case OMP_CLAUSE_NOGROUP:
7669 case OMP_CLAUSE_THREADS:
7670 case OMP_CLAUSE_SIMD:
7673 case OMP_CLAUSE_DEFAULTMAP:
7674 ctx->target_map_scalars_firstprivate = false;
7677 case OMP_CLAUSE_ALIGNED:
7678 decl = OMP_CLAUSE_DECL (c);
7679 if (error_operand_p (decl))
7684 if (gimplify_expr (&OMP_CLAUSE_ALIGNED_ALIGNMENT (c), pre_p, NULL,
7685 is_gimple_val, fb_rvalue) == GS_ERROR)
7690 if (!is_global_var (decl)
7691 && TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE)
7692 omp_add_variable (ctx, decl, GOVD_ALIGNED);
7695 case OMP_CLAUSE_DEFAULT:
7696 ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
7703 if (code == OACC_DATA
7704 && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
7705 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
7708 *list_p = OMP_CLAUSE_CHAIN (c);
7710 list_p = &OMP_CLAUSE_CHAIN (c);
7713 gimplify_omp_ctxp = ctx;
7714 if (struct_map_to_clause)
7715 delete struct_map_to_clause;
7718 /* Return true if DECL is a candidate for shared to firstprivate
7719 optimization. We only consider non-addressable scalars, not
7720 too big, and not references. */
7723 omp_shared_to_firstprivate_optimizable_decl_p (tree decl)
7725 if (TREE_ADDRESSABLE (decl))
7727 tree type = TREE_TYPE (decl);
7728 if (!is_gimple_reg_type (type)
7729 || TREE_CODE (type) == REFERENCE_TYPE
7730 || TREE_ADDRESSABLE (type))
7732 /* Don't optimize too large decls, as each thread/task will have
7734 HOST_WIDE_INT len = int_size_in_bytes (type);
7735 if (len == -1 || len > 4 * POINTER_SIZE / BITS_PER_UNIT)
7737 if (lang_hooks.decls.omp_privatize_by_reference (decl))
7742 /* Helper function of omp_find_stores_op and gimplify_adjust_omp_clauses*.
7743 For omp_shared_to_firstprivate_optimizable_decl_p decl mark it as
7744 GOVD_WRITTEN in outer contexts. */
7747 omp_mark_stores (struct gimplify_omp_ctx *ctx, tree decl)
7749 for (; ctx; ctx = ctx->outer_context)
7751 splay_tree_node n = splay_tree_lookup (ctx->variables,
7752 (splay_tree_key) decl);
7755 else if (n->value & GOVD_SHARED)
7757 n->value |= GOVD_WRITTEN;
7760 else if (n->value & GOVD_DATA_SHARE_CLASS)
7765 /* Helper callback for walk_gimple_seq to discover possible stores
7766 to omp_shared_to_firstprivate_optimizable_decl_p decls and set
7767 GOVD_WRITTEN if they are GOVD_SHARED in some outer context
7771 omp_find_stores_op (tree *tp, int *walk_subtrees, void *data)
7773 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
7782 if (handled_component_p (op))
7783 op = TREE_OPERAND (op, 0);
7784 else if ((TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
7785 && TREE_CODE (TREE_OPERAND (op, 0)) == ADDR_EXPR)
7786 op = TREE_OPERAND (TREE_OPERAND (op, 0), 0);
7791 if (!DECL_P (op) || !omp_shared_to_firstprivate_optimizable_decl_p (op))
7794 omp_mark_stores (gimplify_omp_ctxp, op);
7798 /* Helper callback for walk_gimple_seq to discover possible stores
7799 to omp_shared_to_firstprivate_optimizable_decl_p decls and set
7800 GOVD_WRITTEN if they are GOVD_SHARED in some outer context
7804 omp_find_stores_stmt (gimple_stmt_iterator *gsi_p,
7805 bool *handled_ops_p,
7806 struct walk_stmt_info *wi)
7808 gimple *stmt = gsi_stmt (*gsi_p);
7809 switch (gimple_code (stmt))
7811 /* Don't recurse on OpenMP constructs for which
7812 gimplify_adjust_omp_clauses already handled the bodies,
7813 except handle gimple_omp_for_pre_body. */
7814 case GIMPLE_OMP_FOR:
7815 *handled_ops_p = true;
7816 if (gimple_omp_for_pre_body (stmt))
7817 walk_gimple_seq (gimple_omp_for_pre_body (stmt),
7818 omp_find_stores_stmt, omp_find_stores_op, wi);
7820 case GIMPLE_OMP_PARALLEL:
7821 case GIMPLE_OMP_TASK:
7822 case GIMPLE_OMP_SECTIONS:
7823 case GIMPLE_OMP_SINGLE:
7824 case GIMPLE_OMP_TARGET:
7825 case GIMPLE_OMP_TEAMS:
7826 case GIMPLE_OMP_CRITICAL:
7827 *handled_ops_p = true;
7835 struct gimplify_adjust_omp_clauses_data
7841 /* For all variables that were not actually used within the context,
7842 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
7845 gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data)
7847 tree *list_p = ((struct gimplify_adjust_omp_clauses_data *) data)->list_p;
7849 = ((struct gimplify_adjust_omp_clauses_data *) data)->pre_p;
7850 tree decl = (tree) n->key;
7851 unsigned flags = n->value;
7852 enum omp_clause_code code;
7856 if (flags & (GOVD_EXPLICIT | GOVD_LOCAL))
7858 if ((flags & GOVD_SEEN) == 0)
7860 if (flags & GOVD_DEBUG_PRIVATE)
7862 gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_PRIVATE);
7863 private_debug = true;
7865 else if (flags & GOVD_MAP)
7866 private_debug = false;
7869 = lang_hooks.decls.omp_private_debug_clause (decl,
7870 !!(flags & GOVD_SHARED));
7872 code = OMP_CLAUSE_PRIVATE;
7873 else if (flags & GOVD_MAP)
7874 code = OMP_CLAUSE_MAP;
7875 else if (flags & GOVD_SHARED)
7877 if (is_global_var (decl))
7879 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
7883 = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
7884 if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
7885 | GOVD_PRIVATE | GOVD_REDUCTION
7886 | GOVD_LINEAR | GOVD_MAP)) != 0)
7888 ctx = ctx->outer_context;
7893 code = OMP_CLAUSE_SHARED;
7895 else if (flags & GOVD_PRIVATE)
7896 code = OMP_CLAUSE_PRIVATE;
7897 else if (flags & GOVD_FIRSTPRIVATE)
7898 code = OMP_CLAUSE_FIRSTPRIVATE;
7899 else if (flags & GOVD_LASTPRIVATE)
7900 code = OMP_CLAUSE_LASTPRIVATE;
7901 else if (flags & GOVD_ALIGNED)
7906 if (((flags & GOVD_LASTPRIVATE)
7907 || (code == OMP_CLAUSE_SHARED && (flags & GOVD_WRITTEN)))
7908 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
7909 omp_mark_stores (gimplify_omp_ctxp->outer_context, decl);
7911 clause = build_omp_clause (input_location, code);
7912 OMP_CLAUSE_DECL (clause) = decl;
7913 OMP_CLAUSE_CHAIN (clause) = *list_p;
7915 OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
7916 else if (code == OMP_CLAUSE_PRIVATE && (flags & GOVD_PRIVATE_OUTER_REF))
7917 OMP_CLAUSE_PRIVATE_OUTER_REF (clause) = 1;
7918 else if (code == OMP_CLAUSE_SHARED
7919 && (flags & GOVD_WRITTEN) == 0
7920 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
7921 OMP_CLAUSE_SHARED_READONLY (clause) = 1;
7922 else if (code == OMP_CLAUSE_FIRSTPRIVATE && (flags & GOVD_EXPLICIT) == 0)
7923 OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT (clause) = 1;
7924 else if (code == OMP_CLAUSE_MAP && (flags & GOVD_MAP_0LEN_ARRAY) != 0)
7926 tree nc = build_omp_clause (input_location, OMP_CLAUSE_MAP);
7927 OMP_CLAUSE_DECL (nc) = decl;
7928 if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE
7929 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == POINTER_TYPE)
7930 OMP_CLAUSE_DECL (clause)
7931 = build_simple_mem_ref_loc (input_location, decl);
7932 OMP_CLAUSE_DECL (clause)
7933 = build2 (MEM_REF, char_type_node, OMP_CLAUSE_DECL (clause),
7934 build_int_cst (build_pointer_type (char_type_node), 0));
7935 OMP_CLAUSE_SIZE (clause) = size_zero_node;
7936 OMP_CLAUSE_SIZE (nc) = size_zero_node;
7937 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_ALLOC);
7938 OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (clause) = 1;
7939 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_FIRSTPRIVATE_POINTER);
7940 OMP_CLAUSE_CHAIN (nc) = *list_p;
7941 OMP_CLAUSE_CHAIN (clause) = nc;
7942 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
7943 gimplify_omp_ctxp = ctx->outer_context;
7944 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (clause), 0),
7945 pre_p, NULL, is_gimple_val, fb_rvalue);
7946 gimplify_omp_ctxp = ctx;
7948 else if (code == OMP_CLAUSE_MAP)
7950 int kind = (flags & GOVD_MAP_TO_ONLY
7953 if (flags & GOVD_MAP_FORCE)
7954 kind |= GOMP_MAP_FLAG_FORCE;
7955 OMP_CLAUSE_SET_MAP_KIND (clause, kind);
7956 if (DECL_SIZE (decl)
7957 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
7959 tree decl2 = DECL_VALUE_EXPR (decl);
7960 gcc_assert (TREE_CODE (decl2) == INDIRECT_REF);
7961 decl2 = TREE_OPERAND (decl2, 0);
7962 gcc_assert (DECL_P (decl2));
7963 tree mem = build_simple_mem_ref (decl2);
7964 OMP_CLAUSE_DECL (clause) = mem;
7965 OMP_CLAUSE_SIZE (clause) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
7966 if (gimplify_omp_ctxp->outer_context)
7968 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
7969 omp_notice_variable (ctx, decl2, true);
7970 omp_notice_variable (ctx, OMP_CLAUSE_SIZE (clause), true);
7972 tree nc = build_omp_clause (OMP_CLAUSE_LOCATION (clause),
7974 OMP_CLAUSE_DECL (nc) = decl;
7975 OMP_CLAUSE_SIZE (nc) = size_zero_node;
7976 if (gimplify_omp_ctxp->target_firstprivatize_array_bases)
7977 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_FIRSTPRIVATE_POINTER);
7979 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_POINTER);
7980 OMP_CLAUSE_CHAIN (nc) = OMP_CLAUSE_CHAIN (clause);
7981 OMP_CLAUSE_CHAIN (clause) = nc;
7983 else if (gimplify_omp_ctxp->target_firstprivatize_array_bases
7984 && lang_hooks.decls.omp_privatize_by_reference (decl))
7986 OMP_CLAUSE_DECL (clause) = build_simple_mem_ref (decl);
7987 OMP_CLAUSE_SIZE (clause)
7988 = unshare_expr (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl))));
7989 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
7990 gimplify_omp_ctxp = ctx->outer_context;
7991 gimplify_expr (&OMP_CLAUSE_SIZE (clause),
7992 pre_p, NULL, is_gimple_val, fb_rvalue);
7993 gimplify_omp_ctxp = ctx;
7994 tree nc = build_omp_clause (OMP_CLAUSE_LOCATION (clause),
7996 OMP_CLAUSE_DECL (nc) = decl;
7997 OMP_CLAUSE_SIZE (nc) = size_zero_node;
7998 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_FIRSTPRIVATE_REFERENCE);
7999 OMP_CLAUSE_CHAIN (nc) = OMP_CLAUSE_CHAIN (clause);
8000 OMP_CLAUSE_CHAIN (clause) = nc;
8003 OMP_CLAUSE_SIZE (clause) = DECL_SIZE_UNIT (decl);
8005 if (code == OMP_CLAUSE_FIRSTPRIVATE && (flags & GOVD_LASTPRIVATE) != 0)
8007 tree nc = build_omp_clause (input_location, OMP_CLAUSE_LASTPRIVATE);
8008 OMP_CLAUSE_DECL (nc) = decl;
8009 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (nc) = 1;
8010 OMP_CLAUSE_CHAIN (nc) = *list_p;
8011 OMP_CLAUSE_CHAIN (clause) = nc;
8012 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8013 gimplify_omp_ctxp = ctx->outer_context;
8014 lang_hooks.decls.omp_finish_clause (nc, pre_p);
8015 gimplify_omp_ctxp = ctx;
8018 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8019 gimplify_omp_ctxp = ctx->outer_context;
8020 lang_hooks.decls.omp_finish_clause (clause, pre_p);
8021 gimplify_omp_ctxp = ctx;
8026 gimplify_adjust_omp_clauses (gimple_seq *pre_p, gimple_seq body, tree *list_p,
8027 enum tree_code code)
8029 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
8034 struct gimplify_omp_ctx *octx;
8035 for (octx = ctx; octx; octx = octx->outer_context)
8036 if ((octx->region_type & (ORT_PARALLEL | ORT_TASK | ORT_TEAMS)) != 0)
8040 struct walk_stmt_info wi;
8041 memset (&wi, 0, sizeof (wi));
8042 walk_gimple_seq (body, omp_find_stores_stmt,
8043 omp_find_stores_op, &wi);
8046 while ((c = *list_p) != NULL)
8049 bool remove = false;
8051 switch (OMP_CLAUSE_CODE (c))
8053 case OMP_CLAUSE_PRIVATE:
8054 case OMP_CLAUSE_SHARED:
8055 case OMP_CLAUSE_FIRSTPRIVATE:
8056 case OMP_CLAUSE_LINEAR:
8057 decl = OMP_CLAUSE_DECL (c);
8058 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8059 remove = !(n->value & GOVD_SEEN);
8062 bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
8063 if ((n->value & GOVD_DEBUG_PRIVATE)
8064 || lang_hooks.decls.omp_private_debug_clause (decl, shared))
8066 gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
8067 || ((n->value & GOVD_DATA_SHARE_CLASS)
8069 OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
8070 OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
8072 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED
8073 && (n->value & GOVD_WRITTEN) == 0
8075 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
8076 OMP_CLAUSE_SHARED_READONLY (c) = 1;
8077 else if (DECL_P (decl)
8078 && ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED
8079 && (n->value & GOVD_WRITTEN) != 1)
8080 || (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
8081 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c)))
8082 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
8083 omp_mark_stores (gimplify_omp_ctxp->outer_context, decl);
8087 case OMP_CLAUSE_LASTPRIVATE:
8088 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
8089 accurately reflect the presence of a FIRSTPRIVATE clause. */
8090 decl = OMP_CLAUSE_DECL (c);
8091 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8092 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
8093 = (n->value & GOVD_FIRSTPRIVATE) != 0;
8094 if (omp_no_lastprivate (ctx))
8096 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c))
8099 OMP_CLAUSE_CODE (c) = OMP_CLAUSE_PRIVATE;
8101 else if (code == OMP_DISTRIBUTE
8102 && OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c))
8105 error_at (OMP_CLAUSE_LOCATION (c),
8106 "same variable used in %<firstprivate%> and "
8107 "%<lastprivate%> clauses on %<distribute%> "
8111 && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
8113 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
8114 omp_mark_stores (gimplify_omp_ctxp->outer_context, decl);
8117 case OMP_CLAUSE_ALIGNED:
8118 decl = OMP_CLAUSE_DECL (c);
8119 if (!is_global_var (decl))
8121 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8122 remove = n == NULL || !(n->value & GOVD_SEEN);
8123 if (!remove && TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE)
8125 struct gimplify_omp_ctx *octx;
8127 && (n->value & (GOVD_DATA_SHARE_CLASS
8128 & ~GOVD_FIRSTPRIVATE)))
8131 for (octx = ctx->outer_context; octx;
8132 octx = octx->outer_context)
8134 n = splay_tree_lookup (octx->variables,
8135 (splay_tree_key) decl);
8138 if (n->value & GOVD_LOCAL)
8140 /* We have to avoid assigning a shared variable
8141 to itself when trying to add
8142 __builtin_assume_aligned. */
8143 if (n->value & GOVD_SHARED)
8151 else if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
8153 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8154 if (n != NULL && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
8159 case OMP_CLAUSE_MAP:
8160 if (code == OMP_TARGET_EXIT_DATA
8161 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_ALWAYS_POINTER)
8166 decl = OMP_CLAUSE_DECL (c);
8167 /* Data clauses associated with acc parallel reductions must be
8168 compatible with present_or_copy. Warn and adjust the clause
8169 if that is not the case. */
8170 if (ctx->region_type == ORT_ACC_PARALLEL)
8172 tree t = DECL_P (decl) ? decl : TREE_OPERAND (decl, 0);
8176 n = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
8178 if (n && (n->value & GOVD_REDUCTION))
8180 enum gomp_map_kind kind = OMP_CLAUSE_MAP_KIND (c);
8182 OMP_CLAUSE_MAP_IN_REDUCTION (c) = 1;
8183 if ((kind & GOMP_MAP_TOFROM) != GOMP_MAP_TOFROM
8184 && kind != GOMP_MAP_FORCE_PRESENT
8185 && kind != GOMP_MAP_POINTER)
8187 warning_at (OMP_CLAUSE_LOCATION (c), 0,
8188 "incompatible data clause with reduction "
8189 "on %qE; promoting to present_or_copy",
8191 OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_TOFROM);
8197 if ((ctx->region_type & ORT_TARGET) != 0
8198 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
8200 if (TREE_CODE (decl) == INDIRECT_REF
8201 && TREE_CODE (TREE_OPERAND (decl, 0)) == COMPONENT_REF
8202 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl, 0)))
8204 decl = TREE_OPERAND (decl, 0);
8205 if (TREE_CODE (decl) == COMPONENT_REF)
8207 while (TREE_CODE (decl) == COMPONENT_REF)
8208 decl = TREE_OPERAND (decl, 0);
8211 n = splay_tree_lookup (ctx->variables,
8212 (splay_tree_key) decl);
8213 if (!(n->value & GOVD_SEEN))
8220 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8221 if ((ctx->region_type & ORT_TARGET) != 0
8222 && !(n->value & GOVD_SEEN)
8223 && GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c)) == 0
8224 && !lookup_attribute ("omp declare target link",
8225 DECL_ATTRIBUTES (decl)))
8228 /* For struct element mapping, if struct is never referenced
8229 in target block and none of the mapping has always modifier,
8230 remove all the struct element mappings, which immediately
8231 follow the GOMP_MAP_STRUCT map clause. */
8232 if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_STRUCT)
8234 HOST_WIDE_INT cnt = tree_to_shwi (OMP_CLAUSE_SIZE (c));
8236 OMP_CLAUSE_CHAIN (c)
8237 = OMP_CLAUSE_CHAIN (OMP_CLAUSE_CHAIN (c));
8240 else if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_STRUCT
8241 && code == OMP_TARGET_EXIT_DATA)
8243 else if (DECL_SIZE (decl)
8244 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST
8245 && OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_POINTER
8246 && OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_FIRSTPRIVATE_POINTER
8247 && (OMP_CLAUSE_MAP_KIND (c)
8248 != GOMP_MAP_FIRSTPRIVATE_REFERENCE))
8250 /* For GOMP_MAP_FORCE_DEVICEPTR, we'll never enter here, because
8251 for these, TREE_CODE (DECL_SIZE (decl)) will always be
8253 gcc_assert (OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_FORCE_DEVICEPTR);
8255 tree decl2 = DECL_VALUE_EXPR (decl);
8256 gcc_assert (TREE_CODE (decl2) == INDIRECT_REF);
8257 decl2 = TREE_OPERAND (decl2, 0);
8258 gcc_assert (DECL_P (decl2));
8259 tree mem = build_simple_mem_ref (decl2);
8260 OMP_CLAUSE_DECL (c) = mem;
8261 OMP_CLAUSE_SIZE (c) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
8262 if (ctx->outer_context)
8264 omp_notice_variable (ctx->outer_context, decl2, true);
8265 omp_notice_variable (ctx->outer_context,
8266 OMP_CLAUSE_SIZE (c), true);
8268 if (((ctx->region_type & ORT_TARGET) != 0
8269 || !ctx->target_firstprivatize_array_bases)
8270 && ((n->value & GOVD_SEEN) == 0
8271 || (n->value & (GOVD_PRIVATE | GOVD_FIRSTPRIVATE)) == 0))
8273 tree nc = build_omp_clause (OMP_CLAUSE_LOCATION (c),
8275 OMP_CLAUSE_DECL (nc) = decl;
8276 OMP_CLAUSE_SIZE (nc) = size_zero_node;
8277 if (ctx->target_firstprivatize_array_bases)
8278 OMP_CLAUSE_SET_MAP_KIND (nc,
8279 GOMP_MAP_FIRSTPRIVATE_POINTER);
8281 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_POINTER);
8282 OMP_CLAUSE_CHAIN (nc) = OMP_CLAUSE_CHAIN (c);
8283 OMP_CLAUSE_CHAIN (c) = nc;
8289 if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
8290 OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (decl);
8291 gcc_assert ((n->value & GOVD_SEEN) == 0
8292 || ((n->value & (GOVD_PRIVATE | GOVD_FIRSTPRIVATE))
8298 case OMP_CLAUSE_FROM:
8299 case OMP_CLAUSE__CACHE_:
8300 decl = OMP_CLAUSE_DECL (c);
8303 if (DECL_SIZE (decl)
8304 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
8306 tree decl2 = DECL_VALUE_EXPR (decl);
8307 gcc_assert (TREE_CODE (decl2) == INDIRECT_REF);
8308 decl2 = TREE_OPERAND (decl2, 0);
8309 gcc_assert (DECL_P (decl2));
8310 tree mem = build_simple_mem_ref (decl2);
8311 OMP_CLAUSE_DECL (c) = mem;
8312 OMP_CLAUSE_SIZE (c) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
8313 if (ctx->outer_context)
8315 omp_notice_variable (ctx->outer_context, decl2, true);
8316 omp_notice_variable (ctx->outer_context,
8317 OMP_CLAUSE_SIZE (c), true);
8320 else if (OMP_CLAUSE_SIZE (c) == NULL_TREE)
8321 OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (decl);
8324 case OMP_CLAUSE_REDUCTION:
8325 decl = OMP_CLAUSE_DECL (c);
8326 /* OpenACC reductions need a present_or_copy data clause.
8327 Add one if necessary. Error is the reduction is private. */
8328 if (ctx->region_type == ORT_ACC_PARALLEL)
8330 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
8331 if (n->value & (GOVD_PRIVATE | GOVD_FIRSTPRIVATE))
8332 error_at (OMP_CLAUSE_LOCATION (c), "invalid private "
8333 "reduction on %qE", DECL_NAME (decl));
8334 else if ((n->value & GOVD_MAP) == 0)
8336 tree next = OMP_CLAUSE_CHAIN (c);
8337 tree nc = build_omp_clause (UNKNOWN_LOCATION, OMP_CLAUSE_MAP);
8338 OMP_CLAUSE_SET_MAP_KIND (nc, GOMP_MAP_TOFROM);
8339 OMP_CLAUSE_DECL (nc) = decl;
8340 OMP_CLAUSE_CHAIN (c) = nc;
8341 lang_hooks.decls.omp_finish_clause (nc, pre_p);
8344 OMP_CLAUSE_MAP_IN_REDUCTION (nc) = 1;
8345 if (OMP_CLAUSE_CHAIN (nc) == NULL)
8347 nc = OMP_CLAUSE_CHAIN (nc);
8349 OMP_CLAUSE_CHAIN (nc) = next;
8350 n->value |= GOVD_MAP;
8354 && omp_shared_to_firstprivate_optimizable_decl_p (decl))
8355 omp_mark_stores (gimplify_omp_ctxp->outer_context, decl);
8357 case OMP_CLAUSE_COPYIN:
8358 case OMP_CLAUSE_COPYPRIVATE:
8360 case OMP_CLAUSE_NUM_THREADS:
8361 case OMP_CLAUSE_NUM_TEAMS:
8362 case OMP_CLAUSE_THREAD_LIMIT:
8363 case OMP_CLAUSE_DIST_SCHEDULE:
8364 case OMP_CLAUSE_DEVICE:
8365 case OMP_CLAUSE_SCHEDULE:
8366 case OMP_CLAUSE_NOWAIT:
8367 case OMP_CLAUSE_ORDERED:
8368 case OMP_CLAUSE_DEFAULT:
8369 case OMP_CLAUSE_UNTIED:
8370 case OMP_CLAUSE_COLLAPSE:
8371 case OMP_CLAUSE_FINAL:
8372 case OMP_CLAUSE_MERGEABLE:
8373 case OMP_CLAUSE_PROC_BIND:
8374 case OMP_CLAUSE_SAFELEN:
8375 case OMP_CLAUSE_SIMDLEN:
8376 case OMP_CLAUSE_DEPEND:
8377 case OMP_CLAUSE_PRIORITY:
8378 case OMP_CLAUSE_GRAINSIZE:
8379 case OMP_CLAUSE_NUM_TASKS:
8380 case OMP_CLAUSE_NOGROUP:
8381 case OMP_CLAUSE_THREADS:
8382 case OMP_CLAUSE_SIMD:
8383 case OMP_CLAUSE_HINT:
8384 case OMP_CLAUSE_DEFAULTMAP:
8385 case OMP_CLAUSE_USE_DEVICE_PTR:
8386 case OMP_CLAUSE_IS_DEVICE_PTR:
8387 case OMP_CLAUSE__CILK_FOR_COUNT_:
8388 case OMP_CLAUSE_ASYNC:
8389 case OMP_CLAUSE_WAIT:
8390 case OMP_CLAUSE_INDEPENDENT:
8391 case OMP_CLAUSE_NUM_GANGS:
8392 case OMP_CLAUSE_NUM_WORKERS:
8393 case OMP_CLAUSE_VECTOR_LENGTH:
8394 case OMP_CLAUSE_GANG:
8395 case OMP_CLAUSE_WORKER:
8396 case OMP_CLAUSE_VECTOR:
8397 case OMP_CLAUSE_AUTO:
8398 case OMP_CLAUSE_SEQ:
8401 case OMP_CLAUSE_TILE:
8402 /* We're not yet making use of the information provided by OpenACC
8403 tile clauses. Discard these here, to simplify later middle end
8413 *list_p = OMP_CLAUSE_CHAIN (c);
8415 list_p = &OMP_CLAUSE_CHAIN (c);
8418 /* Add in any implicit data sharing. */
8419 struct gimplify_adjust_omp_clauses_data data;
8420 data.list_p = list_p;
8422 splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, &data);
8424 gimplify_omp_ctxp = ctx->outer_context;
8425 delete_omp_context (ctx);
8428 /* Gimplify OACC_CACHE. */
8431 gimplify_oacc_cache (tree *expr_p, gimple_seq *pre_p)
8433 tree expr = *expr_p;
8435 gimplify_scan_omp_clauses (&OACC_CACHE_CLAUSES (expr), pre_p, ORT_ACC,
8437 gimplify_adjust_omp_clauses (pre_p, NULL, &OACC_CACHE_CLAUSES (expr),
8440 /* TODO: Do something sensible with this information. */
8442 *expr_p = NULL_TREE;
8445 /* Helper function of gimplify_oacc_declare. The helper's purpose is to,
8446 if required, translate 'kind' in CLAUSE into an 'entry' kind and 'exit'
8447 kind. The entry kind will replace the one in CLAUSE, while the exit
8448 kind will be used in a new omp_clause and returned to the caller. */
8451 gimplify_oacc_declare_1 (tree clause)
8453 HOST_WIDE_INT kind, new_op;
8457 kind = OMP_CLAUSE_MAP_KIND (clause);
8461 case GOMP_MAP_ALLOC:
8462 case GOMP_MAP_FORCE_ALLOC:
8463 case GOMP_MAP_FORCE_TO:
8464 new_op = GOMP_MAP_DELETE;
8468 case GOMP_MAP_FORCE_FROM:
8469 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_FORCE_ALLOC);
8470 new_op = GOMP_MAP_FORCE_FROM;
8474 case GOMP_MAP_FORCE_TOFROM:
8475 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_FORCE_TO);
8476 new_op = GOMP_MAP_FORCE_FROM;
8481 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_FORCE_ALLOC);
8482 new_op = GOMP_MAP_FROM;
8486 case GOMP_MAP_TOFROM:
8487 OMP_CLAUSE_SET_MAP_KIND (clause, GOMP_MAP_TO);
8488 new_op = GOMP_MAP_FROM;
8492 case GOMP_MAP_DEVICE_RESIDENT:
8493 case GOMP_MAP_FORCE_DEVICEPTR:
8494 case GOMP_MAP_FORCE_PRESENT:
8496 case GOMP_MAP_POINTER:
8507 c = build_omp_clause (OMP_CLAUSE_LOCATION (clause), OMP_CLAUSE_MAP);
8508 OMP_CLAUSE_SET_MAP_KIND (c, new_op);
8509 OMP_CLAUSE_DECL (c) = OMP_CLAUSE_DECL (clause);
8515 /* Gimplify OACC_DECLARE. */
8518 gimplify_oacc_declare (tree *expr_p, gimple_seq *pre_p)
8520 tree expr = *expr_p;
8524 clauses = OACC_DECLARE_CLAUSES (expr);
8526 gimplify_scan_omp_clauses (&clauses, pre_p, ORT_TARGET_DATA, OACC_DECLARE);
8528 for (t = clauses; t; t = OMP_CLAUSE_CHAIN (t))
8530 tree decl = OMP_CLAUSE_DECL (t);
8532 if (TREE_CODE (decl) == MEM_REF)
8535 if (TREE_CODE (decl) == VAR_DECL
8536 && !is_global_var (decl)
8537 && DECL_CONTEXT (decl) == current_function_decl)
8539 tree c = gimplify_oacc_declare_1 (t);
8542 if (oacc_declare_returns == NULL)
8543 oacc_declare_returns = new hash_map<tree, tree>;
8545 oacc_declare_returns->put (decl, c);
8549 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_SEEN);
8552 stmt = gimple_build_omp_target (NULL, GF_OMP_TARGET_KIND_OACC_DECLARE,
8555 gimplify_seq_add_stmt (pre_p, stmt);
8557 *expr_p = NULL_TREE;
8560 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
8561 gimplification of the body, as well as scanning the body for used
8562 variables. We need to do this scan now, because variable-sized
8563 decls will be decomposed during gimplification. */
8566 gimplify_omp_parallel (tree *expr_p, gimple_seq *pre_p)
8568 tree expr = *expr_p;
8570 gimple_seq body = NULL;
8572 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p,
8573 OMP_PARALLEL_COMBINED (expr)
8574 ? ORT_COMBINED_PARALLEL
8575 : ORT_PARALLEL, OMP_PARALLEL);
8577 push_gimplify_context ();
8579 g = gimplify_and_return_first (OMP_PARALLEL_BODY (expr), &body);
8580 if (gimple_code (g) == GIMPLE_BIND)
8581 pop_gimplify_context (g);
8583 pop_gimplify_context (NULL);
8585 gimplify_adjust_omp_clauses (pre_p, body, &OMP_PARALLEL_CLAUSES (expr),
8588 g = gimple_build_omp_parallel (body,
8589 OMP_PARALLEL_CLAUSES (expr),
8590 NULL_TREE, NULL_TREE);
8591 if (OMP_PARALLEL_COMBINED (expr))
8592 gimple_omp_set_subcode (g, GF_OMP_PARALLEL_COMBINED);
8593 gimplify_seq_add_stmt (pre_p, g);
8594 *expr_p = NULL_TREE;
8597 /* Gimplify the contents of an OMP_TASK statement. This involves
8598 gimplification of the body, as well as scanning the body for used
8599 variables. We need to do this scan now, because variable-sized
8600 decls will be decomposed during gimplification. */
8603 gimplify_omp_task (tree *expr_p, gimple_seq *pre_p)
8605 tree expr = *expr_p;
8607 gimple_seq body = NULL;
8609 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr), pre_p,
8610 find_omp_clause (OMP_TASK_CLAUSES (expr),
8612 ? ORT_UNTIED_TASK : ORT_TASK, OMP_TASK);
8614 push_gimplify_context ();
8616 g = gimplify_and_return_first (OMP_TASK_BODY (expr), &body);
8617 if (gimple_code (g) == GIMPLE_BIND)
8618 pop_gimplify_context (g);
8620 pop_gimplify_context (NULL);
8622 gimplify_adjust_omp_clauses (pre_p, body, &OMP_TASK_CLAUSES (expr),
8625 g = gimple_build_omp_task (body,
8626 OMP_TASK_CLAUSES (expr),
8627 NULL_TREE, NULL_TREE,
8628 NULL_TREE, NULL_TREE, NULL_TREE);
8629 gimplify_seq_add_stmt (pre_p, g);
8630 *expr_p = NULL_TREE;
8633 /* Helper function of gimplify_omp_for, find OMP_FOR resp. OMP_SIMD
8634 with non-NULL OMP_FOR_INIT. */
8637 find_combined_omp_for (tree *tp, int *walk_subtrees, void *)
8640 switch (TREE_CODE (*tp))
8646 if (OMP_FOR_INIT (*tp) != NULL_TREE)
8650 case STATEMENT_LIST:
8660 /* Gimplify the gross structure of an OMP_FOR statement. */
8662 static enum gimplify_status
8663 gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
8665 tree for_stmt, orig_for_stmt, inner_for_stmt = NULL_TREE, decl, var, t;
8666 enum gimplify_status ret = GS_ALL_DONE;
8667 enum gimplify_status tret;
8669 gimple_seq for_body, for_pre_body;
8671 bitmap has_decl_expr = NULL;
8672 enum omp_region_type ort = ORT_WORKSHARE;
8674 orig_for_stmt = for_stmt = *expr_p;
8676 switch (TREE_CODE (for_stmt))
8680 case OMP_DISTRIBUTE:
8686 if (find_omp_clause (OMP_FOR_CLAUSES (for_stmt), OMP_CLAUSE_UNTIED))
8687 ort = ORT_UNTIED_TASK;
8699 /* Set OMP_CLAUSE_LINEAR_NO_COPYIN flag on explicit linear
8700 clause for the IV. */
8701 if (ort == ORT_SIMD && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) == 1)
8703 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), 0);
8704 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
8705 decl = TREE_OPERAND (t, 0);
8706 for (tree c = OMP_FOR_CLAUSES (for_stmt); c; c = OMP_CLAUSE_CHAIN (c))
8707 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
8708 && OMP_CLAUSE_DECL (c) == decl)
8710 OMP_CLAUSE_LINEAR_NO_COPYIN (c) = 1;
8715 if (OMP_FOR_INIT (for_stmt) == NULL_TREE)
8717 gcc_assert (TREE_CODE (for_stmt) != OACC_LOOP);
8718 inner_for_stmt = walk_tree (&OMP_FOR_BODY (for_stmt),
8719 find_combined_omp_for, NULL, NULL);
8720 if (inner_for_stmt == NULL_TREE)
8722 gcc_assert (seen_error ());
8723 *expr_p = NULL_TREE;
8728 if (TREE_CODE (for_stmt) != OMP_TASKLOOP)
8729 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p, ort,
8730 TREE_CODE (for_stmt));
8732 if (TREE_CODE (for_stmt) == OMP_DISTRIBUTE)
8733 gimplify_omp_ctxp->distribute = true;
8735 /* Handle OMP_FOR_INIT. */
8736 for_pre_body = NULL;
8737 if (ort == ORT_SIMD && OMP_FOR_PRE_BODY (for_stmt))
8739 has_decl_expr = BITMAP_ALLOC (NULL);
8740 if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt)) == DECL_EXPR
8741 && TREE_CODE (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt)))
8744 t = OMP_FOR_PRE_BODY (for_stmt);
8745 bitmap_set_bit (has_decl_expr, DECL_UID (DECL_EXPR_DECL (t)));
8747 else if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt)) == STATEMENT_LIST)
8749 tree_stmt_iterator si;
8750 for (si = tsi_start (OMP_FOR_PRE_BODY (for_stmt)); !tsi_end_p (si);
8754 if (TREE_CODE (t) == DECL_EXPR
8755 && TREE_CODE (DECL_EXPR_DECL (t)) == VAR_DECL)
8756 bitmap_set_bit (has_decl_expr, DECL_UID (DECL_EXPR_DECL (t)));
8760 if (OMP_FOR_PRE_BODY (for_stmt))
8762 if (TREE_CODE (for_stmt) != OMP_TASKLOOP || gimplify_omp_ctxp)
8763 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt), &for_pre_body);
8766 struct gimplify_omp_ctx ctx;
8767 memset (&ctx, 0, sizeof (ctx));
8768 ctx.region_type = ORT_NONE;
8769 gimplify_omp_ctxp = &ctx;
8770 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt), &for_pre_body);
8771 gimplify_omp_ctxp = NULL;
8774 OMP_FOR_PRE_BODY (for_stmt) = NULL_TREE;
8776 if (OMP_FOR_INIT (for_stmt) == NULL_TREE)
8777 for_stmt = inner_for_stmt;
8779 /* For taskloop, need to gimplify the start, end and step before the
8780 taskloop, outside of the taskloop omp context. */
8781 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
8783 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
8785 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
8786 if (!is_gimple_constant (TREE_OPERAND (t, 1)))
8789 = get_initialized_tmp_var (TREE_OPERAND (t, 1),
8790 pre_p, NULL, false);
8791 tree c = build_omp_clause (input_location,
8792 OMP_CLAUSE_FIRSTPRIVATE);
8793 OMP_CLAUSE_DECL (c) = TREE_OPERAND (t, 1);
8794 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (orig_for_stmt);
8795 OMP_FOR_CLAUSES (orig_for_stmt) = c;
8798 /* Handle OMP_FOR_COND. */
8799 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
8800 if (!is_gimple_constant (TREE_OPERAND (t, 1)))
8803 = get_initialized_tmp_var (TREE_OPERAND (t, 1),
8804 gimple_seq_empty_p (for_pre_body)
8805 ? pre_p : &for_pre_body, NULL,
8807 tree c = build_omp_clause (input_location,
8808 OMP_CLAUSE_FIRSTPRIVATE);
8809 OMP_CLAUSE_DECL (c) = TREE_OPERAND (t, 1);
8810 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (orig_for_stmt);
8811 OMP_FOR_CLAUSES (orig_for_stmt) = c;
8814 /* Handle OMP_FOR_INCR. */
8815 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
8816 if (TREE_CODE (t) == MODIFY_EXPR)
8818 decl = TREE_OPERAND (t, 0);
8819 t = TREE_OPERAND (t, 1);
8820 tree *tp = &TREE_OPERAND (t, 1);
8821 if (TREE_CODE (t) == PLUS_EXPR && *tp == decl)
8822 tp = &TREE_OPERAND (t, 0);
8824 if (!is_gimple_constant (*tp))
8826 gimple_seq *seq = gimple_seq_empty_p (for_pre_body)
8827 ? pre_p : &for_pre_body;
8828 *tp = get_initialized_tmp_var (*tp, seq, NULL, false);
8829 tree c = build_omp_clause (input_location,
8830 OMP_CLAUSE_FIRSTPRIVATE);
8831 OMP_CLAUSE_DECL (c) = *tp;
8832 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (orig_for_stmt);
8833 OMP_FOR_CLAUSES (orig_for_stmt) = c;
8838 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (orig_for_stmt), pre_p, ort,
8842 if (orig_for_stmt != for_stmt)
8843 gimplify_omp_ctxp->combined_loop = true;
8846 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
8847 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt)));
8848 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
8849 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt)));
8851 tree c = find_omp_clause (OMP_FOR_CLAUSES (for_stmt), OMP_CLAUSE_ORDERED);
8852 bool is_doacross = false;
8853 if (c && OMP_CLAUSE_ORDERED_EXPR (c))
8856 gimplify_omp_ctxp->loop_iter_var.create (TREE_VEC_LENGTH
8857 (OMP_FOR_INIT (for_stmt))
8861 c = find_omp_clause (OMP_FOR_CLAUSES (for_stmt), OMP_CLAUSE_COLLAPSE);
8863 collapse = tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (c));
8864 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
8866 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
8867 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
8868 decl = TREE_OPERAND (t, 0);
8869 gcc_assert (DECL_P (decl));
8870 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl))
8871 || POINTER_TYPE_P (TREE_TYPE (decl)));
8874 if (TREE_CODE (for_stmt) == OMP_FOR && OMP_FOR_ORIG_DECLS (for_stmt))
8875 gimplify_omp_ctxp->loop_iter_var.quick_push
8876 (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt), i));
8878 gimplify_omp_ctxp->loop_iter_var.quick_push (decl);
8879 gimplify_omp_ctxp->loop_iter_var.quick_push (decl);
8882 /* Make sure the iteration variable is private. */
8884 tree c2 = NULL_TREE;
8885 if (orig_for_stmt != for_stmt)
8886 /* Do this only on innermost construct for combined ones. */;
8887 else if (ort == ORT_SIMD)
8889 splay_tree_node n = splay_tree_lookup (gimplify_omp_ctxp->variables,
8890 (splay_tree_key) decl);
8891 omp_is_private (gimplify_omp_ctxp, decl,
8892 1 + (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
8894 if (n != NULL && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
8895 omp_notice_variable (gimplify_omp_ctxp, decl, true);
8896 else if (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) == 1)
8898 c = build_omp_clause (input_location, OMP_CLAUSE_LINEAR);
8899 OMP_CLAUSE_LINEAR_NO_COPYIN (c) = 1;
8900 unsigned int flags = GOVD_LINEAR | GOVD_EXPLICIT | GOVD_SEEN;
8902 && bitmap_bit_p (has_decl_expr, DECL_UID (decl)))
8903 || omp_no_lastprivate (gimplify_omp_ctxp))
8905 OMP_CLAUSE_LINEAR_NO_COPYOUT (c) = 1;
8906 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
8908 struct gimplify_omp_ctx *outer
8909 = gimplify_omp_ctxp->outer_context;
8910 if (outer && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
8912 if (outer->region_type == ORT_WORKSHARE
8913 && outer->combined_loop)
8915 n = splay_tree_lookup (outer->variables,
8916 (splay_tree_key)decl);
8917 if (n != NULL && (n->value & GOVD_LOCAL) != 0)
8919 OMP_CLAUSE_LINEAR_NO_COPYOUT (c) = 1;
8920 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
8924 struct gimplify_omp_ctx *octx = outer->outer_context;
8926 && octx->region_type == ORT_COMBINED_PARALLEL
8927 && octx->outer_context
8928 && (octx->outer_context->region_type
8930 && octx->outer_context->combined_loop)
8932 octx = octx->outer_context;
8933 n = splay_tree_lookup (octx->variables,
8934 (splay_tree_key)decl);
8935 if (n != NULL && (n->value & GOVD_LOCAL) != 0)
8937 OMP_CLAUSE_LINEAR_NO_COPYOUT (c) = 1;
8938 flags |= GOVD_LINEAR_LASTPRIVATE_NO_OUTER;
8945 OMP_CLAUSE_DECL (c) = decl;
8946 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (for_stmt);
8947 OMP_FOR_CLAUSES (for_stmt) = c;
8948 omp_add_variable (gimplify_omp_ctxp, decl, flags);
8949 if (outer && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c))
8951 if (outer->region_type == ORT_WORKSHARE
8952 && outer->combined_loop)
8954 if (outer->outer_context
8955 && (outer->outer_context->region_type
8956 == ORT_COMBINED_PARALLEL))
8957 outer = outer->outer_context;
8958 else if (omp_check_private (outer, decl, false))
8961 else if (((outer->region_type & ORT_TASK) != 0)
8962 && outer->combined_loop
8963 && !omp_check_private (gimplify_omp_ctxp,
8966 else if (outer->region_type != ORT_COMBINED_PARALLEL)
8968 omp_notice_variable (outer, decl, true);
8973 n = splay_tree_lookup (outer->variables,
8974 (splay_tree_key)decl);
8975 if (n == NULL || (n->value & GOVD_DATA_SHARE_CLASS) == 0)
8977 omp_add_variable (outer, decl,
8978 GOVD_LASTPRIVATE | GOVD_SEEN);
8979 if (outer->region_type == ORT_COMBINED_PARALLEL
8980 && outer->outer_context
8981 && (outer->outer_context->region_type
8983 && outer->outer_context->combined_loop)
8985 outer = outer->outer_context;
8986 n = splay_tree_lookup (outer->variables,
8987 (splay_tree_key)decl);
8988 if (omp_check_private (outer, decl, false))
8991 || ((n->value & GOVD_DATA_SHARE_CLASS)
8993 omp_add_variable (outer, decl,
8999 if (outer && outer->outer_context
9000 && (outer->outer_context->region_type
9001 == ORT_COMBINED_TEAMS))
9003 outer = outer->outer_context;
9004 n = splay_tree_lookup (outer->variables,
9005 (splay_tree_key)decl);
9007 || (n->value & GOVD_DATA_SHARE_CLASS) == 0)
9008 omp_add_variable (outer, decl,
9009 GOVD_SHARED | GOVD_SEEN);
9013 if (outer && outer->outer_context)
9014 omp_notice_variable (outer->outer_context, decl,
9024 || !bitmap_bit_p (has_decl_expr, DECL_UID (decl)))
9025 && !omp_no_lastprivate (gimplify_omp_ctxp);
9026 struct gimplify_omp_ctx *outer
9027 = gimplify_omp_ctxp->outer_context;
9028 if (outer && lastprivate)
9030 if (outer->region_type == ORT_WORKSHARE
9031 && outer->combined_loop)
9033 n = splay_tree_lookup (outer->variables,
9034 (splay_tree_key)decl);
9035 if (n != NULL && (n->value & GOVD_LOCAL) != 0)
9037 lastprivate = false;
9040 else if (outer->outer_context
9041 && (outer->outer_context->region_type
9042 == ORT_COMBINED_PARALLEL))
9043 outer = outer->outer_context;
9044 else if (omp_check_private (outer, decl, false))
9047 else if (((outer->region_type & ORT_TASK) != 0)
9048 && outer->combined_loop
9049 && !omp_check_private (gimplify_omp_ctxp,
9052 else if (outer->region_type != ORT_COMBINED_PARALLEL)
9054 omp_notice_variable (outer, decl, true);
9059 n = splay_tree_lookup (outer->variables,
9060 (splay_tree_key)decl);
9061 if (n == NULL || (n->value & GOVD_DATA_SHARE_CLASS) == 0)
9063 omp_add_variable (outer, decl,
9064 GOVD_LASTPRIVATE | GOVD_SEEN);
9065 if (outer->region_type == ORT_COMBINED_PARALLEL
9066 && outer->outer_context
9067 && (outer->outer_context->region_type
9069 && outer->outer_context->combined_loop)
9071 outer = outer->outer_context;
9072 n = splay_tree_lookup (outer->variables,
9073 (splay_tree_key)decl);
9074 if (omp_check_private (outer, decl, false))
9077 || ((n->value & GOVD_DATA_SHARE_CLASS)
9079 omp_add_variable (outer, decl,
9085 if (outer && outer->outer_context
9086 && (outer->outer_context->region_type
9087 == ORT_COMBINED_TEAMS))
9089 outer = outer->outer_context;
9090 n = splay_tree_lookup (outer->variables,
9091 (splay_tree_key)decl);
9093 || (n->value & GOVD_DATA_SHARE_CLASS) == 0)
9094 omp_add_variable (outer, decl,
9095 GOVD_SHARED | GOVD_SEEN);
9099 if (outer && outer->outer_context)
9100 omp_notice_variable (outer->outer_context, decl,
9106 c = build_omp_clause (input_location,
9107 lastprivate ? OMP_CLAUSE_LASTPRIVATE
9108 : OMP_CLAUSE_PRIVATE);
9109 OMP_CLAUSE_DECL (c) = decl;
9110 OMP_CLAUSE_CHAIN (c) = OMP_FOR_CLAUSES (for_stmt);
9111 OMP_FOR_CLAUSES (for_stmt) = c;
9112 omp_add_variable (gimplify_omp_ctxp, decl,
9113 (lastprivate ? GOVD_LASTPRIVATE : GOVD_PRIVATE)
9114 | GOVD_EXPLICIT | GOVD_SEEN);
9118 else if (omp_is_private (gimplify_omp_ctxp, decl, 0))
9119 omp_notice_variable (gimplify_omp_ctxp, decl, true);
9121 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
9123 /* If DECL is not a gimple register, create a temporary variable to act
9124 as an iteration counter. This is valid, since DECL cannot be
9125 modified in the body of the loop. Similarly for any iteration vars
9126 in simd with collapse > 1 where the iterator vars must be
9128 if (orig_for_stmt != for_stmt)
9130 else if (!is_gimple_reg (decl)
9132 && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) > 1))
9134 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
9135 /* Make sure omp_add_variable is not called on it prematurely.
9136 We call it ourselves a few lines later. */
9137 gimplify_omp_ctxp = NULL;
9138 var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
9139 gimplify_omp_ctxp = ctx;
9140 TREE_OPERAND (t, 0) = var;
9142 gimplify_seq_add_stmt (&for_body, gimple_build_assign (decl, var));
9145 && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) == 1)
9147 c2 = build_omp_clause (input_location, OMP_CLAUSE_LINEAR);
9148 OMP_CLAUSE_LINEAR_NO_COPYIN (c2) = 1;
9149 OMP_CLAUSE_LINEAR_NO_COPYOUT (c2) = 1;
9150 OMP_CLAUSE_DECL (c2) = var;
9151 OMP_CLAUSE_CHAIN (c2) = OMP_FOR_CLAUSES (for_stmt);
9152 OMP_FOR_CLAUSES (for_stmt) = c2;
9153 omp_add_variable (gimplify_omp_ctxp, var,
9154 GOVD_LINEAR | GOVD_EXPLICIT | GOVD_SEEN);
9162 omp_add_variable (gimplify_omp_ctxp, var,
9163 GOVD_PRIVATE | GOVD_SEEN);
9168 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
9169 is_gimple_val, fb_rvalue, false);
9170 ret = MIN (ret, tret);
9171 if (ret == GS_ERROR)
9174 /* Handle OMP_FOR_COND. */
9175 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
9176 gcc_assert (COMPARISON_CLASS_P (t));
9177 gcc_assert (TREE_OPERAND (t, 0) == decl);
9179 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
9180 is_gimple_val, fb_rvalue, false);
9181 ret = MIN (ret, tret);
9183 /* Handle OMP_FOR_INCR. */
9184 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
9185 switch (TREE_CODE (t))
9187 case PREINCREMENT_EXPR:
9188 case POSTINCREMENT_EXPR:
9190 tree decl = TREE_OPERAND (t, 0);
9191 /* c_omp_for_incr_canonicalize_ptr() should have been
9192 called to massage things appropriately. */
9193 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl)));
9195 if (orig_for_stmt != for_stmt)
9197 t = build_int_cst (TREE_TYPE (decl), 1);
9199 OMP_CLAUSE_LINEAR_STEP (c) = t;
9200 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
9201 t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
9202 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
9206 case PREDECREMENT_EXPR:
9207 case POSTDECREMENT_EXPR:
9208 /* c_omp_for_incr_canonicalize_ptr() should have been
9209 called to massage things appropriately. */
9210 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl)));
9211 if (orig_for_stmt != for_stmt)
9213 t = build_int_cst (TREE_TYPE (decl), -1);
9215 OMP_CLAUSE_LINEAR_STEP (c) = t;
9216 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
9217 t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
9218 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
9222 gcc_assert (TREE_OPERAND (t, 0) == decl);
9223 TREE_OPERAND (t, 0) = var;
9225 t = TREE_OPERAND (t, 1);
9226 switch (TREE_CODE (t))
9229 if (TREE_OPERAND (t, 1) == decl)
9231 TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
9232 TREE_OPERAND (t, 0) = var;
9238 case POINTER_PLUS_EXPR:
9239 gcc_assert (TREE_OPERAND (t, 0) == decl);
9240 TREE_OPERAND (t, 0) = var;
9246 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
9247 is_gimple_val, fb_rvalue, false);
9248 ret = MIN (ret, tret);
9251 tree step = TREE_OPERAND (t, 1);
9252 tree stept = TREE_TYPE (decl);
9253 if (POINTER_TYPE_P (stept))
9255 step = fold_convert (stept, step);
9256 if (TREE_CODE (t) == MINUS_EXPR)
9257 step = fold_build1 (NEGATE_EXPR, stept, step);
9258 OMP_CLAUSE_LINEAR_STEP (c) = step;
9259 if (step != TREE_OPERAND (t, 1))
9261 tret = gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c),
9262 &for_pre_body, NULL,
9263 is_gimple_val, fb_rvalue, false);
9264 ret = MIN (ret, tret);
9276 OMP_CLAUSE_LINEAR_STEP (c2) = OMP_CLAUSE_LINEAR_STEP (c);
9279 if ((var != decl || collapse > 1) && orig_for_stmt == for_stmt)
9281 for (c = OMP_FOR_CLAUSES (for_stmt); c ; c = OMP_CLAUSE_CHAIN (c))
9282 if (((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
9283 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c) == NULL)
9284 || (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
9285 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c)
9286 && OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c) == NULL))
9287 && OMP_CLAUSE_DECL (c) == decl)
9289 if (is_doacross && (collapse == 1 || i >= collapse))
9293 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
9294 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
9295 gcc_assert (TREE_OPERAND (t, 0) == var);
9296 t = TREE_OPERAND (t, 1);
9297 gcc_assert (TREE_CODE (t) == PLUS_EXPR
9298 || TREE_CODE (t) == MINUS_EXPR
9299 || TREE_CODE (t) == POINTER_PLUS_EXPR);
9300 gcc_assert (TREE_OPERAND (t, 0) == var);
9301 t = build2 (TREE_CODE (t), TREE_TYPE (decl),
9302 is_doacross ? var : decl,
9303 TREE_OPERAND (t, 1));
9306 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
9307 seq = &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c);
9309 seq = &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c);
9310 gimplify_assign (decl, t, seq);
9315 BITMAP_FREE (has_decl_expr);
9317 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
9319 push_gimplify_context ();
9320 if (TREE_CODE (OMP_FOR_BODY (orig_for_stmt)) != BIND_EXPR)
9322 OMP_FOR_BODY (orig_for_stmt)
9323 = build3 (BIND_EXPR, void_type_node, NULL,
9324 OMP_FOR_BODY (orig_for_stmt), NULL);
9325 TREE_SIDE_EFFECTS (OMP_FOR_BODY (orig_for_stmt)) = 1;
9329 gimple *g = gimplify_and_return_first (OMP_FOR_BODY (orig_for_stmt),
9332 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
9334 if (gimple_code (g) == GIMPLE_BIND)
9335 pop_gimplify_context (g);
9337 pop_gimplify_context (NULL);
9340 if (orig_for_stmt != for_stmt)
9341 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
9343 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
9344 decl = TREE_OPERAND (t, 0);
9345 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
9346 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
9347 gimplify_omp_ctxp = ctx->outer_context;
9348 var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
9349 gimplify_omp_ctxp = ctx;
9350 omp_add_variable (gimplify_omp_ctxp, var, GOVD_PRIVATE | GOVD_SEEN);
9351 TREE_OPERAND (t, 0) = var;
9352 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
9353 TREE_OPERAND (t, 1) = copy_node (TREE_OPERAND (t, 1));
9354 TREE_OPERAND (TREE_OPERAND (t, 1), 0) = var;
9357 gimplify_adjust_omp_clauses (pre_p, for_body,
9358 &OMP_FOR_CLAUSES (orig_for_stmt),
9359 TREE_CODE (orig_for_stmt));
9362 switch (TREE_CODE (orig_for_stmt))
9364 case OMP_FOR: kind = GF_OMP_FOR_KIND_FOR; break;
9365 case OMP_SIMD: kind = GF_OMP_FOR_KIND_SIMD; break;
9366 case CILK_SIMD: kind = GF_OMP_FOR_KIND_CILKSIMD; break;
9367 case CILK_FOR: kind = GF_OMP_FOR_KIND_CILKFOR; break;
9368 case OMP_DISTRIBUTE: kind = GF_OMP_FOR_KIND_DISTRIBUTE; break;
9369 case OMP_TASKLOOP: kind = GF_OMP_FOR_KIND_TASKLOOP; break;
9370 case OACC_LOOP: kind = GF_OMP_FOR_KIND_OACC_LOOP; break;
9374 gfor = gimple_build_omp_for (for_body, kind, OMP_FOR_CLAUSES (orig_for_stmt),
9375 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)),
9377 if (orig_for_stmt != for_stmt)
9378 gimple_omp_for_set_combined_p (gfor, true);
9379 if (gimplify_omp_ctxp
9380 && (gimplify_omp_ctxp->combined_loop
9381 || (gimplify_omp_ctxp->region_type == ORT_COMBINED_PARALLEL
9382 && gimplify_omp_ctxp->outer_context
9383 && gimplify_omp_ctxp->outer_context->combined_loop)))
9385 gimple_omp_for_set_combined_into_p (gfor, true);
9386 if (gimplify_omp_ctxp->combined_loop)
9387 gcc_assert (TREE_CODE (orig_for_stmt) == OMP_SIMD);
9389 gcc_assert (TREE_CODE (orig_for_stmt) == OMP_FOR);
9392 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
9394 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
9395 gimple_omp_for_set_index (gfor, i, TREE_OPERAND (t, 0));
9396 gimple_omp_for_set_initial (gfor, i, TREE_OPERAND (t, 1));
9397 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
9398 gimple_omp_for_set_cond (gfor, i, TREE_CODE (t));
9399 gimple_omp_for_set_final (gfor, i, TREE_OPERAND (t, 1));
9400 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
9401 gimple_omp_for_set_incr (gfor, i, TREE_OPERAND (t, 1));
9404 /* OMP_TASKLOOP is gimplified as two GIMPLE_OMP_FOR taskloop
9405 constructs with GIMPLE_OMP_TASK sandwiched in between them.
9406 The outer taskloop stands for computing the number of iterations,
9407 counts for collapsed loops and holding taskloop specific clauses.
9408 The task construct stands for the effect of data sharing on the
9409 explicit task it creates and the inner taskloop stands for expansion
9410 of the static loop inside of the explicit task construct. */
9411 if (TREE_CODE (orig_for_stmt) == OMP_TASKLOOP)
9413 tree *gfor_clauses_ptr = gimple_omp_for_clauses_ptr (gfor);
9414 tree task_clauses = NULL_TREE;
9415 tree c = *gfor_clauses_ptr;
9416 tree *gtask_clauses_ptr = &task_clauses;
9417 tree outer_for_clauses = NULL_TREE;
9418 tree *gforo_clauses_ptr = &outer_for_clauses;
9419 for (; c; c = OMP_CLAUSE_CHAIN (c))
9420 switch (OMP_CLAUSE_CODE (c))
9422 /* These clauses are allowed on task, move them there. */
9423 case OMP_CLAUSE_SHARED:
9424 case OMP_CLAUSE_FIRSTPRIVATE:
9425 case OMP_CLAUSE_DEFAULT:
9427 case OMP_CLAUSE_UNTIED:
9428 case OMP_CLAUSE_FINAL:
9429 case OMP_CLAUSE_MERGEABLE:
9430 case OMP_CLAUSE_PRIORITY:
9431 *gtask_clauses_ptr = c;
9432 gtask_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
9434 case OMP_CLAUSE_PRIVATE:
9435 if (OMP_CLAUSE_PRIVATE_TASKLOOP_IV (c))
9437 /* We want private on outer for and firstprivate
9440 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
9441 OMP_CLAUSE_FIRSTPRIVATE);
9442 OMP_CLAUSE_DECL (*gtask_clauses_ptr) = OMP_CLAUSE_DECL (c);
9443 lang_hooks.decls.omp_finish_clause (*gtask_clauses_ptr, NULL);
9444 gtask_clauses_ptr = &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr);
9445 *gforo_clauses_ptr = c;
9446 gforo_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
9450 *gtask_clauses_ptr = c;
9451 gtask_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
9454 /* These clauses go into outer taskloop clauses. */
9455 case OMP_CLAUSE_GRAINSIZE:
9456 case OMP_CLAUSE_NUM_TASKS:
9457 case OMP_CLAUSE_NOGROUP:
9458 *gforo_clauses_ptr = c;
9459 gforo_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
9461 /* Taskloop clause we duplicate on both taskloops. */
9462 case OMP_CLAUSE_COLLAPSE:
9463 *gfor_clauses_ptr = c;
9464 gfor_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
9465 *gforo_clauses_ptr = copy_node (c);
9466 gforo_clauses_ptr = &OMP_CLAUSE_CHAIN (*gforo_clauses_ptr);
9468 /* For lastprivate, keep the clause on inner taskloop, and add
9469 a shared clause on task. If the same decl is also firstprivate,
9470 add also firstprivate clause on the inner taskloop. */
9471 case OMP_CLAUSE_LASTPRIVATE:
9472 if (OMP_CLAUSE_LASTPRIVATE_TASKLOOP_IV (c))
9474 /* For taskloop C++ lastprivate IVs, we want:
9475 1) private on outer taskloop
9476 2) firstprivate and shared on task
9477 3) lastprivate on inner taskloop */
9479 = build_omp_clause (OMP_CLAUSE_LOCATION (c),
9480 OMP_CLAUSE_FIRSTPRIVATE);
9481 OMP_CLAUSE_DECL (*gtask_clauses_ptr) = OMP_CLAUSE_DECL (c);
9482 lang_hooks.decls.omp_finish_clause (*gtask_clauses_ptr, NULL);
9483 gtask_clauses_ptr = &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr);
9484 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c) = 1;
9485 *gforo_clauses_ptr = build_omp_clause (OMP_CLAUSE_LOCATION (c),
9486 OMP_CLAUSE_PRIVATE);
9487 OMP_CLAUSE_DECL (*gforo_clauses_ptr) = OMP_CLAUSE_DECL (c);
9488 OMP_CLAUSE_PRIVATE_TASKLOOP_IV (*gforo_clauses_ptr) = 1;
9489 TREE_TYPE (*gforo_clauses_ptr) = TREE_TYPE (c);
9490 gforo_clauses_ptr = &OMP_CLAUSE_CHAIN (*gforo_clauses_ptr);
9492 *gfor_clauses_ptr = c;
9493 gfor_clauses_ptr = &OMP_CLAUSE_CHAIN (c);
9495 = build_omp_clause (OMP_CLAUSE_LOCATION (c), OMP_CLAUSE_SHARED);
9496 OMP_CLAUSE_DECL (*gtask_clauses_ptr) = OMP_CLAUSE_DECL (c);
9497 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c))
9498 OMP_CLAUSE_SHARED_FIRSTPRIVATE (*gtask_clauses_ptr) = 1;
9500 = &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr);
9505 *gfor_clauses_ptr = NULL_TREE;
9506 *gtask_clauses_ptr = NULL_TREE;
9507 *gforo_clauses_ptr = NULL_TREE;
9508 g = gimple_build_bind (NULL_TREE, gfor, NULL_TREE);
9509 g = gimple_build_omp_task (g, task_clauses, NULL_TREE, NULL_TREE,
9510 NULL_TREE, NULL_TREE, NULL_TREE);
9511 gimple_omp_task_set_taskloop_p (g, true);
9512 g = gimple_build_bind (NULL_TREE, g, NULL_TREE);
9514 = gimple_build_omp_for (g, GF_OMP_FOR_KIND_TASKLOOP, outer_for_clauses,
9515 gimple_omp_for_collapse (gfor),
9516 gimple_omp_for_pre_body (gfor));
9517 gimple_omp_for_set_pre_body (gfor, NULL);
9518 gimple_omp_for_set_combined_p (gforo, true);
9519 gimple_omp_for_set_combined_into_p (gfor, true);
9520 for (i = 0; i < (int) gimple_omp_for_collapse (gfor); i++)
9522 t = unshare_expr (gimple_omp_for_index (gfor, i));
9523 gimple_omp_for_set_index (gforo, i, t);
9524 t = unshare_expr (gimple_omp_for_initial (gfor, i));
9525 gimple_omp_for_set_initial (gforo, i, t);
9526 gimple_omp_for_set_cond (gforo, i,
9527 gimple_omp_for_cond (gfor, i));
9528 t = unshare_expr (gimple_omp_for_final (gfor, i));
9529 gimple_omp_for_set_final (gforo, i, t);
9530 t = unshare_expr (gimple_omp_for_incr (gfor, i));
9531 gimple_omp_for_set_incr (gforo, i, t);
9533 gimplify_seq_add_stmt (pre_p, gforo);
9536 gimplify_seq_add_stmt (pre_p, gfor);
9537 if (ret != GS_ALL_DONE)
9539 *expr_p = NULL_TREE;
9543 /* Helper function of optimize_target_teams, find OMP_TEAMS inside
9544 of OMP_TARGET's body. */
9547 find_omp_teams (tree *tp, int *walk_subtrees, void *)
9550 switch (TREE_CODE (*tp))
9555 case STATEMENT_LIST:
9564 /* Helper function of optimize_target_teams, determine if the expression
9565 can be computed safely before the target construct on the host. */
9568 computable_teams_clause (tree *tp, int *walk_subtrees, void *)
9577 switch (TREE_CODE (*tp))
9583 if (error_operand_p (*tp)
9584 || !INTEGRAL_TYPE_P (TREE_TYPE (*tp))
9585 || DECL_HAS_VALUE_EXPR_P (*tp)
9586 || DECL_THREAD_LOCAL_P (*tp)
9587 || TREE_SIDE_EFFECTS (*tp)
9588 || TREE_THIS_VOLATILE (*tp))
9590 if (is_global_var (*tp)
9591 && (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (*tp))
9592 || lookup_attribute ("omp declare target link",
9593 DECL_ATTRIBUTES (*tp))))
9595 n = splay_tree_lookup (gimplify_omp_ctxp->variables,
9596 (splay_tree_key) *tp);
9599 if (gimplify_omp_ctxp->target_map_scalars_firstprivate)
9603 else if (n->value & GOVD_LOCAL)
9605 else if (n->value & GOVD_FIRSTPRIVATE)
9607 else if ((n->value & (GOVD_MAP | GOVD_MAP_ALWAYS_TO))
9608 == (GOVD_MAP | GOVD_MAP_ALWAYS_TO))
9612 if (!INTEGRAL_TYPE_P (TREE_TYPE (*tp)))
9616 if (TARGET_EXPR_INITIAL (*tp)
9617 || TREE_CODE (TARGET_EXPR_SLOT (*tp)) != VAR_DECL)
9619 return computable_teams_clause (&TARGET_EXPR_SLOT (*tp),
9620 walk_subtrees, NULL);
9621 /* Allow some reasonable subset of integral arithmetics. */
9625 case TRUNC_DIV_EXPR:
9627 case FLOOR_DIV_EXPR:
9628 case ROUND_DIV_EXPR:
9629 case TRUNC_MOD_EXPR:
9631 case FLOOR_MOD_EXPR:
9632 case ROUND_MOD_EXPR:
9634 case EXACT_DIV_EXPR:
9645 case NON_LVALUE_EXPR:
9647 if (!INTEGRAL_TYPE_P (TREE_TYPE (*tp)))
9650 /* And disallow anything else, except for comparisons. */
9652 if (COMPARISON_CLASS_P (*tp))
9658 /* Try to determine if the num_teams and/or thread_limit expressions
9659 can have their values determined already before entering the
9661 INTEGER_CSTs trivially are,
9662 integral decls that are firstprivate (explicitly or implicitly)
9663 or explicitly map(always, to:) or map(always, tofrom:) on the target
9664 region too, and expressions involving simple arithmetics on those
9665 too, function calls are not ok, dereferencing something neither etc.
9666 Add NUM_TEAMS and THREAD_LIMIT clauses to the OMP_CLAUSES of
9667 EXPR based on what we find:
9668 0 stands for clause not specified at all, use implementation default
9669 -1 stands for value that can't be determined easily before entering
9670 the target construct.
9671 If teams construct is not present at all, use 1 for num_teams
9672 and 0 for thread_limit (only one team is involved, and the thread
9673 limit is implementation defined. */
9676 optimize_target_teams (tree target, gimple_seq *pre_p)
9678 tree body = OMP_BODY (target);
9679 tree teams = walk_tree (&body, find_omp_teams, NULL, NULL);
9680 tree num_teams = integer_zero_node;
9681 tree thread_limit = integer_zero_node;
9682 location_t num_teams_loc = EXPR_LOCATION (target);
9683 location_t thread_limit_loc = EXPR_LOCATION (target);
9685 struct gimplify_omp_ctx *target_ctx = gimplify_omp_ctxp;
9687 if (teams == NULL_TREE)
9688 num_teams = integer_one_node;
9690 for (c = OMP_TEAMS_CLAUSES (teams); c; c = OMP_CLAUSE_CHAIN (c))
9692 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_NUM_TEAMS)
9695 num_teams_loc = OMP_CLAUSE_LOCATION (c);
9697 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_THREAD_LIMIT)
9700 thread_limit_loc = OMP_CLAUSE_LOCATION (c);
9704 expr = OMP_CLAUSE_OPERAND (c, 0);
9705 if (TREE_CODE (expr) == INTEGER_CST)
9710 if (walk_tree (&expr, computable_teams_clause, NULL, NULL))
9712 *p = integer_minus_one_node;
9716 gimplify_omp_ctxp = gimplify_omp_ctxp->outer_context;
9717 if (gimplify_expr (p, pre_p, NULL, is_gimple_val, fb_rvalue, false)
9720 gimplify_omp_ctxp = target_ctx;
9721 *p = integer_minus_one_node;
9724 gimplify_omp_ctxp = target_ctx;
9725 if (!DECL_P (expr) && TREE_CODE (expr) != TARGET_EXPR)
9726 OMP_CLAUSE_OPERAND (c, 0) = *p;
9728 c = build_omp_clause (thread_limit_loc, OMP_CLAUSE_THREAD_LIMIT);
9729 OMP_CLAUSE_THREAD_LIMIT_EXPR (c) = thread_limit;
9730 OMP_CLAUSE_CHAIN (c) = OMP_TARGET_CLAUSES (target);
9731 OMP_TARGET_CLAUSES (target) = c;
9732 c = build_omp_clause (num_teams_loc, OMP_CLAUSE_NUM_TEAMS);
9733 OMP_CLAUSE_NUM_TEAMS_EXPR (c) = num_teams;
9734 OMP_CLAUSE_CHAIN (c) = OMP_TARGET_CLAUSES (target);
9735 OMP_TARGET_CLAUSES (target) = c;
9738 /* Gimplify the gross structure of several OMP constructs. */
9741 gimplify_omp_workshare (tree *expr_p, gimple_seq *pre_p)
9743 tree expr = *expr_p;
9745 gimple_seq body = NULL;
9746 enum omp_region_type ort;
9748 switch (TREE_CODE (expr))
9752 ort = ORT_WORKSHARE;
9755 ort = OMP_TARGET_COMBINED (expr) ? ORT_COMBINED_TARGET : ORT_TARGET;
9758 ort = ORT_ACC_KERNELS;
9761 ort = ORT_ACC_PARALLEL;
9766 case OMP_TARGET_DATA:
9767 ort = ORT_TARGET_DATA;
9770 ort = OMP_TEAMS_COMBINED (expr) ? ORT_COMBINED_TEAMS : ORT_TEAMS;
9772 case OACC_HOST_DATA:
9773 ort = ORT_ACC_HOST_DATA;
9778 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr), pre_p, ort,
9780 if (TREE_CODE (expr) == OMP_TARGET)
9781 optimize_target_teams (expr, pre_p);
9782 if ((ort & (ORT_TARGET | ORT_TARGET_DATA)) != 0)
9784 push_gimplify_context ();
9785 gimple *g = gimplify_and_return_first (OMP_BODY (expr), &body);
9786 if (gimple_code (g) == GIMPLE_BIND)
9787 pop_gimplify_context (g);
9789 pop_gimplify_context (NULL);
9790 if ((ort & ORT_TARGET_DATA) != 0)
9792 enum built_in_function end_ix;
9793 switch (TREE_CODE (expr))
9796 case OACC_HOST_DATA:
9797 end_ix = BUILT_IN_GOACC_DATA_END;
9799 case OMP_TARGET_DATA:
9800 end_ix = BUILT_IN_GOMP_TARGET_END_DATA;
9805 tree fn = builtin_decl_explicit (end_ix);
9806 g = gimple_build_call (fn, 0);
9807 gimple_seq cleanup = NULL;
9808 gimple_seq_add_stmt (&cleanup, g);
9809 g = gimple_build_try (body, cleanup, GIMPLE_TRY_FINALLY);
9811 gimple_seq_add_stmt (&body, g);
9815 gimplify_and_add (OMP_BODY (expr), &body);
9816 gimplify_adjust_omp_clauses (pre_p, body, &OMP_CLAUSES (expr),
9819 switch (TREE_CODE (expr))
9822 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_OACC_DATA,
9823 OMP_CLAUSES (expr));
9826 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_OACC_KERNELS,
9827 OMP_CLAUSES (expr));
9829 case OACC_HOST_DATA:
9830 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_OACC_HOST_DATA,
9831 OMP_CLAUSES (expr));
9834 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_OACC_PARALLEL,
9835 OMP_CLAUSES (expr));
9838 stmt = gimple_build_omp_sections (body, OMP_CLAUSES (expr));
9841 stmt = gimple_build_omp_single (body, OMP_CLAUSES (expr));
9844 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_REGION,
9845 OMP_CLAUSES (expr));
9847 case OMP_TARGET_DATA:
9848 stmt = gimple_build_omp_target (body, GF_OMP_TARGET_KIND_DATA,
9849 OMP_CLAUSES (expr));
9852 stmt = gimple_build_omp_teams (body, OMP_CLAUSES (expr));
9858 gimplify_seq_add_stmt (pre_p, stmt);
9859 *expr_p = NULL_TREE;
9862 /* Gimplify the gross structure of OpenACC enter/exit data, update, and OpenMP
9863 target update constructs. */
9866 gimplify_omp_target_update (tree *expr_p, gimple_seq *pre_p)
9868 tree expr = *expr_p;
9871 enum omp_region_type ort = ORT_WORKSHARE;
9873 switch (TREE_CODE (expr))
9875 case OACC_ENTER_DATA:
9876 case OACC_EXIT_DATA:
9877 kind = GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA;
9881 kind = GF_OMP_TARGET_KIND_OACC_UPDATE;
9884 case OMP_TARGET_UPDATE:
9885 kind = GF_OMP_TARGET_KIND_UPDATE;
9887 case OMP_TARGET_ENTER_DATA:
9888 kind = GF_OMP_TARGET_KIND_ENTER_DATA;
9890 case OMP_TARGET_EXIT_DATA:
9891 kind = GF_OMP_TARGET_KIND_EXIT_DATA;
9896 gimplify_scan_omp_clauses (&OMP_STANDALONE_CLAUSES (expr), pre_p,
9897 ort, TREE_CODE (expr));
9898 gimplify_adjust_omp_clauses (pre_p, NULL, &OMP_STANDALONE_CLAUSES (expr),
9900 stmt = gimple_build_omp_target (NULL, kind, OMP_STANDALONE_CLAUSES (expr));
9902 gimplify_seq_add_stmt (pre_p, stmt);
9903 *expr_p = NULL_TREE;
9906 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
9907 stabilized the lhs of the atomic operation as *ADDR. Return true if
9908 EXPR is this stabilized form. */
9911 goa_lhs_expr_p (tree expr, tree addr)
9913 /* Also include casts to other type variants. The C front end is fond
9914 of adding these for e.g. volatile variables. This is like
9915 STRIP_TYPE_NOPS but includes the main variant lookup. */
9916 STRIP_USELESS_TYPE_CONVERSION (expr);
9918 if (TREE_CODE (expr) == INDIRECT_REF)
9920 expr = TREE_OPERAND (expr, 0);
9922 && (CONVERT_EXPR_P (expr)
9923 || TREE_CODE (expr) == NON_LVALUE_EXPR)
9924 && TREE_CODE (expr) == TREE_CODE (addr)
9925 && types_compatible_p (TREE_TYPE (expr), TREE_TYPE (addr)))
9927 expr = TREE_OPERAND (expr, 0);
9928 addr = TREE_OPERAND (addr, 0);
9932 return (TREE_CODE (addr) == ADDR_EXPR
9933 && TREE_CODE (expr) == ADDR_EXPR
9934 && TREE_OPERAND (addr, 0) == TREE_OPERAND (expr, 0));
9936 if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0))
9941 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
9942 expression does not involve the lhs, evaluate it into a temporary.
9943 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
9944 or -1 if an error was encountered. */
9947 goa_stabilize_expr (tree *expr_p, gimple_seq *pre_p, tree lhs_addr,
9950 tree expr = *expr_p;
9953 if (goa_lhs_expr_p (expr, lhs_addr))
9958 if (is_gimple_val (expr))
9962 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
9965 case tcc_comparison:
9966 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p, lhs_addr,
9970 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p, lhs_addr,
9973 case tcc_expression:
9974 switch (TREE_CODE (expr))
9976 case TRUTH_ANDIF_EXPR:
9977 case TRUTH_ORIF_EXPR:
9978 case TRUTH_AND_EXPR:
9980 case TRUTH_XOR_EXPR:
9981 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
9984 case TRUTH_NOT_EXPR:
9985 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
9989 /* Break out any preevaluations from cp_build_modify_expr. */
9990 for (; TREE_CODE (expr) == COMPOUND_EXPR;
9991 expr = TREE_OPERAND (expr, 1))
9992 gimplify_stmt (&TREE_OPERAND (expr, 0), pre_p);
9994 return goa_stabilize_expr (expr_p, pre_p, lhs_addr, lhs_var);
10005 enum gimplify_status gs;
10006 gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue);
10007 if (gs != GS_ALL_DONE)
10014 /* Gimplify an OMP_ATOMIC statement. */
10016 static enum gimplify_status
10017 gimplify_omp_atomic (tree *expr_p, gimple_seq *pre_p)
10019 tree addr = TREE_OPERAND (*expr_p, 0);
10020 tree rhs = TREE_CODE (*expr_p) == OMP_ATOMIC_READ
10021 ? NULL : TREE_OPERAND (*expr_p, 1);
10022 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
10024 gomp_atomic_load *loadstmt;
10025 gomp_atomic_store *storestmt;
10027 tmp_load = create_tmp_reg (type);
10028 if (rhs && goa_stabilize_expr (&rhs, pre_p, addr, tmp_load) < 0)
10031 if (gimplify_expr (&addr, pre_p, NULL, is_gimple_val, fb_rvalue)
10035 loadstmt = gimple_build_omp_atomic_load (tmp_load, addr);
10036 gimplify_seq_add_stmt (pre_p, loadstmt);
10037 if (rhs && gimplify_expr (&rhs, pre_p, NULL, is_gimple_val, fb_rvalue)
10041 if (TREE_CODE (*expr_p) == OMP_ATOMIC_READ)
10043 storestmt = gimple_build_omp_atomic_store (rhs);
10044 gimplify_seq_add_stmt (pre_p, storestmt);
10045 if (OMP_ATOMIC_SEQ_CST (*expr_p))
10047 gimple_omp_atomic_set_seq_cst (loadstmt);
10048 gimple_omp_atomic_set_seq_cst (storestmt);
10050 switch (TREE_CODE (*expr_p))
10052 case OMP_ATOMIC_READ:
10053 case OMP_ATOMIC_CAPTURE_OLD:
10054 *expr_p = tmp_load;
10055 gimple_omp_atomic_set_need_value (loadstmt);
10057 case OMP_ATOMIC_CAPTURE_NEW:
10059 gimple_omp_atomic_set_need_value (storestmt);
10066 return GS_ALL_DONE;
10069 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
10070 body, and adding some EH bits. */
10072 static enum gimplify_status
10073 gimplify_transaction (tree *expr_p, gimple_seq *pre_p)
10075 tree expr = *expr_p, temp, tbody = TRANSACTION_EXPR_BODY (expr);
10077 gtransaction *trans_stmt;
10078 gimple_seq body = NULL;
10081 /* Wrap the transaction body in a BIND_EXPR so we have a context
10082 where to put decls for OMP. */
10083 if (TREE_CODE (tbody) != BIND_EXPR)
10085 tree bind = build3 (BIND_EXPR, void_type_node, NULL, tbody, NULL);
10086 TREE_SIDE_EFFECTS (bind) = 1;
10087 SET_EXPR_LOCATION (bind, EXPR_LOCATION (tbody));
10088 TRANSACTION_EXPR_BODY (expr) = bind;
10091 push_gimplify_context ();
10092 temp = voidify_wrapper_expr (*expr_p, NULL);
10094 body_stmt = gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr), &body);
10095 pop_gimplify_context (body_stmt);
10097 trans_stmt = gimple_build_transaction (body);
10098 if (TRANSACTION_EXPR_OUTER (expr))
10099 subcode = GTMA_IS_OUTER;
10100 else if (TRANSACTION_EXPR_RELAXED (expr))
10101 subcode = GTMA_IS_RELAXED;
10102 gimple_transaction_set_subcode (trans_stmt, subcode);
10104 gimplify_seq_add_stmt (pre_p, trans_stmt);
10112 *expr_p = NULL_TREE;
10113 return GS_ALL_DONE;
10116 /* Gimplify an OMP_ORDERED construct. EXPR is the tree version. BODY
10117 is the OMP_BODY of the original EXPR (which has already been
10118 gimplified so it's not present in the EXPR).
10120 Return the gimplified GIMPLE_OMP_ORDERED tuple. */
10123 gimplify_omp_ordered (tree expr, gimple_seq body)
10128 tree source_c = NULL_TREE;
10129 tree sink_c = NULL_TREE;
10131 if (gimplify_omp_ctxp)
10133 for (c = OMP_ORDERED_CLAUSES (expr); c; c = OMP_CLAUSE_CHAIN (c))
10134 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
10135 && gimplify_omp_ctxp->loop_iter_var.is_empty ()
10136 && (OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SINK
10137 || OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SOURCE))
10139 error_at (OMP_CLAUSE_LOCATION (c),
10140 "%<ordered%> construct with %<depend%> clause must be "
10141 "closely nested inside a loop with %<ordered%> clause "
10142 "with a parameter");
10145 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
10146 && OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SINK)
10149 for (decls = OMP_CLAUSE_DECL (c), i = 0;
10150 decls && TREE_CODE (decls) == TREE_LIST;
10151 decls = TREE_CHAIN (decls), ++i)
10152 if (i >= gimplify_omp_ctxp->loop_iter_var.length () / 2)
10154 else if (TREE_VALUE (decls)
10155 != gimplify_omp_ctxp->loop_iter_var[2 * i])
10157 error_at (OMP_CLAUSE_LOCATION (c),
10158 "variable %qE is not an iteration "
10159 "of outermost loop %d, expected %qE",
10160 TREE_VALUE (decls), i + 1,
10161 gimplify_omp_ctxp->loop_iter_var[2 * i]);
10167 = gimplify_omp_ctxp->loop_iter_var[2 * i + 1];
10168 if (!fail && i != gimplify_omp_ctxp->loop_iter_var.length () / 2)
10170 error_at (OMP_CLAUSE_LOCATION (c),
10171 "number of variables in %<depend(sink)%> "
10172 "clause does not match number of "
10173 "iteration variables");
10178 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
10179 && OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SOURCE)
10183 error_at (OMP_CLAUSE_LOCATION (c),
10184 "more than one %<depend(source)%> clause on an "
10185 "%<ordered%> construct");
10192 if (source_c && sink_c)
10194 error_at (OMP_CLAUSE_LOCATION (source_c),
10195 "%<depend(source)%> clause specified together with "
10196 "%<depend(sink:)%> clauses on the same construct");
10201 return gimple_build_nop ();
10202 return gimple_build_omp_ordered (body, OMP_ORDERED_CLAUSES (expr));
10205 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
10206 expression produces a value to be used as an operand inside a GIMPLE
10207 statement, the value will be stored back in *EXPR_P. This value will
10208 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
10209 an SSA_NAME. The corresponding sequence of GIMPLE statements is
10210 emitted in PRE_P and POST_P.
10212 Additionally, this process may overwrite parts of the input
10213 expression during gimplification. Ideally, it should be
10214 possible to do non-destructive gimplification.
10216 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
10217 the expression needs to evaluate to a value to be used as
10218 an operand in a GIMPLE statement, this value will be stored in
10219 *EXPR_P on exit. This happens when the caller specifies one
10220 of fb_lvalue or fb_rvalue fallback flags.
10222 PRE_P will contain the sequence of GIMPLE statements corresponding
10223 to the evaluation of EXPR and all the side-effects that must
10224 be executed before the main expression. On exit, the last
10225 statement of PRE_P is the core statement being gimplified. For
10226 instance, when gimplifying 'if (++a)' the last statement in
10227 PRE_P will be 'if (t.1)' where t.1 is the result of
10228 pre-incrementing 'a'.
10230 POST_P will contain the sequence of GIMPLE statements corresponding
10231 to the evaluation of all the side-effects that must be executed
10232 after the main expression. If this is NULL, the post
10233 side-effects are stored at the end of PRE_P.
10235 The reason why the output is split in two is to handle post
10236 side-effects explicitly. In some cases, an expression may have
10237 inner and outer post side-effects which need to be emitted in
10238 an order different from the one given by the recursive
10239 traversal. For instance, for the expression (*p--)++ the post
10240 side-effects of '--' must actually occur *after* the post
10241 side-effects of '++'. However, gimplification will first visit
10242 the inner expression, so if a separate POST sequence was not
10243 used, the resulting sequence would be:
10250 However, the post-decrement operation in line #2 must not be
10251 evaluated until after the store to *p at line #4, so the
10252 correct sequence should be:
10259 So, by specifying a separate post queue, it is possible
10260 to emit the post side-effects in the correct order.
10261 If POST_P is NULL, an internal queue will be used. Before
10262 returning to the caller, the sequence POST_P is appended to
10263 the main output sequence PRE_P.
10265 GIMPLE_TEST_F points to a function that takes a tree T and
10266 returns nonzero if T is in the GIMPLE form requested by the
10267 caller. The GIMPLE predicates are in gimple.c.
10269 FALLBACK tells the function what sort of a temporary we want if
10270 gimplification cannot produce an expression that complies with
10273 fb_none means that no temporary should be generated
10274 fb_rvalue means that an rvalue is OK to generate
10275 fb_lvalue means that an lvalue is OK to generate
10276 fb_either means that either is OK, but an lvalue is preferable.
10277 fb_mayfail means that gimplification may fail (in which case
10278 GS_ERROR will be returned)
10280 The return value is either GS_ERROR or GS_ALL_DONE, since this
10281 function iterates until EXPR is completely gimplified or an error
10284 enum gimplify_status
10285 gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
10286 bool (*gimple_test_f) (tree), fallback_t fallback)
10289 gimple_seq internal_pre = NULL;
10290 gimple_seq internal_post = NULL;
10293 location_t saved_location;
10294 enum gimplify_status ret;
10295 gimple_stmt_iterator pre_last_gsi, post_last_gsi;
10297 save_expr = *expr_p;
10298 if (save_expr == NULL_TREE)
10299 return GS_ALL_DONE;
10301 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
10302 is_statement = gimple_test_f == is_gimple_stmt;
10304 gcc_assert (pre_p);
10306 /* Consistency checks. */
10307 if (gimple_test_f == is_gimple_reg)
10308 gcc_assert (fallback & (fb_rvalue | fb_lvalue));
10309 else if (gimple_test_f == is_gimple_val
10310 || gimple_test_f == is_gimple_call_addr
10311 || gimple_test_f == is_gimple_condexpr
10312 || gimple_test_f == is_gimple_mem_rhs
10313 || gimple_test_f == is_gimple_mem_rhs_or_call
10314 || gimple_test_f == is_gimple_reg_rhs
10315 || gimple_test_f == is_gimple_reg_rhs_or_call
10316 || gimple_test_f == is_gimple_asm_val
10317 || gimple_test_f == is_gimple_mem_ref_addr)
10318 gcc_assert (fallback & fb_rvalue);
10319 else if (gimple_test_f == is_gimple_min_lval
10320 || gimple_test_f == is_gimple_lvalue)
10321 gcc_assert (fallback & fb_lvalue);
10322 else if (gimple_test_f == is_gimple_addressable)
10323 gcc_assert (fallback & fb_either);
10324 else if (gimple_test_f == is_gimple_stmt)
10325 gcc_assert (fallback == fb_none);
10328 /* We should have recognized the GIMPLE_TEST_F predicate to
10329 know what kind of fallback to use in case a temporary is
10330 needed to hold the value or address of *EXPR_P. */
10331 gcc_unreachable ();
10334 /* We used to check the predicate here and return immediately if it
10335 succeeds. This is wrong; the design is for gimplification to be
10336 idempotent, and for the predicates to only test for valid forms, not
10337 whether they are fully simplified. */
10339 pre_p = &internal_pre;
10341 if (post_p == NULL)
10342 post_p = &internal_post;
10344 /* Remember the last statements added to PRE_P and POST_P. Every
10345 new statement added by the gimplification helpers needs to be
10346 annotated with location information. To centralize the
10347 responsibility, we remember the last statement that had been
10348 added to both queues before gimplifying *EXPR_P. If
10349 gimplification produces new statements in PRE_P and POST_P, those
10350 statements will be annotated with the same location information
10352 pre_last_gsi = gsi_last (*pre_p);
10353 post_last_gsi = gsi_last (*post_p);
10355 saved_location = input_location;
10356 if (save_expr != error_mark_node
10357 && EXPR_HAS_LOCATION (*expr_p))
10358 input_location = EXPR_LOCATION (*expr_p);
10360 /* Loop over the specific gimplifiers until the toplevel node
10361 remains the same. */
10364 /* Strip away as many useless type conversions as possible
10365 at the toplevel. */
10366 STRIP_USELESS_TYPE_CONVERSION (*expr_p);
10368 /* Remember the expr. */
10369 save_expr = *expr_p;
10371 /* Die, die, die, my darling. */
10372 if (save_expr == error_mark_node
10373 || (TREE_TYPE (save_expr)
10374 && TREE_TYPE (save_expr) == error_mark_node))
10380 /* Do any language-specific gimplification. */
10381 ret = ((enum gimplify_status)
10382 lang_hooks.gimplify_expr (expr_p, pre_p, post_p));
10385 if (*expr_p == NULL_TREE)
10387 if (*expr_p != save_expr)
10390 else if (ret != GS_UNHANDLED)
10393 /* Make sure that all the cases set 'ret' appropriately. */
10394 ret = GS_UNHANDLED;
10395 switch (TREE_CODE (*expr_p))
10397 /* First deal with the special cases. */
10399 case POSTINCREMENT_EXPR:
10400 case POSTDECREMENT_EXPR:
10401 case PREINCREMENT_EXPR:
10402 case PREDECREMENT_EXPR:
10403 ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
10404 fallback != fb_none,
10405 TREE_TYPE (*expr_p));
10408 case VIEW_CONVERT_EXPR:
10409 if (is_gimple_reg_type (TREE_TYPE (*expr_p))
10410 && is_gimple_reg_type (TREE_TYPE (TREE_OPERAND (*expr_p, 0))))
10412 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
10413 post_p, is_gimple_val, fb_rvalue);
10414 recalculate_side_effects (*expr_p);
10420 case ARRAY_RANGE_REF:
10421 case REALPART_EXPR:
10422 case IMAGPART_EXPR:
10423 case COMPONENT_REF:
10424 ret = gimplify_compound_lval (expr_p, pre_p, post_p,
10425 fallback ? fallback : fb_rvalue);
10429 ret = gimplify_cond_expr (expr_p, pre_p, fallback);
10431 /* C99 code may assign to an array in a structure value of a
10432 conditional expression, and this has undefined behavior
10433 only on execution, so create a temporary if an lvalue is
10435 if (fallback == fb_lvalue)
10437 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p, false);
10438 mark_addressable (*expr_p);
10444 ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
10446 /* C99 code may assign to an array in a structure returned
10447 from a function, and this has undefined behavior only on
10448 execution, so create a temporary if an lvalue is
10450 if (fallback == fb_lvalue)
10452 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p, false);
10453 mark_addressable (*expr_p);
10459 gcc_unreachable ();
10461 case COMPOUND_EXPR:
10462 ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
10465 case COMPOUND_LITERAL_EXPR:
10466 ret = gimplify_compound_literal_expr (expr_p, pre_p,
10467 gimple_test_f, fallback);
10472 ret = gimplify_modify_expr (expr_p, pre_p, post_p,
10473 fallback != fb_none);
10476 case TRUTH_ANDIF_EXPR:
10477 case TRUTH_ORIF_EXPR:
10479 /* Preserve the original type of the expression and the
10480 source location of the outer expression. */
10481 tree org_type = TREE_TYPE (*expr_p);
10482 *expr_p = gimple_boolify (*expr_p);
10483 *expr_p = build3_loc (input_location, COND_EXPR,
10487 org_type, boolean_true_node),
10490 org_type, boolean_false_node));
10495 case TRUTH_NOT_EXPR:
10497 tree type = TREE_TYPE (*expr_p);
10498 /* The parsers are careful to generate TRUTH_NOT_EXPR
10499 only with operands that are always zero or one.
10500 We do not fold here but handle the only interesting case
10501 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
10502 *expr_p = gimple_boolify (*expr_p);
10503 if (TYPE_PRECISION (TREE_TYPE (*expr_p)) == 1)
10504 *expr_p = build1_loc (input_location, BIT_NOT_EXPR,
10505 TREE_TYPE (*expr_p),
10506 TREE_OPERAND (*expr_p, 0));
10508 *expr_p = build2_loc (input_location, BIT_XOR_EXPR,
10509 TREE_TYPE (*expr_p),
10510 TREE_OPERAND (*expr_p, 0),
10511 build_int_cst (TREE_TYPE (*expr_p), 1));
10512 if (!useless_type_conversion_p (type, TREE_TYPE (*expr_p)))
10513 *expr_p = fold_convert_loc (input_location, type, *expr_p);
10519 ret = gimplify_addr_expr (expr_p, pre_p, post_p);
10522 case ANNOTATE_EXPR:
10524 tree cond = TREE_OPERAND (*expr_p, 0);
10525 tree kind = TREE_OPERAND (*expr_p, 1);
10526 tree type = TREE_TYPE (cond);
10527 if (!INTEGRAL_TYPE_P (type))
10533 tree tmp = create_tmp_var (type);
10534 gimplify_arg (&cond, pre_p, EXPR_LOCATION (*expr_p));
10536 = gimple_build_call_internal (IFN_ANNOTATE, 2, cond, kind);
10537 gimple_call_set_lhs (call, tmp);
10538 gimplify_seq_add_stmt (pre_p, call);
10545 ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
10549 if (IS_EMPTY_STMT (*expr_p))
10555 if (VOID_TYPE_P (TREE_TYPE (*expr_p))
10556 || fallback == fb_none)
10558 /* Just strip a conversion to void (or in void context) and
10560 *expr_p = TREE_OPERAND (*expr_p, 0);
10565 ret = gimplify_conversion (expr_p);
10566 if (ret == GS_ERROR)
10568 if (*expr_p != save_expr)
10572 case FIX_TRUNC_EXPR:
10573 /* unary_expr: ... | '(' cast ')' val | ... */
10574 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
10575 is_gimple_val, fb_rvalue);
10576 recalculate_side_effects (*expr_p);
10581 bool volatilep = TREE_THIS_VOLATILE (*expr_p);
10582 bool notrap = TREE_THIS_NOTRAP (*expr_p);
10583 tree saved_ptr_type = TREE_TYPE (TREE_OPERAND (*expr_p, 0));
10585 *expr_p = fold_indirect_ref_loc (input_location, *expr_p);
10586 if (*expr_p != save_expr)
10592 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
10593 is_gimple_reg, fb_rvalue);
10594 if (ret == GS_ERROR)
10597 recalculate_side_effects (*expr_p);
10598 *expr_p = fold_build2_loc (input_location, MEM_REF,
10599 TREE_TYPE (*expr_p),
10600 TREE_OPERAND (*expr_p, 0),
10601 build_int_cst (saved_ptr_type, 0));
10602 TREE_THIS_VOLATILE (*expr_p) = volatilep;
10603 TREE_THIS_NOTRAP (*expr_p) = notrap;
10608 /* We arrive here through the various re-gimplifcation paths. */
10610 /* First try re-folding the whole thing. */
10611 tmp = fold_binary (MEM_REF, TREE_TYPE (*expr_p),
10612 TREE_OPERAND (*expr_p, 0),
10613 TREE_OPERAND (*expr_p, 1));
10616 REF_REVERSE_STORAGE_ORDER (tmp)
10617 = REF_REVERSE_STORAGE_ORDER (*expr_p);
10619 recalculate_side_effects (*expr_p);
10623 /* Avoid re-gimplifying the address operand if it is already
10624 in suitable form. Re-gimplifying would mark the address
10625 operand addressable. Always gimplify when not in SSA form
10626 as we still may have to gimplify decls with value-exprs. */
10627 if (!gimplify_ctxp || !gimple_in_ssa_p (cfun)
10628 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p, 0)))
10630 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
10631 is_gimple_mem_ref_addr, fb_rvalue);
10632 if (ret == GS_ERROR)
10635 recalculate_side_effects (*expr_p);
10639 /* Constants need not be gimplified. */
10646 /* Drop the overflow flag on constants, we do not want
10647 that in the GIMPLE IL. */
10648 if (TREE_OVERFLOW_P (*expr_p))
10649 *expr_p = drop_tree_overflow (*expr_p);
10654 /* If we require an lvalue, such as for ADDR_EXPR, retain the
10655 CONST_DECL node. Otherwise the decl is replaceable by its
10657 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
10658 if (fallback & fb_lvalue)
10662 *expr_p = DECL_INITIAL (*expr_p);
10668 ret = gimplify_decl_expr (expr_p, pre_p);
10672 ret = gimplify_bind_expr (expr_p, pre_p);
10676 ret = gimplify_loop_expr (expr_p, pre_p);
10680 ret = gimplify_switch_expr (expr_p, pre_p);
10684 ret = gimplify_exit_expr (expr_p);
10688 /* If the target is not LABEL, then it is a computed jump
10689 and the target needs to be gimplified. */
10690 if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
10692 ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
10693 NULL, is_gimple_val, fb_rvalue);
10694 if (ret == GS_ERROR)
10697 gimplify_seq_add_stmt (pre_p,
10698 gimple_build_goto (GOTO_DESTINATION (*expr_p)));
10703 gimplify_seq_add_stmt (pre_p,
10704 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p),
10705 PREDICT_EXPR_OUTCOME (*expr_p)));
10711 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
10712 == current_function_decl);
10713 gimplify_seq_add_stmt (pre_p,
10714 gimple_build_label (LABEL_EXPR_LABEL (*expr_p)));
10717 case CASE_LABEL_EXPR:
10718 ret = gimplify_case_label_expr (expr_p, pre_p);
10722 ret = gimplify_return_expr (*expr_p, pre_p);
10726 /* Don't reduce this in place; let gimplify_init_constructor work its
10727 magic. Buf if we're just elaborating this for side effects, just
10728 gimplify any element that has side-effects. */
10729 if (fallback == fb_none)
10731 unsigned HOST_WIDE_INT ix;
10733 tree temp = NULL_TREE;
10734 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p), ix, val)
10735 if (TREE_SIDE_EFFECTS (val))
10736 append_to_statement_list (val, &temp);
10739 ret = temp ? GS_OK : GS_ALL_DONE;
10741 /* C99 code may assign to an array in a constructed
10742 structure or union, and this has undefined behavior only
10743 on execution, so create a temporary if an lvalue is
10745 else if (fallback == fb_lvalue)
10747 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p, false);
10748 mark_addressable (*expr_p);
10755 /* The following are special cases that are not handled by the
10756 original GIMPLE grammar. */
10758 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
10761 ret = gimplify_save_expr (expr_p, pre_p, post_p);
10764 case BIT_FIELD_REF:
10765 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
10766 post_p, is_gimple_lvalue, fb_either);
10767 recalculate_side_effects (*expr_p);
10770 case TARGET_MEM_REF:
10772 enum gimplify_status r0 = GS_ALL_DONE, r1 = GS_ALL_DONE;
10774 if (TMR_BASE (*expr_p))
10775 r0 = gimplify_expr (&TMR_BASE (*expr_p), pre_p,
10776 post_p, is_gimple_mem_ref_addr, fb_either);
10777 if (TMR_INDEX (*expr_p))
10778 r1 = gimplify_expr (&TMR_INDEX (*expr_p), pre_p,
10779 post_p, is_gimple_val, fb_rvalue);
10780 if (TMR_INDEX2 (*expr_p))
10781 r1 = gimplify_expr (&TMR_INDEX2 (*expr_p), pre_p,
10782 post_p, is_gimple_val, fb_rvalue);
10783 /* TMR_STEP and TMR_OFFSET are always integer constants. */
10784 ret = MIN (r0, r1);
10788 case NON_LVALUE_EXPR:
10789 /* This should have been stripped above. */
10790 gcc_unreachable ();
10793 ret = gimplify_asm_expr (expr_p, pre_p, post_p);
10796 case TRY_FINALLY_EXPR:
10797 case TRY_CATCH_EXPR:
10799 gimple_seq eval, cleanup;
10802 /* Calls to destructors are generated automatically in FINALLY/CATCH
10803 block. They should have location as UNKNOWN_LOCATION. However,
10804 gimplify_call_expr will reset these call stmts to input_location
10805 if it finds stmt's location is unknown. To prevent resetting for
10806 destructors, we set the input_location to unknown.
10807 Note that this only affects the destructor calls in FINALLY/CATCH
10808 block, and will automatically reset to its original value by the
10809 end of gimplify_expr. */
10810 input_location = UNKNOWN_LOCATION;
10811 eval = cleanup = NULL;
10812 gimplify_and_add (TREE_OPERAND (*expr_p, 0), &eval);
10813 gimplify_and_add (TREE_OPERAND (*expr_p, 1), &cleanup);
10814 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
10815 if (gimple_seq_empty_p (cleanup))
10817 gimple_seq_add_seq (pre_p, eval);
10821 try_ = gimple_build_try (eval, cleanup,
10822 TREE_CODE (*expr_p) == TRY_FINALLY_EXPR
10823 ? GIMPLE_TRY_FINALLY
10824 : GIMPLE_TRY_CATCH);
10825 if (EXPR_HAS_LOCATION (save_expr))
10826 gimple_set_location (try_, EXPR_LOCATION (save_expr));
10827 else if (LOCATION_LOCUS (saved_location) != UNKNOWN_LOCATION)
10828 gimple_set_location (try_, saved_location);
10829 if (TREE_CODE (*expr_p) == TRY_CATCH_EXPR)
10830 gimple_try_set_catch_is_cleanup (try_,
10831 TRY_CATCH_IS_CLEANUP (*expr_p));
10832 gimplify_seq_add_stmt (pre_p, try_);
10837 case CLEANUP_POINT_EXPR:
10838 ret = gimplify_cleanup_point_expr (expr_p, pre_p);
10842 ret = gimplify_target_expr (expr_p, pre_p, post_p);
10848 gimple_seq handler = NULL;
10849 gimplify_and_add (CATCH_BODY (*expr_p), &handler);
10850 c = gimple_build_catch (CATCH_TYPES (*expr_p), handler);
10851 gimplify_seq_add_stmt (pre_p, c);
10856 case EH_FILTER_EXPR:
10859 gimple_seq failure = NULL;
10861 gimplify_and_add (EH_FILTER_FAILURE (*expr_p), &failure);
10862 ehf = gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p), failure);
10863 gimple_set_no_warning (ehf, TREE_NO_WARNING (*expr_p));
10864 gimplify_seq_add_stmt (pre_p, ehf);
10871 enum gimplify_status r0, r1;
10872 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p,
10873 post_p, is_gimple_val, fb_rvalue);
10874 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p,
10875 post_p, is_gimple_val, fb_rvalue);
10876 TREE_SIDE_EFFECTS (*expr_p) = 0;
10877 ret = MIN (r0, r1);
10882 /* We get here when taking the address of a label. We mark
10883 the label as "forced"; meaning it can never be removed and
10884 it is a potential target for any computed goto. */
10885 FORCED_LABEL (*expr_p) = 1;
10889 case STATEMENT_LIST:
10890 ret = gimplify_statement_list (expr_p, pre_p);
10893 case WITH_SIZE_EXPR:
10895 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
10896 post_p == &internal_post ? NULL : post_p,
10897 gimple_test_f, fallback);
10898 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
10899 is_gimple_val, fb_rvalue);
10906 ret = gimplify_var_or_parm_decl (expr_p);
10910 /* When within an OMP context, notice uses of variables. */
10911 if (gimplify_omp_ctxp)
10912 omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
10917 /* Allow callbacks into the gimplifier during optimization. */
10922 gimplify_omp_parallel (expr_p, pre_p);
10927 gimplify_omp_task (expr_p, pre_p);
10935 case OMP_DISTRIBUTE:
10938 ret = gimplify_omp_for (expr_p, pre_p);
10942 gimplify_oacc_cache (expr_p, pre_p);
10947 gimplify_oacc_declare (expr_p, pre_p);
10951 case OACC_HOST_DATA:
10954 case OACC_PARALLEL:
10958 case OMP_TARGET_DATA:
10960 gimplify_omp_workshare (expr_p, pre_p);
10964 case OACC_ENTER_DATA:
10965 case OACC_EXIT_DATA:
10967 case OMP_TARGET_UPDATE:
10968 case OMP_TARGET_ENTER_DATA:
10969 case OMP_TARGET_EXIT_DATA:
10970 gimplify_omp_target_update (expr_p, pre_p);
10976 case OMP_TASKGROUP:
10980 gimple_seq body = NULL;
10983 gimplify_and_add (OMP_BODY (*expr_p), &body);
10984 switch (TREE_CODE (*expr_p))
10987 g = gimple_build_omp_section (body);
10990 g = gimple_build_omp_master (body);
10992 case OMP_TASKGROUP:
10994 gimple_seq cleanup = NULL;
10996 = builtin_decl_explicit (BUILT_IN_GOMP_TASKGROUP_END);
10997 g = gimple_build_call (fn, 0);
10998 gimple_seq_add_stmt (&cleanup, g);
10999 g = gimple_build_try (body, cleanup, GIMPLE_TRY_FINALLY);
11001 gimple_seq_add_stmt (&body, g);
11002 g = gimple_build_omp_taskgroup (body);
11006 g = gimplify_omp_ordered (*expr_p, body);
11009 gimplify_scan_omp_clauses (&OMP_CRITICAL_CLAUSES (*expr_p),
11010 pre_p, ORT_WORKSHARE, OMP_CRITICAL);
11011 gimplify_adjust_omp_clauses (pre_p, body,
11012 &OMP_CRITICAL_CLAUSES (*expr_p),
11014 g = gimple_build_omp_critical (body,
11015 OMP_CRITICAL_NAME (*expr_p),
11016 OMP_CRITICAL_CLAUSES (*expr_p));
11019 gcc_unreachable ();
11021 gimplify_seq_add_stmt (pre_p, g);
11027 case OMP_ATOMIC_READ:
11028 case OMP_ATOMIC_CAPTURE_OLD:
11029 case OMP_ATOMIC_CAPTURE_NEW:
11030 ret = gimplify_omp_atomic (expr_p, pre_p);
11033 case TRANSACTION_EXPR:
11034 ret = gimplify_transaction (expr_p, pre_p);
11037 case TRUTH_AND_EXPR:
11038 case TRUTH_OR_EXPR:
11039 case TRUTH_XOR_EXPR:
11041 tree orig_type = TREE_TYPE (*expr_p);
11042 tree new_type, xop0, xop1;
11043 *expr_p = gimple_boolify (*expr_p);
11044 new_type = TREE_TYPE (*expr_p);
11045 if (!useless_type_conversion_p (orig_type, new_type))
11047 *expr_p = fold_convert_loc (input_location, orig_type, *expr_p);
11052 /* Boolified binary truth expressions are semantically equivalent
11053 to bitwise binary expressions. Canonicalize them to the
11054 bitwise variant. */
11055 switch (TREE_CODE (*expr_p))
11057 case TRUTH_AND_EXPR:
11058 TREE_SET_CODE (*expr_p, BIT_AND_EXPR);
11060 case TRUTH_OR_EXPR:
11061 TREE_SET_CODE (*expr_p, BIT_IOR_EXPR);
11063 case TRUTH_XOR_EXPR:
11064 TREE_SET_CODE (*expr_p, BIT_XOR_EXPR);
11069 /* Now make sure that operands have compatible type to
11070 expression's new_type. */
11071 xop0 = TREE_OPERAND (*expr_p, 0);
11072 xop1 = TREE_OPERAND (*expr_p, 1);
11073 if (!useless_type_conversion_p (new_type, TREE_TYPE (xop0)))
11074 TREE_OPERAND (*expr_p, 0) = fold_convert_loc (input_location,
11077 if (!useless_type_conversion_p (new_type, TREE_TYPE (xop1)))
11078 TREE_OPERAND (*expr_p, 1) = fold_convert_loc (input_location,
11081 /* Continue classified as tcc_binary. */
11085 case VEC_COND_EXPR:
11087 enum gimplify_status r0, r1, r2;
11089 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11090 post_p, is_gimple_condexpr, fb_rvalue);
11091 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
11092 post_p, is_gimple_val, fb_rvalue);
11093 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
11094 post_p, is_gimple_val, fb_rvalue);
11096 ret = MIN (MIN (r0, r1), r2);
11097 recalculate_side_effects (*expr_p);
11102 case VEC_PERM_EXPR:
11103 /* Classified as tcc_expression. */
11106 case BIT_INSERT_EXPR:
11107 /* Argument 3 is a constant. */
11110 case POINTER_PLUS_EXPR:
11112 enum gimplify_status r0, r1;
11113 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11114 post_p, is_gimple_val, fb_rvalue);
11115 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
11116 post_p, is_gimple_val, fb_rvalue);
11117 recalculate_side_effects (*expr_p);
11118 ret = MIN (r0, r1);
11122 case CILK_SYNC_STMT:
11124 if (!fn_contains_cilk_spawn_p (cfun))
11126 error_at (EXPR_LOCATION (*expr_p),
11127 "expected %<_Cilk_spawn%> before %<_Cilk_sync%>");
11132 gimplify_cilk_sync (expr_p, pre_p);
11139 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
11141 case tcc_comparison:
11142 /* Handle comparison of objects of non scalar mode aggregates
11143 with a call to memcmp. It would be nice to only have to do
11144 this for variable-sized objects, but then we'd have to allow
11145 the same nest of reference nodes we allow for MODIFY_EXPR and
11146 that's too complex.
11148 Compare scalar mode aggregates as scalar mode values. Using
11149 memcmp for them would be very inefficient at best, and is
11150 plain wrong if bitfields are involved. */
11152 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
11154 /* Vector comparisons need no boolification. */
11155 if (TREE_CODE (type) == VECTOR_TYPE)
11157 else if (!AGGREGATE_TYPE_P (type))
11159 tree org_type = TREE_TYPE (*expr_p);
11160 *expr_p = gimple_boolify (*expr_p);
11161 if (!useless_type_conversion_p (org_type,
11162 TREE_TYPE (*expr_p)))
11164 *expr_p = fold_convert_loc (input_location,
11165 org_type, *expr_p);
11171 else if (TYPE_MODE (type) != BLKmode)
11172 ret = gimplify_scalar_mode_aggregate_compare (expr_p);
11174 ret = gimplify_variable_sized_compare (expr_p);
11179 /* If *EXPR_P does not need to be special-cased, handle it
11180 according to its class. */
11182 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11183 post_p, is_gimple_val, fb_rvalue);
11189 enum gimplify_status r0, r1;
11191 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11192 post_p, is_gimple_val, fb_rvalue);
11193 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
11194 post_p, is_gimple_val, fb_rvalue);
11196 ret = MIN (r0, r1);
11202 enum gimplify_status r0, r1, r2;
11204 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
11205 post_p, is_gimple_val, fb_rvalue);
11206 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
11207 post_p, is_gimple_val, fb_rvalue);
11208 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
11209 post_p, is_gimple_val, fb_rvalue);
11211 ret = MIN (MIN (r0, r1), r2);
11215 case tcc_declaration:
11218 goto dont_recalculate;
11221 gcc_unreachable ();
11224 recalculate_side_effects (*expr_p);
11230 gcc_assert (*expr_p || ret != GS_OK);
11232 while (ret == GS_OK);
11234 /* If we encountered an error_mark somewhere nested inside, either
11235 stub out the statement or propagate the error back out. */
11236 if (ret == GS_ERROR)
11243 /* This was only valid as a return value from the langhook, which
11244 we handled. Make sure it doesn't escape from any other context. */
11245 gcc_assert (ret != GS_UNHANDLED);
11247 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
11249 /* We aren't looking for a value, and we don't have a valid
11250 statement. If it doesn't have side-effects, throw it away. */
11251 if (!TREE_SIDE_EFFECTS (*expr_p))
11253 else if (!TREE_THIS_VOLATILE (*expr_p))
11255 /* This is probably a _REF that contains something nested that
11256 has side effects. Recurse through the operands to find it. */
11257 enum tree_code code = TREE_CODE (*expr_p);
11261 case COMPONENT_REF:
11262 case REALPART_EXPR:
11263 case IMAGPART_EXPR:
11264 case VIEW_CONVERT_EXPR:
11265 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
11266 gimple_test_f, fallback);
11270 case ARRAY_RANGE_REF:
11271 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
11272 gimple_test_f, fallback);
11273 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
11274 gimple_test_f, fallback);
11278 /* Anything else with side-effects must be converted to
11279 a valid statement before we get here. */
11280 gcc_unreachable ();
11285 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p))
11286 && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode)
11288 /* Historically, the compiler has treated a bare reference
11289 to a non-BLKmode volatile lvalue as forcing a load. */
11290 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
11292 /* Normally, we do not want to create a temporary for a
11293 TREE_ADDRESSABLE type because such a type should not be
11294 copied by bitwise-assignment. However, we make an
11295 exception here, as all we are doing here is ensuring that
11296 we read the bytes that make up the type. We use
11297 create_tmp_var_raw because create_tmp_var will abort when
11298 given a TREE_ADDRESSABLE type. */
11299 tree tmp = create_tmp_var_raw (type, "vol");
11300 gimple_add_tmp_var (tmp);
11301 gimplify_assign (tmp, *expr_p, pre_p);
11305 /* We can't do anything useful with a volatile reference to
11306 an incomplete type, so just throw it away. Likewise for
11307 a BLKmode type, since any implicit inner load should
11308 already have been turned into an explicit one by the
11309 gimplification process. */
11313 /* If we are gimplifying at the statement level, we're done. Tack
11314 everything together and return. */
11315 if (fallback == fb_none || is_statement)
11317 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
11318 it out for GC to reclaim it. */
11319 *expr_p = NULL_TREE;
11321 if (!gimple_seq_empty_p (internal_pre)
11322 || !gimple_seq_empty_p (internal_post))
11324 gimplify_seq_add_seq (&internal_pre, internal_post);
11325 gimplify_seq_add_seq (pre_p, internal_pre);
11328 /* The result of gimplifying *EXPR_P is going to be the last few
11329 statements in *PRE_P and *POST_P. Add location information
11330 to all the statements that were added by the gimplification
11332 if (!gimple_seq_empty_p (*pre_p))
11333 annotate_all_with_location_after (*pre_p, pre_last_gsi, input_location);
11335 if (!gimple_seq_empty_p (*post_p))
11336 annotate_all_with_location_after (*post_p, post_last_gsi,
11342 #ifdef ENABLE_GIMPLE_CHECKING
11345 enum tree_code code = TREE_CODE (*expr_p);
11346 /* These expressions should already be in gimple IR form. */
11347 gcc_assert (code != MODIFY_EXPR
11348 && code != ASM_EXPR
11349 && code != BIND_EXPR
11350 && code != CATCH_EXPR
11351 && (code != COND_EXPR || gimplify_ctxp->allow_rhs_cond_expr)
11352 && code != EH_FILTER_EXPR
11353 && code != GOTO_EXPR
11354 && code != LABEL_EXPR
11355 && code != LOOP_EXPR
11356 && code != SWITCH_EXPR
11357 && code != TRY_FINALLY_EXPR
11358 && code != OACC_PARALLEL
11359 && code != OACC_KERNELS
11360 && code != OACC_DATA
11361 && code != OACC_HOST_DATA
11362 && code != OACC_DECLARE
11363 && code != OACC_UPDATE
11364 && code != OACC_ENTER_DATA
11365 && code != OACC_EXIT_DATA
11366 && code != OACC_CACHE
11367 && code != OMP_CRITICAL
11369 && code != OACC_LOOP
11370 && code != OMP_MASTER
11371 && code != OMP_TASKGROUP
11372 && code != OMP_ORDERED
11373 && code != OMP_PARALLEL
11374 && code != OMP_SECTIONS
11375 && code != OMP_SECTION
11376 && code != OMP_SINGLE);
11380 /* Otherwise we're gimplifying a subexpression, so the resulting
11381 value is interesting. If it's a valid operand that matches
11382 GIMPLE_TEST_F, we're done. Unless we are handling some
11383 post-effects internally; if that's the case, we need to copy into
11384 a temporary before adding the post-effects to POST_P. */
11385 if (gimple_seq_empty_p (internal_post) && (*gimple_test_f) (*expr_p))
11388 /* Otherwise, we need to create a new temporary for the gimplified
11391 /* We can't return an lvalue if we have an internal postqueue. The
11392 object the lvalue refers to would (probably) be modified by the
11393 postqueue; we need to copy the value out first, which means an
11395 if ((fallback & fb_lvalue)
11396 && gimple_seq_empty_p (internal_post)
11397 && is_gimple_addressable (*expr_p))
11399 /* An lvalue will do. Take the address of the expression, store it
11400 in a temporary, and replace the expression with an INDIRECT_REF of
11402 tmp = build_fold_addr_expr_loc (input_location, *expr_p);
11403 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
11404 *expr_p = build_simple_mem_ref (tmp);
11406 else if ((fallback & fb_rvalue) && is_gimple_reg_rhs_or_call (*expr_p))
11408 /* An rvalue will do. Assign the gimplified expression into a
11409 new temporary TMP and replace the original expression with
11410 TMP. First, make sure that the expression has a type so that
11411 it can be assigned into a temporary. */
11412 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
11413 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
11417 #ifdef ENABLE_GIMPLE_CHECKING
11418 if (!(fallback & fb_mayfail))
11420 fprintf (stderr, "gimplification failed:\n");
11421 print_generic_expr (stderr, *expr_p, 0);
11422 debug_tree (*expr_p);
11423 internal_error ("gimplification failed");
11426 gcc_assert (fallback & fb_mayfail);
11428 /* If this is an asm statement, and the user asked for the
11429 impossible, don't die. Fail and let gimplify_asm_expr
11435 /* Make sure the temporary matches our predicate. */
11436 gcc_assert ((*gimple_test_f) (*expr_p));
11438 if (!gimple_seq_empty_p (internal_post))
11440 annotate_all_with_location (internal_post, input_location);
11441 gimplify_seq_add_seq (pre_p, internal_post);
11445 input_location = saved_location;
11449 /* Like gimplify_expr but make sure the gimplified result is not itself
11450 a SSA name (but a decl if it were). Temporaries required by
11451 evaluating *EXPR_P may be still SSA names. */
11453 static enum gimplify_status
11454 gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
11455 bool (*gimple_test_f) (tree), fallback_t fallback,
11458 bool was_ssa_name_p = TREE_CODE (*expr_p) == SSA_NAME;
11459 enum gimplify_status ret = gimplify_expr (expr_p, pre_p, post_p,
11460 gimple_test_f, fallback);
11462 && TREE_CODE (*expr_p) == SSA_NAME)
11464 tree name = *expr_p;
11465 if (was_ssa_name_p)
11466 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, NULL, false);
11469 /* Avoid the extra copy if possible. */
11470 *expr_p = create_tmp_reg (TREE_TYPE (name));
11471 gimple_set_lhs (SSA_NAME_DEF_STMT (name), *expr_p);
11472 release_ssa_name (name);
11478 /* Look through TYPE for variable-sized objects and gimplify each such
11479 size that we find. Add to LIST_P any statements generated. */
11482 gimplify_type_sizes (tree type, gimple_seq *list_p)
11486 if (type == NULL || type == error_mark_node)
11489 /* We first do the main variant, then copy into any other variants. */
11490 type = TYPE_MAIN_VARIANT (type);
11492 /* Avoid infinite recursion. */
11493 if (TYPE_SIZES_GIMPLIFIED (type))
11496 TYPE_SIZES_GIMPLIFIED (type) = 1;
11498 switch (TREE_CODE (type))
11501 case ENUMERAL_TYPE:
11504 case FIXED_POINT_TYPE:
11505 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
11506 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
11508 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11510 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
11511 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
11516 /* These types may not have declarations, so handle them here. */
11517 gimplify_type_sizes (TREE_TYPE (type), list_p);
11518 gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
11519 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
11520 with assigned stack slots, for -O1+ -g they should be tracked
11522 if (!(TYPE_NAME (type)
11523 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11524 && DECL_IGNORED_P (TYPE_NAME (type)))
11525 && TYPE_DOMAIN (type)
11526 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type)))
11528 t = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
11529 if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
11530 DECL_IGNORED_P (t) = 0;
11531 t = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
11532 if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
11533 DECL_IGNORED_P (t) = 0;
11539 case QUAL_UNION_TYPE:
11540 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
11541 if (TREE_CODE (field) == FIELD_DECL)
11543 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
11544 gimplify_one_sizepos (&DECL_SIZE (field), list_p);
11545 gimplify_one_sizepos (&DECL_SIZE_UNIT (field), list_p);
11546 gimplify_type_sizes (TREE_TYPE (field), list_p);
11551 case REFERENCE_TYPE:
11552 /* We used to recurse on the pointed-to type here, which turned out to
11553 be incorrect because its definition might refer to variables not
11554 yet initialized at this point if a forward declaration is involved.
11556 It was actually useful for anonymous pointed-to types to ensure
11557 that the sizes evaluation dominates every possible later use of the
11558 values. Restricting to such types here would be safe since there
11559 is no possible forward declaration around, but would introduce an
11560 undesirable middle-end semantic to anonymity. We then defer to
11561 front-ends the responsibility of ensuring that the sizes are
11562 evaluated both early and late enough, e.g. by attaching artificial
11563 type declarations to the tree. */
11570 gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
11571 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
11573 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11575 TYPE_SIZE (t) = TYPE_SIZE (type);
11576 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type);
11577 TYPE_SIZES_GIMPLIFIED (t) = 1;
11581 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
11582 a size or position, has had all of its SAVE_EXPRs evaluated.
11583 We add any required statements to *STMT_P. */
11586 gimplify_one_sizepos (tree *expr_p, gimple_seq *stmt_p)
11588 tree expr = *expr_p;
11590 /* We don't do anything if the value isn't there, is constant, or contains
11591 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
11592 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
11593 will want to replace it with a new variable, but that will cause problems
11594 if this type is from outside the function. It's OK to have that here. */
11595 if (is_gimple_sizepos (expr))
11598 *expr_p = unshare_expr (expr);
11600 /* SSA names in decl/type fields are a bad idea - they'll get reclaimed
11601 if the def vanishes. */
11602 gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue, false);
11605 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
11606 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
11607 is true, also gimplify the parameters. */
11610 gimplify_body (tree fndecl, bool do_parms)
11612 location_t saved_location = input_location;
11613 gimple_seq parm_stmts, seq;
11614 gimple *outer_stmt;
11616 struct cgraph_node *cgn;
11618 timevar_push (TV_TREE_GIMPLIFY);
11620 init_tree_ssa (cfun);
11622 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
11624 default_rtl_profile ();
11626 gcc_assert (gimplify_ctxp == NULL);
11627 push_gimplify_context (true);
11629 if (flag_openacc || flag_openmp)
11631 gcc_assert (gimplify_omp_ctxp == NULL);
11632 if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (fndecl)))
11633 gimplify_omp_ctxp = new_omp_context (ORT_TARGET);
11636 /* Unshare most shared trees in the body and in that of any nested functions.
11637 It would seem we don't have to do this for nested functions because
11638 they are supposed to be output and then the outer function gimplified
11639 first, but the g++ front end doesn't always do it that way. */
11640 unshare_body (fndecl);
11641 unvisit_body (fndecl);
11643 cgn = cgraph_node::get (fndecl);
11644 if (cgn && cgn->origin)
11645 nonlocal_vlas = new hash_set<tree>;
11647 /* Make sure input_location isn't set to something weird. */
11648 input_location = DECL_SOURCE_LOCATION (fndecl);
11650 /* Resolve callee-copies. This has to be done before processing
11651 the body so that DECL_VALUE_EXPR gets processed correctly. */
11652 parm_stmts = do_parms ? gimplify_parameters () : NULL;
11654 /* Gimplify the function's body. */
11656 gimplify_stmt (&DECL_SAVED_TREE (fndecl), &seq);
11657 outer_stmt = gimple_seq_first_stmt (seq);
11660 outer_stmt = gimple_build_nop ();
11661 gimplify_seq_add_stmt (&seq, outer_stmt);
11664 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
11665 not the case, wrap everything in a GIMPLE_BIND to make it so. */
11666 if (gimple_code (outer_stmt) == GIMPLE_BIND
11667 && gimple_seq_first (seq) == gimple_seq_last (seq))
11668 outer_bind = as_a <gbind *> (outer_stmt);
11670 outer_bind = gimple_build_bind (NULL_TREE, seq, NULL);
11672 DECL_SAVED_TREE (fndecl) = NULL_TREE;
11674 /* If we had callee-copies statements, insert them at the beginning
11675 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
11676 if (!gimple_seq_empty_p (parm_stmts))
11680 gimplify_seq_add_seq (&parm_stmts, gimple_bind_body (outer_bind));
11681 gimple_bind_set_body (outer_bind, parm_stmts);
11683 for (parm = DECL_ARGUMENTS (current_function_decl);
11684 parm; parm = DECL_CHAIN (parm))
11685 if (DECL_HAS_VALUE_EXPR_P (parm))
11687 DECL_HAS_VALUE_EXPR_P (parm) = 0;
11688 DECL_IGNORED_P (parm) = 0;
11694 if (nonlocal_vla_vars)
11696 /* tree-nested.c may later on call declare_vars (..., true);
11697 which relies on BLOCK_VARS chain to be the tail of the
11698 gimple_bind_vars chain. Ensure we don't violate that
11700 if (gimple_bind_block (outer_bind)
11701 == DECL_INITIAL (current_function_decl))
11702 declare_vars (nonlocal_vla_vars, outer_bind, true);
11704 BLOCK_VARS (DECL_INITIAL (current_function_decl))
11705 = chainon (BLOCK_VARS (DECL_INITIAL (current_function_decl)),
11706 nonlocal_vla_vars);
11707 nonlocal_vla_vars = NULL_TREE;
11709 delete nonlocal_vlas;
11710 nonlocal_vlas = NULL;
11713 if ((flag_openacc || flag_openmp || flag_openmp_simd)
11714 && gimplify_omp_ctxp)
11716 delete_omp_context (gimplify_omp_ctxp);
11717 gimplify_omp_ctxp = NULL;
11720 pop_gimplify_context (outer_bind);
11721 gcc_assert (gimplify_ctxp == NULL);
11723 if (flag_checking && !seen_error ())
11724 verify_gimple_in_seq (gimple_bind_body (outer_bind));
11726 timevar_pop (TV_TREE_GIMPLIFY);
11727 input_location = saved_location;
11732 typedef char *char_p; /* For DEF_VEC_P. */
11734 /* Return whether we should exclude FNDECL from instrumentation. */
11737 flag_instrument_functions_exclude_p (tree fndecl)
11741 v = (vec<char_p> *) flag_instrument_functions_exclude_functions;
11742 if (v && v->length () > 0)
11748 name = lang_hooks.decl_printable_name (fndecl, 0);
11749 FOR_EACH_VEC_ELT (*v, i, s)
11750 if (strstr (name, s) != NULL)
11754 v = (vec<char_p> *) flag_instrument_functions_exclude_files;
11755 if (v && v->length () > 0)
11761 name = DECL_SOURCE_FILE (fndecl);
11762 FOR_EACH_VEC_ELT (*v, i, s)
11763 if (strstr (name, s) != NULL)
11770 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
11771 node for the function we want to gimplify.
11773 Return the sequence of GIMPLE statements corresponding to the body
11777 gimplify_function_tree (tree fndecl)
11783 gcc_assert (!gimple_body (fndecl));
11785 if (DECL_STRUCT_FUNCTION (fndecl))
11786 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
11788 push_struct_function (fndecl);
11790 /* Tentatively set PROP_gimple_lva here, and reset it in gimplify_va_arg_expr
11792 cfun->curr_properties |= PROP_gimple_lva;
11794 for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = DECL_CHAIN (parm))
11796 /* Preliminarily mark non-addressed complex variables as eligible
11797 for promotion to gimple registers. We'll transform their uses
11798 as we find them. */
11799 if ((TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
11800 || TREE_CODE (TREE_TYPE (parm)) == VECTOR_TYPE)
11801 && !TREE_THIS_VOLATILE (parm)
11802 && !needs_to_live_in_memory (parm))
11803 DECL_GIMPLE_REG_P (parm) = 1;
11806 ret = DECL_RESULT (fndecl);
11807 if ((TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE
11808 || TREE_CODE (TREE_TYPE (ret)) == VECTOR_TYPE)
11809 && !needs_to_live_in_memory (ret))
11810 DECL_GIMPLE_REG_P (ret) = 1;
11812 bind = gimplify_body (fndecl, true);
11814 /* The tree body of the function is no longer needed, replace it
11815 with the new GIMPLE body. */
11817 gimple_seq_add_stmt (&seq, bind);
11818 gimple_set_body (fndecl, seq);
11820 /* If we're instrumenting function entry/exit, then prepend the call to
11821 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
11822 catch the exit hook. */
11823 /* ??? Add some way to ignore exceptions for this TFE. */
11824 if (flag_instrument_function_entry_exit
11825 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl)
11826 && !flag_instrument_functions_exclude_p (fndecl))
11831 gimple_seq cleanup = NULL, body = NULL;
11835 x = builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS);
11836 call = gimple_build_call (x, 1, integer_zero_node);
11837 tmp_var = create_tmp_var (ptr_type_node, "return_addr");
11838 gimple_call_set_lhs (call, tmp_var);
11839 gimplify_seq_add_stmt (&cleanup, call);
11840 x = builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT);
11841 call = gimple_build_call (x, 2,
11842 build_fold_addr_expr (current_function_decl),
11844 gimplify_seq_add_stmt (&cleanup, call);
11845 tf = gimple_build_try (seq, cleanup, GIMPLE_TRY_FINALLY);
11847 x = builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS);
11848 call = gimple_build_call (x, 1, integer_zero_node);
11849 tmp_var = create_tmp_var (ptr_type_node, "return_addr");
11850 gimple_call_set_lhs (call, tmp_var);
11851 gimplify_seq_add_stmt (&body, call);
11852 x = builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER);
11853 call = gimple_build_call (x, 2,
11854 build_fold_addr_expr (current_function_decl),
11856 gimplify_seq_add_stmt (&body, call);
11857 gimplify_seq_add_stmt (&body, tf);
11858 new_bind = gimple_build_bind (NULL, body, gimple_bind_block (bind));
11859 /* Clear the block for BIND, since it is no longer directly inside
11860 the function, but within a try block. */
11861 gimple_bind_set_block (bind, NULL);
11863 /* Replace the current function body with the body
11864 wrapped in the try/finally TF. */
11866 gimple_seq_add_stmt (&seq, new_bind);
11867 gimple_set_body (fndecl, seq);
11871 if ((flag_sanitize & SANITIZE_THREAD) != 0
11872 && !lookup_attribute ("no_sanitize_thread", DECL_ATTRIBUTES (fndecl)))
11874 gcall *call = gimple_build_call_internal (IFN_TSAN_FUNC_EXIT, 0);
11875 gimple *tf = gimple_build_try (seq, call, GIMPLE_TRY_FINALLY);
11876 gbind *new_bind = gimple_build_bind (NULL, tf, gimple_bind_block (bind));
11877 /* Clear the block for BIND, since it is no longer directly inside
11878 the function, but within a try block. */
11879 gimple_bind_set_block (bind, NULL);
11880 /* Replace the current function body with the body
11881 wrapped in the try/finally TF. */
11883 gimple_seq_add_stmt (&seq, new_bind);
11884 gimple_set_body (fndecl, seq);
11887 DECL_SAVED_TREE (fndecl) = NULL_TREE;
11888 cfun->curr_properties |= PROP_gimple_any;
11892 dump_function (TDI_generic, fndecl);
11895 /* Return a dummy expression of type TYPE in order to keep going after an
11899 dummy_object (tree type)
11901 tree t = build_int_cst (build_pointer_type (type), 0);
11902 return build2 (MEM_REF, type, t, t);
11905 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
11906 builtin function, but a very special sort of operator. */
11908 enum gimplify_status
11909 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p,
11910 gimple_seq *post_p ATTRIBUTE_UNUSED)
11912 tree promoted_type, have_va_type;
11913 tree valist = TREE_OPERAND (*expr_p, 0);
11914 tree type = TREE_TYPE (*expr_p);
11915 tree t, tag, aptag;
11916 location_t loc = EXPR_LOCATION (*expr_p);
11918 /* Verify that valist is of the proper type. */
11919 have_va_type = TREE_TYPE (valist);
11920 if (have_va_type == error_mark_node)
11922 have_va_type = targetm.canonical_va_list_type (have_va_type);
11924 if (have_va_type == NULL_TREE)
11926 error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
11930 /* Generate a diagnostic for requesting data of a type that cannot
11931 be passed through `...' due to type promotion at the call site. */
11932 if ((promoted_type = lang_hooks.types.type_promotes_to (type))
11935 static bool gave_help;
11937 /* Use the expansion point to handle cases such as passing bool (defined
11938 in a system header) through `...'. */
11939 source_location xloc
11940 = expansion_point_location_if_in_system_header (loc);
11942 /* Unfortunately, this is merely undefined, rather than a constraint
11943 violation, so we cannot make this an error. If this call is never
11944 executed, the program is still strictly conforming. */
11945 warned = warning_at (xloc, 0,
11946 "%qT is promoted to %qT when passed through %<...%>",
11947 type, promoted_type);
11948 if (!gave_help && warned)
11951 inform (xloc, "(so you should pass %qT not %qT to %<va_arg%>)",
11952 promoted_type, type);
11955 /* We can, however, treat "undefined" any way we please.
11956 Call abort to encourage the user to fix the program. */
11958 inform (xloc, "if this code is reached, the program will abort");
11959 /* Before the abort, allow the evaluation of the va_list
11960 expression to exit or longjmp. */
11961 gimplify_and_add (valist, pre_p);
11962 t = build_call_expr_loc (loc,
11963 builtin_decl_implicit (BUILT_IN_TRAP), 0);
11964 gimplify_and_add (t, pre_p);
11966 /* This is dead code, but go ahead and finish so that the
11967 mode of the result comes out right. */
11968 *expr_p = dummy_object (type);
11969 return GS_ALL_DONE;
11972 tag = build_int_cst (build_pointer_type (type), 0);
11973 aptag = build_int_cst (TREE_TYPE (valist), 0);
11975 *expr_p = build_call_expr_internal_loc (loc, IFN_VA_ARG, type, 3,
11976 valist, tag, aptag);
11978 /* Clear the tentatively set PROP_gimple_lva, to indicate that IFN_VA_ARG
11979 needs to be expanded. */
11980 cfun->curr_properties &= ~PROP_gimple_lva;
11985 /* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
11987 DST/SRC are the destination and source respectively. You can pass
11988 ungimplified trees in DST or SRC, in which case they will be
11989 converted to a gimple operand if necessary.
11991 This function returns the newly created GIMPLE_ASSIGN tuple. */
11994 gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
11996 tree t = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
11997 gimplify_and_add (t, seq_p);
11999 return gimple_seq_last_stmt (*seq_p);
12003 gimplify_hasher::hash (const elt_t *p)
12006 return iterative_hash_expr (t, 0);
12010 gimplify_hasher::equal (const elt_t *p1, const elt_t *p2)
12014 enum tree_code code = TREE_CODE (t1);
12016 if (TREE_CODE (t2) != code
12017 || TREE_TYPE (t1) != TREE_TYPE (t2))
12020 if (!operand_equal_p (t1, t2, 0))
12023 /* Only allow them to compare equal if they also hash equal; otherwise
12024 results are nondeterminate, and we fail bootstrap comparison. */
12025 gcc_checking_assert (hash (p1) == hash (p2));