1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002-2019 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"
33 #include "gimple-predict.h"
34 #include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
37 #include "tree-pretty-print.h"
38 #include "diagnostic-core.h"
40 #include "fold-const.h"
45 #include "gimple-fold.h"
48 #include "gimple-iterator.h"
49 #include "stor-layout.h"
50 #include "print-tree.h"
51 #include "tree-iterator.h"
52 #include "tree-inline.h"
53 #include "langhooks.h"
56 #include "omp-general.h"
58 #include "gimple-low.h"
59 #include "gomp-constants.h"
60 #include "splay-tree.h"
61 #include "gimple-walk.h"
62 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
64 #include "stringpool.h"
69 /* Hash set of poisoned variables in a bind expr. */
70 static hash_set
<tree
> *asan_poisoned_variables
= NULL
;
72 enum gimplify_omp_var_data
78 GOVD_FIRSTPRIVATE
= 16,
79 GOVD_LASTPRIVATE
= 32,
83 GOVD_DEBUG_PRIVATE
= 512,
84 GOVD_PRIVATE_OUTER_REF
= 1024,
88 /* Flag for GOVD_MAP: don't copy back. */
89 GOVD_MAP_TO_ONLY
= 8192,
91 /* Flag for GOVD_LINEAR or GOVD_LASTPRIVATE: no outer reference. */
92 GOVD_LINEAR_LASTPRIVATE_NO_OUTER
= 16384,
94 GOVD_MAP_0LEN_ARRAY
= 32768,
96 /* Flag for GOVD_MAP, if it is always, to or always, tofrom mapping. */
97 GOVD_MAP_ALWAYS_TO
= 65536,
99 /* Flag for shared vars that are or might be stored to in the region. */
100 GOVD_WRITTEN
= 131072,
102 /* Flag for GOVD_MAP, if it is a forced mapping. */
103 GOVD_MAP_FORCE
= 262144,
105 /* Flag for GOVD_MAP: must be present already. */
106 GOVD_MAP_FORCE_PRESENT
= 524288,
108 /* Flag for GOVD_MAP: only allocate. */
109 GOVD_MAP_ALLOC_ONLY
= 1048576,
111 /* Flag for GOVD_MAP: only copy back. */
112 GOVD_MAP_FROM_ONLY
= 2097152,
114 GOVD_NONTEMPORAL
= 4194304,
116 GOVD_DATA_SHARE_CLASS
= (GOVD_SHARED
| GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
117 | GOVD_LASTPRIVATE
| GOVD_REDUCTION
| GOVD_LINEAR
124 ORT_WORKSHARE
= 0x00,
125 ORT_TASKGROUP
= 0x01,
129 ORT_COMBINED_PARALLEL
= ORT_PARALLEL
| 1,
132 ORT_UNTIED_TASK
= ORT_TASK
| 1,
133 ORT_TASKLOOP
= ORT_TASK
| 2,
134 ORT_UNTIED_TASKLOOP
= ORT_UNTIED_TASK
| 2,
137 ORT_COMBINED_TEAMS
= ORT_TEAMS
| 1,
138 ORT_HOST_TEAMS
= ORT_TEAMS
| 2,
139 ORT_COMBINED_HOST_TEAMS
= ORT_COMBINED_TEAMS
| 2,
142 ORT_TARGET_DATA
= 0x40,
144 /* Data region with offloading. */
146 ORT_COMBINED_TARGET
= ORT_TARGET
| 1,
148 /* OpenACC variants. */
149 ORT_ACC
= 0x100, /* A generic OpenACC region. */
150 ORT_ACC_DATA
= ORT_ACC
| ORT_TARGET_DATA
, /* Data construct. */
151 ORT_ACC_PARALLEL
= ORT_ACC
| ORT_TARGET
, /* Parallel construct */
152 ORT_ACC_KERNELS
= ORT_ACC
| ORT_TARGET
| 2, /* Kernels construct. */
153 ORT_ACC_HOST_DATA
= ORT_ACC
| ORT_TARGET_DATA
| 2, /* Host data. */
155 /* Dummy OpenMP region, used to disable expansion of
156 DECL_VALUE_EXPRs in taskloop pre body. */
160 /* Gimplify hashtable helper. */
162 struct gimplify_hasher
: free_ptr_hash
<elt_t
>
164 static inline hashval_t
hash (const elt_t
*);
165 static inline bool equal (const elt_t
*, const elt_t
*);
170 struct gimplify_ctx
*prev_context
;
172 vec
<gbind
*> bind_expr_stack
;
174 gimple_seq conditional_cleanups
;
178 vec
<tree
> case_labels
;
179 hash_set
<tree
> *live_switch_vars
;
180 /* The formal temporary table. Should this be persistent? */
181 hash_table
<gimplify_hasher
> *temp_htab
;
184 unsigned into_ssa
: 1;
185 unsigned allow_rhs_cond_expr
: 1;
186 unsigned in_cleanup_point_expr
: 1;
187 unsigned keep_stack
: 1;
188 unsigned save_stack
: 1;
189 unsigned in_switch_expr
: 1;
192 enum gimplify_defaultmap_kind
200 struct gimplify_omp_ctx
202 struct gimplify_omp_ctx
*outer_context
;
203 splay_tree variables
;
204 hash_set
<tree
> *privatized_types
;
205 /* Iteration variables in an OMP_FOR. */
206 vec
<tree
> loop_iter_var
;
208 enum omp_clause_default_kind default_kind
;
209 enum omp_region_type region_type
;
212 bool target_firstprivatize_array_bases
;
216 static struct gimplify_ctx
*gimplify_ctxp
;
217 static struct gimplify_omp_ctx
*gimplify_omp_ctxp
;
219 /* Forward declaration. */
220 static enum gimplify_status
gimplify_compound_expr (tree
*, gimple_seq
*, bool);
221 static hash_map
<tree
, tree
> *oacc_declare_returns
;
222 static enum gimplify_status
gimplify_expr (tree
*, gimple_seq
*, gimple_seq
*,
223 bool (*) (tree
), fallback_t
, bool);
225 /* Shorter alias name for the above function for use in gimplify.c
229 gimplify_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
231 gimple_seq_add_stmt_without_update (seq_p
, gs
);
234 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
235 NULL, a new sequence is allocated. This function is
236 similar to gimple_seq_add_seq, but does not scan the operands.
237 During gimplification, we need to manipulate statement sequences
238 before the def/use vectors have been constructed. */
241 gimplify_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
243 gimple_stmt_iterator si
;
248 si
= gsi_last (*dst_p
);
249 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
253 /* Pointer to a list of allocated gimplify_ctx structs to be used for pushing
254 and popping gimplify contexts. */
256 static struct gimplify_ctx
*ctx_pool
= NULL
;
258 /* Return a gimplify context struct from the pool. */
260 static inline struct gimplify_ctx
*
263 struct gimplify_ctx
* c
= ctx_pool
;
266 ctx_pool
= c
->prev_context
;
268 c
= XNEW (struct gimplify_ctx
);
270 memset (c
, '\0', sizeof (*c
));
274 /* Put gimplify context C back into the pool. */
277 ctx_free (struct gimplify_ctx
*c
)
279 c
->prev_context
= ctx_pool
;
283 /* Free allocated ctx stack memory. */
286 free_gimplify_stack (void)
288 struct gimplify_ctx
*c
;
290 while ((c
= ctx_pool
))
292 ctx_pool
= c
->prev_context
;
298 /* Set up a context for the gimplifier. */
301 push_gimplify_context (bool in_ssa
, bool rhs_cond_ok
)
303 struct gimplify_ctx
*c
= ctx_alloc ();
305 c
->prev_context
= gimplify_ctxp
;
307 gimplify_ctxp
->into_ssa
= in_ssa
;
308 gimplify_ctxp
->allow_rhs_cond_expr
= rhs_cond_ok
;
311 /* Tear down a context for the gimplifier. If BODY is non-null, then
312 put the temporaries into the outer BIND_EXPR. Otherwise, put them
315 BODY is not a sequence, but the first tuple in a sequence. */
318 pop_gimplify_context (gimple
*body
)
320 struct gimplify_ctx
*c
= gimplify_ctxp
;
323 && (!c
->bind_expr_stack
.exists ()
324 || c
->bind_expr_stack
.is_empty ()));
325 c
->bind_expr_stack
.release ();
326 gimplify_ctxp
= c
->prev_context
;
329 declare_vars (c
->temps
, body
, false);
331 record_vars (c
->temps
);
338 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
341 gimple_push_bind_expr (gbind
*bind_stmt
)
343 gimplify_ctxp
->bind_expr_stack
.reserve (8);
344 gimplify_ctxp
->bind_expr_stack
.safe_push (bind_stmt
);
347 /* Pop the first element off the stack of bindings. */
350 gimple_pop_bind_expr (void)
352 gimplify_ctxp
->bind_expr_stack
.pop ();
355 /* Return the first element of the stack of bindings. */
358 gimple_current_bind_expr (void)
360 return gimplify_ctxp
->bind_expr_stack
.last ();
363 /* Return the stack of bindings created during gimplification. */
366 gimple_bind_expr_stack (void)
368 return gimplify_ctxp
->bind_expr_stack
;
371 /* Return true iff there is a COND_EXPR between us and the innermost
372 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
375 gimple_conditional_context (void)
377 return gimplify_ctxp
->conditions
> 0;
380 /* Note that we've entered a COND_EXPR. */
383 gimple_push_condition (void)
385 #ifdef ENABLE_GIMPLE_CHECKING
386 if (gimplify_ctxp
->conditions
== 0)
387 gcc_assert (gimple_seq_empty_p (gimplify_ctxp
->conditional_cleanups
));
389 ++(gimplify_ctxp
->conditions
);
392 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
393 now, add any conditional cleanups we've seen to the prequeue. */
396 gimple_pop_condition (gimple_seq
*pre_p
)
398 int conds
= --(gimplify_ctxp
->conditions
);
400 gcc_assert (conds
>= 0);
403 gimplify_seq_add_seq (pre_p
, gimplify_ctxp
->conditional_cleanups
);
404 gimplify_ctxp
->conditional_cleanups
= NULL
;
408 /* A stable comparison routine for use with splay trees and DECLs. */
411 splay_tree_compare_decl_uid (splay_tree_key xa
, splay_tree_key xb
)
416 return DECL_UID (a
) - DECL_UID (b
);
419 /* Create a new omp construct that deals with variable remapping. */
421 static struct gimplify_omp_ctx
*
422 new_omp_context (enum omp_region_type region_type
)
424 struct gimplify_omp_ctx
*c
;
426 c
= XCNEW (struct gimplify_omp_ctx
);
427 c
->outer_context
= gimplify_omp_ctxp
;
428 c
->variables
= splay_tree_new (splay_tree_compare_decl_uid
, 0, 0);
429 c
->privatized_types
= new hash_set
<tree
>;
430 c
->location
= input_location
;
431 c
->region_type
= region_type
;
432 if ((region_type
& ORT_TASK
) == 0)
433 c
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
435 c
->default_kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
436 c
->defaultmap
[GDMK_SCALAR
] = GOVD_MAP
;
437 c
->defaultmap
[GDMK_AGGREGATE
] = GOVD_MAP
;
438 c
->defaultmap
[GDMK_ALLOCATABLE
] = GOVD_MAP
;
439 c
->defaultmap
[GDMK_POINTER
] = GOVD_MAP
;
444 /* Destroy an omp construct that deals with variable remapping. */
447 delete_omp_context (struct gimplify_omp_ctx
*c
)
449 splay_tree_delete (c
->variables
);
450 delete c
->privatized_types
;
451 c
->loop_iter_var
.release ();
455 static void omp_add_variable (struct gimplify_omp_ctx
*, tree
, unsigned int);
456 static bool omp_notice_variable (struct gimplify_omp_ctx
*, tree
, bool);
458 /* Both gimplify the statement T and append it to *SEQ_P. This function
459 behaves exactly as gimplify_stmt, but you don't have to pass T as a
463 gimplify_and_add (tree t
, gimple_seq
*seq_p
)
465 gimplify_stmt (&t
, seq_p
);
468 /* Gimplify statement T into sequence *SEQ_P, and return the first
469 tuple in the sequence of generated tuples for this statement.
470 Return NULL if gimplifying T produced no tuples. */
473 gimplify_and_return_first (tree t
, gimple_seq
*seq_p
)
475 gimple_stmt_iterator last
= gsi_last (*seq_p
);
477 gimplify_and_add (t
, seq_p
);
479 if (!gsi_end_p (last
))
482 return gsi_stmt (last
);
485 return gimple_seq_first_stmt (*seq_p
);
488 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
489 LHS, or for a call argument. */
492 is_gimple_mem_rhs (tree t
)
494 /* If we're dealing with a renamable type, either source or dest must be
495 a renamed variable. */
496 if (is_gimple_reg_type (TREE_TYPE (t
)))
497 return is_gimple_val (t
);
499 return is_gimple_val (t
) || is_gimple_lvalue (t
);
502 /* Return true if T is a CALL_EXPR or an expression that can be
503 assigned to a temporary. Note that this predicate should only be
504 used during gimplification. See the rationale for this in
505 gimplify_modify_expr. */
508 is_gimple_reg_rhs_or_call (tree t
)
510 return (get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
511 || TREE_CODE (t
) == CALL_EXPR
);
514 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
515 this predicate should only be used during gimplification. See the
516 rationale for this in gimplify_modify_expr. */
519 is_gimple_mem_rhs_or_call (tree t
)
521 /* If we're dealing with a renamable type, either source or dest must be
522 a renamed variable. */
523 if (is_gimple_reg_type (TREE_TYPE (t
)))
524 return is_gimple_val (t
);
526 return (is_gimple_val (t
)
527 || is_gimple_lvalue (t
)
528 || TREE_CLOBBER_P (t
)
529 || TREE_CODE (t
) == CALL_EXPR
);
532 /* Create a temporary with a name derived from VAL. Subroutine of
533 lookup_tmp_var; nobody else should call this function. */
536 create_tmp_from_val (tree val
)
538 /* Drop all qualifiers and address-space information from the value type. */
539 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (val
));
540 tree var
= create_tmp_var (type
, get_name (val
));
541 if (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
542 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
543 DECL_GIMPLE_REG_P (var
) = 1;
547 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
548 an existing expression temporary. */
551 lookup_tmp_var (tree val
, bool is_formal
)
555 /* If not optimizing, never really reuse a temporary. local-alloc
556 won't allocate any variable that is used in more than one basic
557 block, which means it will go into memory, causing much extra
558 work in reload and final and poorer code generation, outweighing
559 the extra memory allocation here. */
560 if (!optimize
|| !is_formal
|| TREE_SIDE_EFFECTS (val
))
561 ret
= create_tmp_from_val (val
);
568 if (!gimplify_ctxp
->temp_htab
)
569 gimplify_ctxp
->temp_htab
= new hash_table
<gimplify_hasher
> (1000);
570 slot
= gimplify_ctxp
->temp_htab
->find_slot (&elt
, INSERT
);
573 elt_p
= XNEW (elt_t
);
575 elt_p
->temp
= ret
= create_tmp_from_val (val
);
588 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
591 internal_get_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
592 bool is_formal
, bool allow_ssa
)
596 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
597 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
598 gimplify_expr (&val
, pre_p
, post_p
, is_gimple_reg_rhs_or_call
,
602 && gimplify_ctxp
->into_ssa
603 && is_gimple_reg_type (TREE_TYPE (val
)))
605 t
= make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val
)));
606 if (! gimple_in_ssa_p (cfun
))
608 const char *name
= get_name (val
);
610 SET_SSA_NAME_VAR_OR_IDENTIFIER (t
, create_tmp_var_name (name
));
614 t
= lookup_tmp_var (val
, is_formal
);
616 mod
= build2 (INIT_EXPR
, TREE_TYPE (t
), t
, unshare_expr (val
));
618 SET_EXPR_LOCATION (mod
, EXPR_LOC_OR_LOC (val
, input_location
));
620 /* gimplify_modify_expr might want to reduce this further. */
621 gimplify_and_add (mod
, pre_p
);
627 /* Return a formal temporary variable initialized with VAL. PRE_P is as
628 in gimplify_expr. Only use this function if:
630 1) The value of the unfactored expression represented by VAL will not
631 change between the initialization and use of the temporary, and
632 2) The temporary will not be otherwise modified.
634 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
635 and #2 means it is inappropriate for && temps.
637 For other cases, use get_initialized_tmp_var instead. */
640 get_formal_tmp_var (tree val
, gimple_seq
*pre_p
)
642 return internal_get_tmp_var (val
, pre_p
, NULL
, true, true);
645 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
646 are as in gimplify_expr. */
649 get_initialized_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
652 return internal_get_tmp_var (val
, pre_p
, post_p
, false, allow_ssa
);
655 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
656 generate debug info for them; otherwise don't. */
659 declare_vars (tree vars
, gimple
*gs
, bool debug_info
)
666 gbind
*scope
= as_a
<gbind
*> (gs
);
668 temps
= nreverse (last
);
670 block
= gimple_bind_block (scope
);
671 gcc_assert (!block
|| TREE_CODE (block
) == BLOCK
);
672 if (!block
|| !debug_info
)
674 DECL_CHAIN (last
) = gimple_bind_vars (scope
);
675 gimple_bind_set_vars (scope
, temps
);
679 /* We need to attach the nodes both to the BIND_EXPR and to its
680 associated BLOCK for debugging purposes. The key point here
681 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
682 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
683 if (BLOCK_VARS (block
))
684 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), temps
);
687 gimple_bind_set_vars (scope
,
688 chainon (gimple_bind_vars (scope
), temps
));
689 BLOCK_VARS (block
) = temps
;
695 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
696 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
697 no such upper bound can be obtained. */
700 force_constant_size (tree var
)
702 /* The only attempt we make is by querying the maximum size of objects
703 of the variable's type. */
705 HOST_WIDE_INT max_size
;
707 gcc_assert (VAR_P (var
));
709 max_size
= max_int_size_in_bytes (TREE_TYPE (var
));
711 gcc_assert (max_size
>= 0);
714 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var
)), max_size
);
716 = build_int_cst (TREE_TYPE (DECL_SIZE (var
)), max_size
* BITS_PER_UNIT
);
719 /* Push the temporary variable TMP into the current binding. */
722 gimple_add_tmp_var_fn (struct function
*fn
, tree tmp
)
724 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
726 /* Later processing assumes that the object size is constant, which might
727 not be true at this point. Force the use of a constant upper bound in
729 if (!tree_fits_poly_uint64_p (DECL_SIZE_UNIT (tmp
)))
730 force_constant_size (tmp
);
732 DECL_CONTEXT (tmp
) = fn
->decl
;
733 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
735 record_vars_into (tmp
, fn
->decl
);
738 /* Push the temporary variable TMP into the current binding. */
741 gimple_add_tmp_var (tree tmp
)
743 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
745 /* Later processing assumes that the object size is constant, which might
746 not be true at this point. Force the use of a constant upper bound in
748 if (!tree_fits_poly_uint64_p (DECL_SIZE_UNIT (tmp
)))
749 force_constant_size (tmp
);
751 DECL_CONTEXT (tmp
) = current_function_decl
;
752 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
756 DECL_CHAIN (tmp
) = gimplify_ctxp
->temps
;
757 gimplify_ctxp
->temps
= tmp
;
759 /* Mark temporaries local within the nearest enclosing parallel. */
760 if (gimplify_omp_ctxp
)
762 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
764 && (ctx
->region_type
== ORT_WORKSHARE
765 || ctx
->region_type
== ORT_TASKGROUP
766 || ctx
->region_type
== ORT_SIMD
767 || ctx
->region_type
== ORT_ACC
))
768 ctx
= ctx
->outer_context
;
770 omp_add_variable (ctx
, tmp
, GOVD_LOCAL
| GOVD_SEEN
);
779 /* This case is for nested functions. We need to expose the locals
781 body_seq
= gimple_body (current_function_decl
);
782 declare_vars (tmp
, gimple_seq_first_stmt (body_seq
), false);
788 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
789 nodes that are referenced more than once in GENERIC functions. This is
790 necessary because gimplification (translation into GIMPLE) is performed
791 by modifying tree nodes in-place, so gimplication of a shared node in a
792 first context could generate an invalid GIMPLE form in a second context.
794 This is achieved with a simple mark/copy/unmark algorithm that walks the
795 GENERIC representation top-down, marks nodes with TREE_VISITED the first
796 time it encounters them, duplicates them if they already have TREE_VISITED
797 set, and finally removes the TREE_VISITED marks it has set.
799 The algorithm works only at the function level, i.e. it generates a GENERIC
800 representation of a function with no nodes shared within the function when
801 passed a GENERIC function (except for nodes that are allowed to be shared).
803 At the global level, it is also necessary to unshare tree nodes that are
804 referenced in more than one function, for the same aforementioned reason.
805 This requires some cooperation from the front-end. There are 2 strategies:
807 1. Manual unsharing. The front-end needs to call unshare_expr on every
808 expression that might end up being shared across functions.
810 2. Deep unsharing. This is an extension of regular unsharing. Instead
811 of calling unshare_expr on expressions that might be shared across
812 functions, the front-end pre-marks them with TREE_VISITED. This will
813 ensure that they are unshared on the first reference within functions
814 when the regular unsharing algorithm runs. The counterpart is that
815 this algorithm must look deeper than for manual unsharing, which is
816 specified by LANG_HOOKS_DEEP_UNSHARING.
818 If there are only few specific cases of node sharing across functions, it is
819 probably easier for a front-end to unshare the expressions manually. On the
820 contrary, if the expressions generated at the global level are as widespread
821 as expressions generated within functions, deep unsharing is very likely the
824 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
825 These nodes model computations that must be done once. If we were to
826 unshare something like SAVE_EXPR(i++), the gimplification process would
827 create wrong code. However, if DATA is non-null, it must hold a pointer
828 set that is used to unshare the subtrees of these nodes. */
831 mostly_copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
834 enum tree_code code
= TREE_CODE (t
);
836 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
837 copy their subtrees if we can make sure to do it only once. */
838 if (code
== SAVE_EXPR
|| code
== TARGET_EXPR
|| code
== BIND_EXPR
)
840 if (data
&& !((hash_set
<tree
> *)data
)->add (t
))
846 /* Stop at types, decls, constants like copy_tree_r. */
847 else if (TREE_CODE_CLASS (code
) == tcc_type
848 || TREE_CODE_CLASS (code
) == tcc_declaration
849 || TREE_CODE_CLASS (code
) == tcc_constant
)
852 /* Cope with the statement expression extension. */
853 else if (code
== STATEMENT_LIST
)
856 /* Leave the bulk of the work to copy_tree_r itself. */
858 copy_tree_r (tp
, walk_subtrees
, NULL
);
863 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
864 If *TP has been visited already, then *TP is deeply copied by calling
865 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
868 copy_if_shared_r (tree
*tp
, int *walk_subtrees
, void *data
)
871 enum tree_code code
= TREE_CODE (t
);
873 /* Skip types, decls, and constants. But we do want to look at their
874 types and the bounds of types. Mark them as visited so we properly
875 unmark their subtrees on the unmark pass. If we've already seen them,
876 don't look down further. */
877 if (TREE_CODE_CLASS (code
) == tcc_type
878 || TREE_CODE_CLASS (code
) == tcc_declaration
879 || TREE_CODE_CLASS (code
) == tcc_constant
)
881 if (TREE_VISITED (t
))
884 TREE_VISITED (t
) = 1;
887 /* If this node has been visited already, unshare it and don't look
889 else if (TREE_VISITED (t
))
891 walk_tree (tp
, mostly_copy_tree_r
, data
, NULL
);
895 /* Otherwise, mark the node as visited and keep looking. */
897 TREE_VISITED (t
) = 1;
902 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
903 copy_if_shared_r callback unmodified. */
906 copy_if_shared (tree
*tp
, void *data
)
908 walk_tree (tp
, copy_if_shared_r
, data
, NULL
);
911 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
912 any nested functions. */
915 unshare_body (tree fndecl
)
917 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
918 /* If the language requires deep unsharing, we need a pointer set to make
919 sure we don't repeatedly unshare subtrees of unshareable nodes. */
920 hash_set
<tree
> *visited
921 = lang_hooks
.deep_unsharing
? new hash_set
<tree
> : NULL
;
923 copy_if_shared (&DECL_SAVED_TREE (fndecl
), visited
);
924 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl
)), visited
);
925 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)), visited
);
930 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
931 unshare_body (cgn
->decl
);
934 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
935 Subtrees are walked until the first unvisited node is encountered. */
938 unmark_visited_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
942 /* If this node has been visited, unmark it and keep looking. */
943 if (TREE_VISITED (t
))
944 TREE_VISITED (t
) = 0;
946 /* Otherwise, don't look any deeper. */
953 /* Unmark the visited trees rooted at *TP. */
956 unmark_visited (tree
*tp
)
958 walk_tree (tp
, unmark_visited_r
, NULL
, NULL
);
961 /* Likewise, but mark all trees as not visited. */
964 unvisit_body (tree fndecl
)
966 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
968 unmark_visited (&DECL_SAVED_TREE (fndecl
));
969 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl
)));
970 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)));
973 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
974 unvisit_body (cgn
->decl
);
977 /* Unconditionally make an unshared copy of EXPR. This is used when using
978 stored expressions which span multiple functions, such as BINFO_VTABLE,
979 as the normal unsharing process can't tell that they're shared. */
982 unshare_expr (tree expr
)
984 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
988 /* Worker for unshare_expr_without_location. */
991 prune_expr_location (tree
*tp
, int *walk_subtrees
, void *)
994 SET_EXPR_LOCATION (*tp
, UNKNOWN_LOCATION
);
1000 /* Similar to unshare_expr but also prune all expression locations
1004 unshare_expr_without_location (tree expr
)
1006 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
1008 walk_tree (&expr
, prune_expr_location
, NULL
, NULL
);
1012 /* Return the EXPR_LOCATION of EXPR, if it (maybe recursively) has
1013 one, OR_ELSE otherwise. The location of a STATEMENT_LISTs
1014 comprising at least one DEBUG_BEGIN_STMT followed by exactly one
1015 EXPR is the location of the EXPR. */
1018 rexpr_location (tree expr
, location_t or_else
= UNKNOWN_LOCATION
)
1023 if (EXPR_HAS_LOCATION (expr
))
1024 return EXPR_LOCATION (expr
);
1026 if (TREE_CODE (expr
) != STATEMENT_LIST
)
1029 tree_stmt_iterator i
= tsi_start (expr
);
1032 while (!tsi_end_p (i
) && TREE_CODE (tsi_stmt (i
)) == DEBUG_BEGIN_STMT
)
1038 if (!found
|| !tsi_one_before_end_p (i
))
1041 return rexpr_location (tsi_stmt (i
), or_else
);
1044 /* Return TRUE iff EXPR (maybe recursively) has a location; see
1045 rexpr_location for the potential recursion. */
1048 rexpr_has_location (tree expr
)
1050 return rexpr_location (expr
) != UNKNOWN_LOCATION
;
1054 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1055 contain statements and have a value. Assign its value to a temporary
1056 and give it void_type_node. Return the temporary, or NULL_TREE if
1057 WRAPPER was already void. */
1060 voidify_wrapper_expr (tree wrapper
, tree temp
)
1062 tree type
= TREE_TYPE (wrapper
);
1063 if (type
&& !VOID_TYPE_P (type
))
1067 /* Set p to point to the body of the wrapper. Loop until we find
1068 something that isn't a wrapper. */
1069 for (p
= &wrapper
; p
&& *p
; )
1071 switch (TREE_CODE (*p
))
1074 TREE_SIDE_EFFECTS (*p
) = 1;
1075 TREE_TYPE (*p
) = void_type_node
;
1076 /* For a BIND_EXPR, the body is operand 1. */
1077 p
= &BIND_EXPR_BODY (*p
);
1080 case CLEANUP_POINT_EXPR
:
1081 case TRY_FINALLY_EXPR
:
1082 case TRY_CATCH_EXPR
:
1083 TREE_SIDE_EFFECTS (*p
) = 1;
1084 TREE_TYPE (*p
) = void_type_node
;
1085 p
= &TREE_OPERAND (*p
, 0);
1088 case STATEMENT_LIST
:
1090 tree_stmt_iterator i
= tsi_last (*p
);
1091 TREE_SIDE_EFFECTS (*p
) = 1;
1092 TREE_TYPE (*p
) = void_type_node
;
1093 p
= tsi_end_p (i
) ? NULL
: tsi_stmt_ptr (i
);
1098 /* Advance to the last statement. Set all container types to
1100 for (; TREE_CODE (*p
) == COMPOUND_EXPR
; p
= &TREE_OPERAND (*p
, 1))
1102 TREE_SIDE_EFFECTS (*p
) = 1;
1103 TREE_TYPE (*p
) = void_type_node
;
1107 case TRANSACTION_EXPR
:
1108 TREE_SIDE_EFFECTS (*p
) = 1;
1109 TREE_TYPE (*p
) = void_type_node
;
1110 p
= &TRANSACTION_EXPR_BODY (*p
);
1114 /* Assume that any tree upon which voidify_wrapper_expr is
1115 directly called is a wrapper, and that its body is op0. */
1118 TREE_SIDE_EFFECTS (*p
) = 1;
1119 TREE_TYPE (*p
) = void_type_node
;
1120 p
= &TREE_OPERAND (*p
, 0);
1128 if (p
== NULL
|| IS_EMPTY_STMT (*p
))
1132 /* The wrapper is on the RHS of an assignment that we're pushing
1134 gcc_assert (TREE_CODE (temp
) == INIT_EXPR
1135 || TREE_CODE (temp
) == MODIFY_EXPR
);
1136 TREE_OPERAND (temp
, 1) = *p
;
1141 temp
= create_tmp_var (type
, "retval");
1142 *p
= build2 (INIT_EXPR
, type
, temp
, *p
);
1151 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1152 a temporary through which they communicate. */
1155 build_stack_save_restore (gcall
**save
, gcall
**restore
)
1159 *save
= gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE
), 0);
1160 tmp_var
= create_tmp_var (ptr_type_node
, "saved_stack");
1161 gimple_call_set_lhs (*save
, tmp_var
);
1164 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE
),
1168 /* Generate IFN_ASAN_MARK call that poisons shadow of a for DECL variable. */
1171 build_asan_poison_call_expr (tree decl
)
1173 /* Do not poison variables that have size equal to zero. */
1174 tree unit_size
= DECL_SIZE_UNIT (decl
);
1175 if (zerop (unit_size
))
1178 tree base
= build_fold_addr_expr (decl
);
1180 return build_call_expr_internal_loc (UNKNOWN_LOCATION
, IFN_ASAN_MARK
,
1182 build_int_cst (integer_type_node
,
1187 /* Generate IFN_ASAN_MARK call that would poison or unpoison, depending
1188 on POISON flag, shadow memory of a DECL variable. The call will be
1189 put on location identified by IT iterator, where BEFORE flag drives
1190 position where the stmt will be put. */
1193 asan_poison_variable (tree decl
, bool poison
, gimple_stmt_iterator
*it
,
1196 tree unit_size
= DECL_SIZE_UNIT (decl
);
1197 tree base
= build_fold_addr_expr (decl
);
1199 /* Do not poison variables that have size equal to zero. */
1200 if (zerop (unit_size
))
1203 /* It's necessary to have all stack variables aligned to ASAN granularity
1205 if (DECL_ALIGN_UNIT (decl
) <= ASAN_SHADOW_GRANULARITY
)
1206 SET_DECL_ALIGN (decl
, BITS_PER_UNIT
* ASAN_SHADOW_GRANULARITY
);
1208 HOST_WIDE_INT flags
= poison
? ASAN_MARK_POISON
: ASAN_MARK_UNPOISON
;
1211 = gimple_build_call_internal (IFN_ASAN_MARK
, 3,
1212 build_int_cst (integer_type_node
, flags
),
1216 gsi_insert_before (it
, g
, GSI_NEW_STMT
);
1218 gsi_insert_after (it
, g
, GSI_NEW_STMT
);
1221 /* Generate IFN_ASAN_MARK internal call that depending on POISON flag
1222 either poisons or unpoisons a DECL. Created statement is appended
1223 to SEQ_P gimple sequence. */
1226 asan_poison_variable (tree decl
, bool poison
, gimple_seq
*seq_p
)
1228 gimple_stmt_iterator it
= gsi_last (*seq_p
);
1229 bool before
= false;
1234 asan_poison_variable (decl
, poison
, &it
, before
);
1237 /* Sort pair of VAR_DECLs A and B by DECL_UID. */
1240 sort_by_decl_uid (const void *a
, const void *b
)
1242 const tree
*t1
= (const tree
*)a
;
1243 const tree
*t2
= (const tree
*)b
;
1245 int uid1
= DECL_UID (*t1
);
1246 int uid2
= DECL_UID (*t2
);
1250 else if (uid1
> uid2
)
1256 /* Generate IFN_ASAN_MARK internal call for all VARIABLES
1257 depending on POISON flag. Created statement is appended
1258 to SEQ_P gimple sequence. */
1261 asan_poison_variables (hash_set
<tree
> *variables
, bool poison
, gimple_seq
*seq_p
)
1263 unsigned c
= variables
->elements ();
1267 auto_vec
<tree
> sorted_variables (c
);
1269 for (hash_set
<tree
>::iterator it
= variables
->begin ();
1270 it
!= variables
->end (); ++it
)
1271 sorted_variables
.safe_push (*it
);
1273 sorted_variables
.qsort (sort_by_decl_uid
);
1277 FOR_EACH_VEC_ELT (sorted_variables
, i
, var
)
1279 asan_poison_variable (var
, poison
, seq_p
);
1281 /* Add use_after_scope_memory attribute for the variable in order
1282 to prevent re-written into SSA. */
1283 if (!lookup_attribute (ASAN_USE_AFTER_SCOPE_ATTRIBUTE
,
1284 DECL_ATTRIBUTES (var
)))
1285 DECL_ATTRIBUTES (var
)
1286 = tree_cons (get_identifier (ASAN_USE_AFTER_SCOPE_ATTRIBUTE
),
1288 DECL_ATTRIBUTES (var
));
1292 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1294 static enum gimplify_status
1295 gimplify_bind_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1297 tree bind_expr
= *expr_p
;
1298 bool old_keep_stack
= gimplify_ctxp
->keep_stack
;
1299 bool old_save_stack
= gimplify_ctxp
->save_stack
;
1302 gimple_seq body
, cleanup
;
1304 location_t start_locus
= 0, end_locus
= 0;
1305 tree ret_clauses
= NULL
;
1307 tree temp
= voidify_wrapper_expr (bind_expr
, NULL
);
1309 /* Mark variables seen in this bind expr. */
1310 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1314 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1316 /* Mark variable as local. */
1317 if (ctx
&& ctx
->region_type
!= ORT_NONE
&& !DECL_EXTERNAL (t
)
1318 && (! DECL_SEEN_IN_BIND_EXPR_P (t
)
1319 || splay_tree_lookup (ctx
->variables
,
1320 (splay_tree_key
) t
) == NULL
))
1322 if (ctx
->region_type
== ORT_SIMD
1323 && TREE_ADDRESSABLE (t
)
1324 && !TREE_STATIC (t
))
1325 omp_add_variable (ctx
, t
, GOVD_PRIVATE
| GOVD_SEEN
);
1327 omp_add_variable (ctx
, t
, GOVD_LOCAL
| GOVD_SEEN
);
1330 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
1332 if (DECL_HARD_REGISTER (t
) && !is_global_var (t
) && cfun
)
1333 cfun
->has_local_explicit_reg_vars
= true;
1336 /* Preliminarily mark non-addressed complex variables as eligible
1337 for promotion to gimple registers. We'll transform their uses
1339 if ((TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
1340 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1341 && !TREE_THIS_VOLATILE (t
)
1342 && (VAR_P (t
) && !DECL_HARD_REGISTER (t
))
1343 && !needs_to_live_in_memory (t
))
1344 DECL_GIMPLE_REG_P (t
) = 1;
1347 bind_stmt
= gimple_build_bind (BIND_EXPR_VARS (bind_expr
), NULL
,
1348 BIND_EXPR_BLOCK (bind_expr
));
1349 gimple_push_bind_expr (bind_stmt
);
1351 gimplify_ctxp
->keep_stack
= false;
1352 gimplify_ctxp
->save_stack
= false;
1354 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1356 gimplify_stmt (&BIND_EXPR_BODY (bind_expr
), &body
);
1357 gimple_bind_set_body (bind_stmt
, body
);
1359 /* Source location wise, the cleanup code (stack_restore and clobbers)
1360 belongs to the end of the block, so propagate what we have. The
1361 stack_save operation belongs to the beginning of block, which we can
1362 infer from the bind_expr directly if the block has no explicit
1364 if (BIND_EXPR_BLOCK (bind_expr
))
1366 end_locus
= BLOCK_SOURCE_END_LOCATION (BIND_EXPR_BLOCK (bind_expr
));
1367 start_locus
= BLOCK_SOURCE_LOCATION (BIND_EXPR_BLOCK (bind_expr
));
1369 if (start_locus
== 0)
1370 start_locus
= EXPR_LOCATION (bind_expr
);
1375 /* If the code both contains VLAs and calls alloca, then we cannot reclaim
1376 the stack space allocated to the VLAs. */
1377 if (gimplify_ctxp
->save_stack
&& !gimplify_ctxp
->keep_stack
)
1379 gcall
*stack_restore
;
1381 /* Save stack on entry and restore it on exit. Add a try_finally
1382 block to achieve this. */
1383 build_stack_save_restore (&stack_save
, &stack_restore
);
1385 gimple_set_location (stack_save
, start_locus
);
1386 gimple_set_location (stack_restore
, end_locus
);
1388 gimplify_seq_add_stmt (&cleanup
, stack_restore
);
1391 /* Add clobbers for all variables that go out of scope. */
1392 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1395 && !is_global_var (t
)
1396 && DECL_CONTEXT (t
) == current_function_decl
)
1398 if (!DECL_HARD_REGISTER (t
)
1399 && !TREE_THIS_VOLATILE (t
)
1400 && !DECL_HAS_VALUE_EXPR_P (t
)
1401 /* Only care for variables that have to be in memory. Others
1402 will be rewritten into SSA names, hence moved to the
1404 && !is_gimple_reg (t
)
1405 && flag_stack_reuse
!= SR_NONE
)
1407 tree clobber
= build_clobber (TREE_TYPE (t
));
1408 gimple
*clobber_stmt
;
1409 clobber_stmt
= gimple_build_assign (t
, clobber
);
1410 gimple_set_location (clobber_stmt
, end_locus
);
1411 gimplify_seq_add_stmt (&cleanup
, clobber_stmt
);
1414 if (flag_openacc
&& oacc_declare_returns
!= NULL
)
1416 tree
*c
= oacc_declare_returns
->get (t
);
1420 OMP_CLAUSE_CHAIN (*c
) = ret_clauses
;
1424 oacc_declare_returns
->remove (t
);
1426 if (oacc_declare_returns
->elements () == 0)
1428 delete oacc_declare_returns
;
1429 oacc_declare_returns
= NULL
;
1435 if (asan_poisoned_variables
!= NULL
1436 && asan_poisoned_variables
->contains (t
))
1438 asan_poisoned_variables
->remove (t
);
1439 asan_poison_variable (t
, true, &cleanup
);
1442 if (gimplify_ctxp
->live_switch_vars
!= NULL
1443 && gimplify_ctxp
->live_switch_vars
->contains (t
))
1444 gimplify_ctxp
->live_switch_vars
->remove (t
);
1450 gimple_stmt_iterator si
= gsi_start (cleanup
);
1452 stmt
= gimple_build_omp_target (NULL
, GF_OMP_TARGET_KIND_OACC_DECLARE
,
1454 gsi_insert_seq_before_without_update (&si
, stmt
, GSI_NEW_STMT
);
1460 gimple_seq new_body
;
1463 gs
= gimple_build_try (gimple_bind_body (bind_stmt
), cleanup
,
1464 GIMPLE_TRY_FINALLY
);
1467 gimplify_seq_add_stmt (&new_body
, stack_save
);
1468 gimplify_seq_add_stmt (&new_body
, gs
);
1469 gimple_bind_set_body (bind_stmt
, new_body
);
1472 /* keep_stack propagates all the way up to the outermost BIND_EXPR. */
1473 if (!gimplify_ctxp
->keep_stack
)
1474 gimplify_ctxp
->keep_stack
= old_keep_stack
;
1475 gimplify_ctxp
->save_stack
= old_save_stack
;
1477 gimple_pop_bind_expr ();
1479 gimplify_seq_add_stmt (pre_p
, bind_stmt
);
1487 *expr_p
= NULL_TREE
;
1491 /* Maybe add early return predict statement to PRE_P sequence. */
1494 maybe_add_early_return_predict_stmt (gimple_seq
*pre_p
)
1496 /* If we are not in a conditional context, add PREDICT statement. */
1497 if (gimple_conditional_context ())
1499 gimple
*predict
= gimple_build_predict (PRED_TREE_EARLY_RETURN
,
1501 gimplify_seq_add_stmt (pre_p
, predict
);
1505 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1506 GIMPLE value, it is assigned to a new temporary and the statement is
1507 re-written to return the temporary.
1509 PRE_P points to the sequence where side effects that must happen before
1510 STMT should be stored. */
1512 static enum gimplify_status
1513 gimplify_return_expr (tree stmt
, gimple_seq
*pre_p
)
1516 tree ret_expr
= TREE_OPERAND (stmt
, 0);
1517 tree result_decl
, result
;
1519 if (ret_expr
== error_mark_node
)
1523 || TREE_CODE (ret_expr
) == RESULT_DECL
)
1525 maybe_add_early_return_predict_stmt (pre_p
);
1526 greturn
*ret
= gimple_build_return (ret_expr
);
1527 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1528 gimplify_seq_add_stmt (pre_p
, ret
);
1532 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1533 result_decl
= NULL_TREE
;
1536 result_decl
= TREE_OPERAND (ret_expr
, 0);
1538 /* See through a return by reference. */
1539 if (TREE_CODE (result_decl
) == INDIRECT_REF
)
1540 result_decl
= TREE_OPERAND (result_decl
, 0);
1542 gcc_assert ((TREE_CODE (ret_expr
) == MODIFY_EXPR
1543 || TREE_CODE (ret_expr
) == INIT_EXPR
)
1544 && TREE_CODE (result_decl
) == RESULT_DECL
);
1547 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1548 Recall that aggregate_value_p is FALSE for any aggregate type that is
1549 returned in registers. If we're returning values in registers, then
1550 we don't want to extend the lifetime of the RESULT_DECL, particularly
1551 across another call. In addition, for those aggregates for which
1552 hard_function_value generates a PARALLEL, we'll die during normal
1553 expansion of structure assignments; there's special code in expand_return
1554 to handle this case that does not exist in expand_expr. */
1557 else if (aggregate_value_p (result_decl
, TREE_TYPE (current_function_decl
)))
1559 if (TREE_CODE (DECL_SIZE (result_decl
)) != INTEGER_CST
)
1561 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl
)))
1562 gimplify_type_sizes (TREE_TYPE (result_decl
), pre_p
);
1563 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1564 should be effectively allocated by the caller, i.e. all calls to
1565 this function must be subject to the Return Slot Optimization. */
1566 gimplify_one_sizepos (&DECL_SIZE (result_decl
), pre_p
);
1567 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl
), pre_p
);
1569 result
= result_decl
;
1571 else if (gimplify_ctxp
->return_temp
)
1572 result
= gimplify_ctxp
->return_temp
;
1575 result
= create_tmp_reg (TREE_TYPE (result_decl
));
1577 /* ??? With complex control flow (usually involving abnormal edges),
1578 we can wind up warning about an uninitialized value for this. Due
1579 to how this variable is constructed and initialized, this is never
1580 true. Give up and never warn. */
1581 TREE_NO_WARNING (result
) = 1;
1583 gimplify_ctxp
->return_temp
= result
;
1586 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1587 Then gimplify the whole thing. */
1588 if (result
!= result_decl
)
1589 TREE_OPERAND (ret_expr
, 0) = result
;
1591 gimplify_and_add (TREE_OPERAND (stmt
, 0), pre_p
);
1593 maybe_add_early_return_predict_stmt (pre_p
);
1594 ret
= gimple_build_return (result
);
1595 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1596 gimplify_seq_add_stmt (pre_p
, ret
);
1601 /* Gimplify a variable-length array DECL. */
1604 gimplify_vla_decl (tree decl
, gimple_seq
*seq_p
)
1606 /* This is a variable-sized decl. Simplify its size and mark it
1607 for deferred expansion. */
1608 tree t
, addr
, ptr_type
;
1610 gimplify_one_sizepos (&DECL_SIZE (decl
), seq_p
);
1611 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl
), seq_p
);
1613 /* Don't mess with a DECL_VALUE_EXPR set by the front-end. */
1614 if (DECL_HAS_VALUE_EXPR_P (decl
))
1617 /* All occurrences of this decl in final gimplified code will be
1618 replaced by indirection. Setting DECL_VALUE_EXPR does two
1619 things: First, it lets the rest of the gimplifier know what
1620 replacement to use. Second, it lets the debug info know
1621 where to find the value. */
1622 ptr_type
= build_pointer_type (TREE_TYPE (decl
));
1623 addr
= create_tmp_var (ptr_type
, get_name (decl
));
1624 DECL_IGNORED_P (addr
) = 0;
1625 t
= build_fold_indirect_ref (addr
);
1626 TREE_THIS_NOTRAP (t
) = 1;
1627 SET_DECL_VALUE_EXPR (decl
, t
);
1628 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1630 t
= build_alloca_call_expr (DECL_SIZE_UNIT (decl
), DECL_ALIGN (decl
),
1631 max_int_size_in_bytes (TREE_TYPE (decl
)));
1632 /* The call has been built for a variable-sized object. */
1633 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
1634 t
= fold_convert (ptr_type
, t
);
1635 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
1637 gimplify_and_add (t
, seq_p
);
1640 /* A helper function to be called via walk_tree. Mark all labels under *TP
1641 as being forced. To be called for DECL_INITIAL of static variables. */
1644 force_labels_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1648 if (TREE_CODE (*tp
) == LABEL_DECL
)
1650 FORCED_LABEL (*tp
) = 1;
1651 cfun
->has_forced_label_in_static
= 1;
1657 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1658 and initialization explicit. */
1660 static enum gimplify_status
1661 gimplify_decl_expr (tree
*stmt_p
, gimple_seq
*seq_p
)
1663 tree stmt
= *stmt_p
;
1664 tree decl
= DECL_EXPR_DECL (stmt
);
1666 *stmt_p
= NULL_TREE
;
1668 if (TREE_TYPE (decl
) == error_mark_node
)
1671 if ((TREE_CODE (decl
) == TYPE_DECL
1673 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl
)))
1675 gimplify_type_sizes (TREE_TYPE (decl
), seq_p
);
1676 if (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
)
1677 gimplify_type_sizes (TREE_TYPE (TREE_TYPE (decl
)), seq_p
);
1680 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1681 in case its size expressions contain problematic nodes like CALL_EXPR. */
1682 if (TREE_CODE (decl
) == TYPE_DECL
1683 && DECL_ORIGINAL_TYPE (decl
)
1684 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl
)))
1686 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl
), seq_p
);
1687 if (TREE_CODE (DECL_ORIGINAL_TYPE (decl
)) == REFERENCE_TYPE
)
1688 gimplify_type_sizes (TREE_TYPE (DECL_ORIGINAL_TYPE (decl
)), seq_p
);
1691 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
1693 tree init
= DECL_INITIAL (decl
);
1694 bool is_vla
= false;
1696 if (TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1697 || (!TREE_STATIC (decl
)
1698 && flag_stack_check
== GENERIC_STACK_CHECK
1699 && compare_tree_int (DECL_SIZE_UNIT (decl
),
1700 STACK_CHECK_MAX_VAR_SIZE
) > 0))
1702 gimplify_vla_decl (decl
, seq_p
);
1706 if (asan_poisoned_variables
1708 && TREE_ADDRESSABLE (decl
)
1709 && !TREE_STATIC (decl
)
1710 && !DECL_HAS_VALUE_EXPR_P (decl
)
1711 && DECL_ALIGN (decl
) <= MAX_SUPPORTED_STACK_ALIGNMENT
1712 && dbg_cnt (asan_use_after_scope
)
1713 && !gimplify_omp_ctxp
)
1715 asan_poisoned_variables
->add (decl
);
1716 asan_poison_variable (decl
, false, seq_p
);
1717 if (!DECL_ARTIFICIAL (decl
) && gimplify_ctxp
->live_switch_vars
)
1718 gimplify_ctxp
->live_switch_vars
->add (decl
);
1721 /* Some front ends do not explicitly declare all anonymous
1722 artificial variables. We compensate here by declaring the
1723 variables, though it would be better if the front ends would
1724 explicitly declare them. */
1725 if (!DECL_SEEN_IN_BIND_EXPR_P (decl
)
1726 && DECL_ARTIFICIAL (decl
) && DECL_NAME (decl
) == NULL_TREE
)
1727 gimple_add_tmp_var (decl
);
1729 if (init
&& init
!= error_mark_node
)
1731 if (!TREE_STATIC (decl
))
1733 DECL_INITIAL (decl
) = NULL_TREE
;
1734 init
= build2 (INIT_EXPR
, void_type_node
, decl
, init
);
1735 gimplify_and_add (init
, seq_p
);
1739 /* We must still examine initializers for static variables
1740 as they may contain a label address. */
1741 walk_tree (&init
, force_labels_r
, NULL
, NULL
);
1748 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1749 and replacing the LOOP_EXPR with goto, but if the loop contains an
1750 EXIT_EXPR, we need to append a label for it to jump to. */
1752 static enum gimplify_status
1753 gimplify_loop_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1755 tree saved_label
= gimplify_ctxp
->exit_label
;
1756 tree start_label
= create_artificial_label (UNKNOWN_LOCATION
);
1758 gimplify_seq_add_stmt (pre_p
, gimple_build_label (start_label
));
1760 gimplify_ctxp
->exit_label
= NULL_TREE
;
1762 gimplify_and_add (LOOP_EXPR_BODY (*expr_p
), pre_p
);
1764 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (start_label
));
1766 if (gimplify_ctxp
->exit_label
)
1767 gimplify_seq_add_stmt (pre_p
,
1768 gimple_build_label (gimplify_ctxp
->exit_label
));
1770 gimplify_ctxp
->exit_label
= saved_label
;
1776 /* Gimplify a statement list onto a sequence. These may be created either
1777 by an enlightened front-end, or by shortcut_cond_expr. */
1779 static enum gimplify_status
1780 gimplify_statement_list (tree
*expr_p
, gimple_seq
*pre_p
)
1782 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
1784 tree_stmt_iterator i
= tsi_start (*expr_p
);
1786 while (!tsi_end_p (i
))
1788 gimplify_stmt (tsi_stmt_ptr (i
), pre_p
);
1801 /* Callback for walk_gimple_seq. */
1804 warn_switch_unreachable_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
1805 struct walk_stmt_info
*wi
)
1807 gimple
*stmt
= gsi_stmt (*gsi_p
);
1809 *handled_ops_p
= true;
1810 switch (gimple_code (stmt
))
1813 /* A compiler-generated cleanup or a user-written try block.
1814 If it's empty, don't dive into it--that would result in
1815 worse location info. */
1816 if (gimple_try_eval (stmt
) == NULL
)
1819 return integer_zero_node
;
1824 case GIMPLE_EH_FILTER
:
1825 case GIMPLE_TRANSACTION
:
1826 /* Walk the sub-statements. */
1827 *handled_ops_p
= false;
1831 /* Ignore these. We may generate them before declarations that
1832 are never executed. If there's something to warn about,
1833 there will be non-debug stmts too, and we'll catch those. */
1837 if (gimple_call_internal_p (stmt
, IFN_ASAN_MARK
))
1839 *handled_ops_p
= false;
1844 /* Save the first "real" statement (not a decl/lexical scope/...). */
1846 return integer_zero_node
;
1851 /* Possibly warn about unreachable statements between switch's controlling
1852 expression and the first case. SEQ is the body of a switch expression. */
1855 maybe_warn_switch_unreachable (gimple_seq seq
)
1857 if (!warn_switch_unreachable
1858 /* This warning doesn't play well with Fortran when optimizations
1860 || lang_GNU_Fortran ()
1864 struct walk_stmt_info wi
;
1865 memset (&wi
, 0, sizeof (wi
));
1866 walk_gimple_seq (seq
, warn_switch_unreachable_r
, NULL
, &wi
);
1867 gimple
*stmt
= (gimple
*) wi
.info
;
1869 if (stmt
&& gimple_code (stmt
) != GIMPLE_LABEL
)
1871 if (gimple_code (stmt
) == GIMPLE_GOTO
1872 && TREE_CODE (gimple_goto_dest (stmt
)) == LABEL_DECL
1873 && DECL_ARTIFICIAL (gimple_goto_dest (stmt
)))
1874 /* Don't warn for compiler-generated gotos. These occur
1875 in Duff's devices, for example. */;
1877 warning_at (gimple_location (stmt
), OPT_Wswitch_unreachable
,
1878 "statement will never be executed");
1883 /* A label entry that pairs label and a location. */
1890 /* Find LABEL in vector of label entries VEC. */
1892 static struct label_entry
*
1893 find_label_entry (const auto_vec
<struct label_entry
> *vec
, tree label
)
1896 struct label_entry
*l
;
1898 FOR_EACH_VEC_ELT (*vec
, i
, l
)
1899 if (l
->label
== label
)
1904 /* Return true if LABEL, a LABEL_DECL, represents a case label
1905 in a vector of labels CASES. */
1908 case_label_p (const vec
<tree
> *cases
, tree label
)
1913 FOR_EACH_VEC_ELT (*cases
, i
, l
)
1914 if (CASE_LABEL (l
) == label
)
1919 /* Find the last nondebug statement in a scope STMT. */
1922 last_stmt_in_scope (gimple
*stmt
)
1927 switch (gimple_code (stmt
))
1931 gbind
*bind
= as_a
<gbind
*> (stmt
);
1932 stmt
= gimple_seq_last_nondebug_stmt (gimple_bind_body (bind
));
1933 return last_stmt_in_scope (stmt
);
1938 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1939 stmt
= gimple_seq_last_nondebug_stmt (gimple_try_eval (try_stmt
));
1940 gimple
*last_eval
= last_stmt_in_scope (stmt
);
1941 if (gimple_stmt_may_fallthru (last_eval
)
1942 && (last_eval
== NULL
1943 || !gimple_call_internal_p (last_eval
, IFN_FALLTHROUGH
))
1944 && gimple_try_kind (try_stmt
) == GIMPLE_TRY_FINALLY
)
1946 stmt
= gimple_seq_last_nondebug_stmt (gimple_try_cleanup (try_stmt
));
1947 return last_stmt_in_scope (stmt
);
1961 /* Collect interesting labels in LABELS and return the statement preceding
1962 another case label, or a user-defined label. Store a location useful
1963 to give warnings at *PREVLOC (usually the location of the returned
1964 statement or of its surrounding scope). */
1967 collect_fallthrough_labels (gimple_stmt_iterator
*gsi_p
,
1968 auto_vec
<struct label_entry
> *labels
,
1969 location_t
*prevloc
)
1971 gimple
*prev
= NULL
;
1973 *prevloc
= UNKNOWN_LOCATION
;
1976 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_BIND
)
1978 /* Recognize the special GIMPLE_BIND added by gimplify_switch_expr,
1979 which starts on a GIMPLE_SWITCH and ends with a break label.
1980 Handle that as a single statement that can fall through. */
1981 gbind
*bind
= as_a
<gbind
*> (gsi_stmt (*gsi_p
));
1982 gimple
*first
= gimple_seq_first_stmt (gimple_bind_body (bind
));
1983 gimple
*last
= gimple_seq_last_stmt (gimple_bind_body (bind
));
1985 && gimple_code (first
) == GIMPLE_SWITCH
1986 && gimple_code (last
) == GIMPLE_LABEL
)
1988 tree label
= gimple_label_label (as_a
<glabel
*> (last
));
1989 if (SWITCH_BREAK_LABEL_P (label
))
1997 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_BIND
1998 || gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_TRY
)
2000 /* Nested scope. Only look at the last statement of
2001 the innermost scope. */
2002 location_t bind_loc
= gimple_location (gsi_stmt (*gsi_p
));
2003 gimple
*last
= last_stmt_in_scope (gsi_stmt (*gsi_p
));
2007 /* It might be a label without a location. Use the
2008 location of the scope then. */
2009 if (!gimple_has_location (prev
))
2010 *prevloc
= bind_loc
;
2016 /* Ifs are tricky. */
2017 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_COND
)
2019 gcond
*cond_stmt
= as_a
<gcond
*> (gsi_stmt (*gsi_p
));
2020 tree false_lab
= gimple_cond_false_label (cond_stmt
);
2021 location_t if_loc
= gimple_location (cond_stmt
);
2024 if (i > 1) goto <D.2259>; else goto D;
2025 we can't do much with the else-branch. */
2026 if (!DECL_ARTIFICIAL (false_lab
))
2029 /* Go on until the false label, then one step back. */
2030 for (; !gsi_end_p (*gsi_p
); gsi_next (gsi_p
))
2032 gimple
*stmt
= gsi_stmt (*gsi_p
);
2033 if (gimple_code (stmt
) == GIMPLE_LABEL
2034 && gimple_label_label (as_a
<glabel
*> (stmt
)) == false_lab
)
2038 /* Not found? Oops. */
2039 if (gsi_end_p (*gsi_p
))
2042 struct label_entry l
= { false_lab
, if_loc
};
2043 labels
->safe_push (l
);
2045 /* Go to the last statement of the then branch. */
2048 /* if (i != 0) goto <D.1759>; else goto <D.1760>;
2054 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_GOTO
2055 && !gimple_has_location (gsi_stmt (*gsi_p
)))
2057 /* Look at the statement before, it might be
2058 attribute fallthrough, in which case don't warn. */
2060 bool fallthru_before_dest
2061 = gimple_call_internal_p (gsi_stmt (*gsi_p
), IFN_FALLTHROUGH
);
2063 tree goto_dest
= gimple_goto_dest (gsi_stmt (*gsi_p
));
2064 if (!fallthru_before_dest
)
2066 struct label_entry l
= { goto_dest
, if_loc
};
2067 labels
->safe_push (l
);
2070 /* And move back. */
2074 /* Remember the last statement. Skip labels that are of no interest
2076 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_LABEL
)
2078 tree label
= gimple_label_label (as_a
<glabel
*> (gsi_stmt (*gsi_p
)));
2079 if (find_label_entry (labels
, label
))
2080 prev
= gsi_stmt (*gsi_p
);
2082 else if (gimple_call_internal_p (gsi_stmt (*gsi_p
), IFN_ASAN_MARK
))
2084 else if (!is_gimple_debug (gsi_stmt (*gsi_p
)))
2085 prev
= gsi_stmt (*gsi_p
);
2088 while (!gsi_end_p (*gsi_p
)
2089 /* Stop if we find a case or a user-defined label. */
2090 && (gimple_code (gsi_stmt (*gsi_p
)) != GIMPLE_LABEL
2091 || !gimple_has_location (gsi_stmt (*gsi_p
))));
2093 if (prev
&& gimple_has_location (prev
))
2094 *prevloc
= gimple_location (prev
);
2098 /* Return true if the switch fallthough warning should occur. LABEL is
2099 the label statement that we're falling through to. */
2102 should_warn_for_implicit_fallthrough (gimple_stmt_iterator
*gsi_p
, tree label
)
2104 gimple_stmt_iterator gsi
= *gsi_p
;
2106 /* Don't warn if the label is marked with a "falls through" comment. */
2107 if (FALLTHROUGH_LABEL_P (label
))
2110 /* Don't warn for non-case labels followed by a statement:
2115 as these are likely intentional. */
2116 if (!case_label_p (&gimplify_ctxp
->case_labels
, label
))
2119 while (!gsi_end_p (gsi
)
2120 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_LABEL
2121 && (l
= gimple_label_label (as_a
<glabel
*> (gsi_stmt (gsi
))))
2122 && !case_label_p (&gimplify_ctxp
->case_labels
, l
))
2123 gsi_next_nondebug (&gsi
);
2124 if (gsi_end_p (gsi
) || gimple_code (gsi_stmt (gsi
)) != GIMPLE_LABEL
)
2128 /* Don't warn for terminated branches, i.e. when the subsequent case labels
2129 immediately breaks. */
2132 /* Skip all immediately following labels. */
2133 while (!gsi_end_p (gsi
)
2134 && (gimple_code (gsi_stmt (gsi
)) == GIMPLE_LABEL
2135 || gimple_code (gsi_stmt (gsi
)) == GIMPLE_PREDICT
))
2136 gsi_next_nondebug (&gsi
);
2138 /* { ... something; default:; } */
2140 /* { ... something; default: break; } or
2141 { ... something; default: goto L; } */
2142 || gimple_code (gsi_stmt (gsi
)) == GIMPLE_GOTO
2143 /* { ... something; default: return; } */
2144 || gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
2150 /* Callback for walk_gimple_seq. */
2153 warn_implicit_fallthrough_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
2154 struct walk_stmt_info
*)
2156 gimple
*stmt
= gsi_stmt (*gsi_p
);
2158 *handled_ops_p
= true;
2159 switch (gimple_code (stmt
))
2164 case GIMPLE_EH_FILTER
:
2165 case GIMPLE_TRANSACTION
:
2166 /* Walk the sub-statements. */
2167 *handled_ops_p
= false;
2170 /* Find a sequence of form:
2177 and possibly warn. */
2180 /* Found a label. Skip all immediately following labels. */
2181 while (!gsi_end_p (*gsi_p
)
2182 && gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_LABEL
)
2183 gsi_next_nondebug (gsi_p
);
2185 /* There might be no more statements. */
2186 if (gsi_end_p (*gsi_p
))
2187 return integer_zero_node
;
2189 /* Vector of labels that fall through. */
2190 auto_vec
<struct label_entry
> labels
;
2192 gimple
*prev
= collect_fallthrough_labels (gsi_p
, &labels
, &prevloc
);
2194 /* There might be no more statements. */
2195 if (gsi_end_p (*gsi_p
))
2196 return integer_zero_node
;
2198 gimple
*next
= gsi_stmt (*gsi_p
);
2200 /* If what follows is a label, then we may have a fallthrough. */
2201 if (gimple_code (next
) == GIMPLE_LABEL
2202 && gimple_has_location (next
)
2203 && (label
= gimple_label_label (as_a
<glabel
*> (next
)))
2206 struct label_entry
*l
;
2207 bool warned_p
= false;
2208 auto_diagnostic_group d
;
2209 if (!should_warn_for_implicit_fallthrough (gsi_p
, label
))
2211 else if (gimple_code (prev
) == GIMPLE_LABEL
2212 && (label
= gimple_label_label (as_a
<glabel
*> (prev
)))
2213 && (l
= find_label_entry (&labels
, label
)))
2214 warned_p
= warning_at (l
->loc
, OPT_Wimplicit_fallthrough_
,
2215 "this statement may fall through");
2216 else if (!gimple_call_internal_p (prev
, IFN_FALLTHROUGH
)
2217 /* Try to be clever and don't warn when the statement
2218 can't actually fall through. */
2219 && gimple_stmt_may_fallthru (prev
)
2220 && prevloc
!= UNKNOWN_LOCATION
)
2221 warned_p
= warning_at (prevloc
,
2222 OPT_Wimplicit_fallthrough_
,
2223 "this statement may fall through");
2225 inform (gimple_location (next
), "here");
2227 /* Mark this label as processed so as to prevent multiple
2228 warnings in nested switches. */
2229 FALLTHROUGH_LABEL_P (label
) = true;
2231 /* So that next warn_implicit_fallthrough_r will start looking for
2232 a new sequence starting with this label. */
2243 /* Warn when a switch case falls through. */
2246 maybe_warn_implicit_fallthrough (gimple_seq seq
)
2248 if (!warn_implicit_fallthrough
)
2251 /* This warning is meant for C/C++/ObjC/ObjC++ only. */
2254 || lang_GNU_OBJC ()))
2257 struct walk_stmt_info wi
;
2258 memset (&wi
, 0, sizeof (wi
));
2259 walk_gimple_seq (seq
, warn_implicit_fallthrough_r
, NULL
, &wi
);
2262 /* Callback for walk_gimple_seq. */
2265 expand_FALLTHROUGH_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
2266 struct walk_stmt_info
*wi
)
2268 gimple
*stmt
= gsi_stmt (*gsi_p
);
2270 *handled_ops_p
= true;
2271 switch (gimple_code (stmt
))
2276 case GIMPLE_EH_FILTER
:
2277 case GIMPLE_TRANSACTION
:
2278 /* Walk the sub-statements. */
2279 *handled_ops_p
= false;
2282 if (gimple_call_internal_p (stmt
, IFN_FALLTHROUGH
))
2284 gsi_remove (gsi_p
, true);
2285 if (gsi_end_p (*gsi_p
))
2287 *static_cast<location_t
*>(wi
->info
) = gimple_location (stmt
);
2288 return integer_zero_node
;
2292 location_t loc
= gimple_location (stmt
);
2294 gimple_stmt_iterator gsi2
= *gsi_p
;
2295 stmt
= gsi_stmt (gsi2
);
2296 if (gimple_code (stmt
) == GIMPLE_GOTO
&& !gimple_has_location (stmt
))
2298 /* Go on until the artificial label. */
2299 tree goto_dest
= gimple_goto_dest (stmt
);
2300 for (; !gsi_end_p (gsi2
); gsi_next (&gsi2
))
2302 if (gimple_code (gsi_stmt (gsi2
)) == GIMPLE_LABEL
2303 && gimple_label_label (as_a
<glabel
*> (gsi_stmt (gsi2
)))
2308 /* Not found? Stop. */
2309 if (gsi_end_p (gsi2
))
2312 /* Look one past it. */
2316 /* We're looking for a case label or default label here. */
2317 while (!gsi_end_p (gsi2
))
2319 stmt
= gsi_stmt (gsi2
);
2320 if (gimple_code (stmt
) == GIMPLE_LABEL
)
2322 tree label
= gimple_label_label (as_a
<glabel
*> (stmt
));
2323 if (gimple_has_location (stmt
) && DECL_ARTIFICIAL (label
))
2329 else if (gimple_call_internal_p (stmt
, IFN_ASAN_MARK
))
2331 else if (!is_gimple_debug (stmt
))
2332 /* Anything else is not expected. */
2337 warning_at (loc
, 0, "attribute %<fallthrough%> not preceding "
2338 "a case label or default label");
2347 /* Expand all FALLTHROUGH () calls in SEQ. */
2350 expand_FALLTHROUGH (gimple_seq
*seq_p
)
2352 struct walk_stmt_info wi
;
2354 memset (&wi
, 0, sizeof (wi
));
2355 wi
.info
= (void *) &loc
;
2356 walk_gimple_seq_mod (seq_p
, expand_FALLTHROUGH_r
, NULL
, &wi
);
2357 if (wi
.callback_result
== integer_zero_node
)
2358 /* We've found [[fallthrough]]; at the end of a switch, which the C++
2359 standard says is ill-formed; see [dcl.attr.fallthrough]. */
2360 warning_at (loc
, 0, "attribute %<fallthrough%> not preceding "
2361 "a case label or default label");
2365 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
2368 static enum gimplify_status
2369 gimplify_switch_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2371 tree switch_expr
= *expr_p
;
2372 gimple_seq switch_body_seq
= NULL
;
2373 enum gimplify_status ret
;
2374 tree index_type
= TREE_TYPE (switch_expr
);
2375 if (index_type
== NULL_TREE
)
2376 index_type
= TREE_TYPE (SWITCH_COND (switch_expr
));
2378 ret
= gimplify_expr (&SWITCH_COND (switch_expr
), pre_p
, NULL
, is_gimple_val
,
2380 if (ret
== GS_ERROR
|| ret
== GS_UNHANDLED
)
2383 if (SWITCH_BODY (switch_expr
))
2386 vec
<tree
> saved_labels
;
2387 hash_set
<tree
> *saved_live_switch_vars
= NULL
;
2388 tree default_case
= NULL_TREE
;
2389 gswitch
*switch_stmt
;
2391 /* Save old labels, get new ones from body, then restore the old
2392 labels. Save all the things from the switch body to append after. */
2393 saved_labels
= gimplify_ctxp
->case_labels
;
2394 gimplify_ctxp
->case_labels
.create (8);
2396 /* Do not create live_switch_vars if SWITCH_BODY is not a BIND_EXPR. */
2397 saved_live_switch_vars
= gimplify_ctxp
->live_switch_vars
;
2398 tree_code body_type
= TREE_CODE (SWITCH_BODY (switch_expr
));
2399 if (body_type
== BIND_EXPR
|| body_type
== STATEMENT_LIST
)
2400 gimplify_ctxp
->live_switch_vars
= new hash_set
<tree
> (4);
2402 gimplify_ctxp
->live_switch_vars
= NULL
;
2404 bool old_in_switch_expr
= gimplify_ctxp
->in_switch_expr
;
2405 gimplify_ctxp
->in_switch_expr
= true;
2407 gimplify_stmt (&SWITCH_BODY (switch_expr
), &switch_body_seq
);
2409 gimplify_ctxp
->in_switch_expr
= old_in_switch_expr
;
2410 maybe_warn_switch_unreachable (switch_body_seq
);
2411 maybe_warn_implicit_fallthrough (switch_body_seq
);
2412 /* Only do this for the outermost GIMPLE_SWITCH. */
2413 if (!gimplify_ctxp
->in_switch_expr
)
2414 expand_FALLTHROUGH (&switch_body_seq
);
2416 labels
= gimplify_ctxp
->case_labels
;
2417 gimplify_ctxp
->case_labels
= saved_labels
;
2419 if (gimplify_ctxp
->live_switch_vars
)
2421 gcc_assert (gimplify_ctxp
->live_switch_vars
->elements () == 0);
2422 delete gimplify_ctxp
->live_switch_vars
;
2424 gimplify_ctxp
->live_switch_vars
= saved_live_switch_vars
;
2426 preprocess_case_label_vec_for_gimple (labels
, index_type
,
2429 bool add_bind
= false;
2432 glabel
*new_default
;
2435 = build_case_label (NULL_TREE
, NULL_TREE
,
2436 create_artificial_label (UNKNOWN_LOCATION
));
2437 if (old_in_switch_expr
)
2439 SWITCH_BREAK_LABEL_P (CASE_LABEL (default_case
)) = 1;
2442 new_default
= gimple_build_label (CASE_LABEL (default_case
));
2443 gimplify_seq_add_stmt (&switch_body_seq
, new_default
);
2445 else if (old_in_switch_expr
)
2447 gimple
*last
= gimple_seq_last_stmt (switch_body_seq
);
2448 if (last
&& gimple_code (last
) == GIMPLE_LABEL
)
2450 tree label
= gimple_label_label (as_a
<glabel
*> (last
));
2451 if (SWITCH_BREAK_LABEL_P (label
))
2456 switch_stmt
= gimple_build_switch (SWITCH_COND (switch_expr
),
2457 default_case
, labels
);
2458 /* For the benefit of -Wimplicit-fallthrough, if switch_body_seq
2459 ends with a GIMPLE_LABEL holding SWITCH_BREAK_LABEL_P LABEL_DECL,
2460 wrap the GIMPLE_SWITCH up to that GIMPLE_LABEL into a GIMPLE_BIND,
2461 so that we can easily find the start and end of the switch
2465 gimple_seq bind_body
= NULL
;
2466 gimplify_seq_add_stmt (&bind_body
, switch_stmt
);
2467 gimple_seq_add_seq (&bind_body
, switch_body_seq
);
2468 gbind
*bind
= gimple_build_bind (NULL_TREE
, bind_body
, NULL_TREE
);
2469 gimple_set_location (bind
, EXPR_LOCATION (switch_expr
));
2470 gimplify_seq_add_stmt (pre_p
, bind
);
2474 gimplify_seq_add_stmt (pre_p
, switch_stmt
);
2475 gimplify_seq_add_seq (pre_p
, switch_body_seq
);
2485 /* Gimplify the LABEL_EXPR pointed to by EXPR_P. */
2487 static enum gimplify_status
2488 gimplify_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2490 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p
))
2491 == current_function_decl
);
2493 tree label
= LABEL_EXPR_LABEL (*expr_p
);
2494 glabel
*label_stmt
= gimple_build_label (label
);
2495 gimple_set_location (label_stmt
, EXPR_LOCATION (*expr_p
));
2496 gimplify_seq_add_stmt (pre_p
, label_stmt
);
2498 if (lookup_attribute ("cold", DECL_ATTRIBUTES (label
)))
2499 gimple_seq_add_stmt (pre_p
, gimple_build_predict (PRED_COLD_LABEL
,
2501 else if (lookup_attribute ("hot", DECL_ATTRIBUTES (label
)))
2502 gimple_seq_add_stmt (pre_p
, gimple_build_predict (PRED_HOT_LABEL
,
2508 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
2510 static enum gimplify_status
2511 gimplify_case_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2513 struct gimplify_ctx
*ctxp
;
2516 /* Invalid programs can play Duff's Device type games with, for example,
2517 #pragma omp parallel. At least in the C front end, we don't
2518 detect such invalid branches until after gimplification, in the
2519 diagnose_omp_blocks pass. */
2520 for (ctxp
= gimplify_ctxp
; ; ctxp
= ctxp
->prev_context
)
2521 if (ctxp
->case_labels
.exists ())
2524 tree label
= CASE_LABEL (*expr_p
);
2525 label_stmt
= gimple_build_label (label
);
2526 gimple_set_location (label_stmt
, EXPR_LOCATION (*expr_p
));
2527 ctxp
->case_labels
.safe_push (*expr_p
);
2528 gimplify_seq_add_stmt (pre_p
, label_stmt
);
2530 if (lookup_attribute ("cold", DECL_ATTRIBUTES (label
)))
2531 gimple_seq_add_stmt (pre_p
, gimple_build_predict (PRED_COLD_LABEL
,
2533 else if (lookup_attribute ("hot", DECL_ATTRIBUTES (label
)))
2534 gimple_seq_add_stmt (pre_p
, gimple_build_predict (PRED_HOT_LABEL
,
2540 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
2544 build_and_jump (tree
*label_p
)
2546 if (label_p
== NULL
)
2547 /* If there's nowhere to jump, just fall through. */
2550 if (*label_p
== NULL_TREE
)
2552 tree label
= create_artificial_label (UNKNOWN_LOCATION
);
2556 return build1 (GOTO_EXPR
, void_type_node
, *label_p
);
2559 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
2560 This also involves building a label to jump to and communicating it to
2561 gimplify_loop_expr through gimplify_ctxp->exit_label. */
2563 static enum gimplify_status
2564 gimplify_exit_expr (tree
*expr_p
)
2566 tree cond
= TREE_OPERAND (*expr_p
, 0);
2569 expr
= build_and_jump (&gimplify_ctxp
->exit_label
);
2570 expr
= build3 (COND_EXPR
, void_type_node
, cond
, expr
, NULL_TREE
);
2576 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
2577 different from its canonical type, wrap the whole thing inside a
2578 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
2581 The canonical type of a COMPONENT_REF is the type of the field being
2582 referenced--unless the field is a bit-field which can be read directly
2583 in a smaller mode, in which case the canonical type is the
2584 sign-appropriate type corresponding to that mode. */
2587 canonicalize_component_ref (tree
*expr_p
)
2589 tree expr
= *expr_p
;
2592 gcc_assert (TREE_CODE (expr
) == COMPONENT_REF
);
2594 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
2595 type
= TREE_TYPE (get_unwidened (expr
, NULL_TREE
));
2597 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
2599 /* One could argue that all the stuff below is not necessary for
2600 the non-bitfield case and declare it a FE error if type
2601 adjustment would be needed. */
2602 if (TREE_TYPE (expr
) != type
)
2604 #ifdef ENABLE_TYPES_CHECKING
2605 tree old_type
= TREE_TYPE (expr
);
2609 /* We need to preserve qualifiers and propagate them from
2611 type_quals
= TYPE_QUALS (type
)
2612 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr
, 0)));
2613 if (TYPE_QUALS (type
) != type_quals
)
2614 type
= build_qualified_type (TYPE_MAIN_VARIANT (type
), type_quals
);
2616 /* Set the type of the COMPONENT_REF to the underlying type. */
2617 TREE_TYPE (expr
) = type
;
2619 #ifdef ENABLE_TYPES_CHECKING
2620 /* It is now a FE error, if the conversion from the canonical
2621 type to the original expression type is not useless. */
2622 gcc_assert (useless_type_conversion_p (old_type
, type
));
2627 /* If a NOP conversion is changing a pointer to array of foo to a pointer
2628 to foo, embed that change in the ADDR_EXPR by converting
2633 where L is the lower bound. For simplicity, only do this for constant
2635 The constraint is that the type of &array[L] is trivially convertible
2639 canonicalize_addr_expr (tree
*expr_p
)
2641 tree expr
= *expr_p
;
2642 tree addr_expr
= TREE_OPERAND (expr
, 0);
2643 tree datype
, ddatype
, pddatype
;
2645 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
2646 if (!POINTER_TYPE_P (TREE_TYPE (expr
))
2647 || TREE_CODE (addr_expr
) != ADDR_EXPR
)
2650 /* The addr_expr type should be a pointer to an array. */
2651 datype
= TREE_TYPE (TREE_TYPE (addr_expr
));
2652 if (TREE_CODE (datype
) != ARRAY_TYPE
)
2655 /* The pointer to element type shall be trivially convertible to
2656 the expression pointer type. */
2657 ddatype
= TREE_TYPE (datype
);
2658 pddatype
= build_pointer_type (ddatype
);
2659 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)),
2663 /* The lower bound and element sizes must be constant. */
2664 if (!TYPE_SIZE_UNIT (ddatype
)
2665 || TREE_CODE (TYPE_SIZE_UNIT (ddatype
)) != INTEGER_CST
2666 || !TYPE_DOMAIN (datype
) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))
2667 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))) != INTEGER_CST
)
2670 /* All checks succeeded. Build a new node to merge the cast. */
2671 *expr_p
= build4 (ARRAY_REF
, ddatype
, TREE_OPERAND (addr_expr
, 0),
2672 TYPE_MIN_VALUE (TYPE_DOMAIN (datype
)),
2673 NULL_TREE
, NULL_TREE
);
2674 *expr_p
= build1 (ADDR_EXPR
, pddatype
, *expr_p
);
2676 /* We can have stripped a required restrict qualifier above. */
2677 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
2678 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
2681 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
2682 underneath as appropriate. */
2684 static enum gimplify_status
2685 gimplify_conversion (tree
*expr_p
)
2687 location_t loc
= EXPR_LOCATION (*expr_p
);
2688 gcc_assert (CONVERT_EXPR_P (*expr_p
));
2690 /* Then strip away all but the outermost conversion. */
2691 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p
, 0));
2693 /* And remove the outermost conversion if it's useless. */
2694 if (tree_ssa_useless_type_conversion (*expr_p
))
2695 *expr_p
= TREE_OPERAND (*expr_p
, 0);
2697 /* If we still have a conversion at the toplevel,
2698 then canonicalize some constructs. */
2699 if (CONVERT_EXPR_P (*expr_p
))
2701 tree sub
= TREE_OPERAND (*expr_p
, 0);
2703 /* If a NOP conversion is changing the type of a COMPONENT_REF
2704 expression, then canonicalize its type now in order to expose more
2705 redundant conversions. */
2706 if (TREE_CODE (sub
) == COMPONENT_REF
)
2707 canonicalize_component_ref (&TREE_OPERAND (*expr_p
, 0));
2709 /* If a NOP conversion is changing a pointer to array of foo
2710 to a pointer to foo, embed that change in the ADDR_EXPR. */
2711 else if (TREE_CODE (sub
) == ADDR_EXPR
)
2712 canonicalize_addr_expr (expr_p
);
2715 /* If we have a conversion to a non-register type force the
2716 use of a VIEW_CONVERT_EXPR instead. */
2717 if (CONVERT_EXPR_P (*expr_p
) && !is_gimple_reg_type (TREE_TYPE (*expr_p
)))
2718 *expr_p
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (*expr_p
),
2719 TREE_OPERAND (*expr_p
, 0));
2721 /* Canonicalize CONVERT_EXPR to NOP_EXPR. */
2722 if (TREE_CODE (*expr_p
) == CONVERT_EXPR
)
2723 TREE_SET_CODE (*expr_p
, NOP_EXPR
);
2728 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
2729 DECL_VALUE_EXPR, and it's worth re-examining things. */
2731 static enum gimplify_status
2732 gimplify_var_or_parm_decl (tree
*expr_p
)
2734 tree decl
= *expr_p
;
2736 /* ??? If this is a local variable, and it has not been seen in any
2737 outer BIND_EXPR, then it's probably the result of a duplicate
2738 declaration, for which we've already issued an error. It would
2739 be really nice if the front end wouldn't leak these at all.
2740 Currently the only known culprit is C++ destructors, as seen
2741 in g++.old-deja/g++.jason/binding.C. */
2743 && !DECL_SEEN_IN_BIND_EXPR_P (decl
)
2744 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)
2745 && decl_function_context (decl
) == current_function_decl
)
2747 gcc_assert (seen_error ());
2751 /* When within an OMP context, notice uses of variables. */
2752 if (gimplify_omp_ctxp
&& omp_notice_variable (gimplify_omp_ctxp
, decl
, true))
2755 /* If the decl is an alias for another expression, substitute it now. */
2756 if (DECL_HAS_VALUE_EXPR_P (decl
))
2758 *expr_p
= unshare_expr (DECL_VALUE_EXPR (decl
));
2765 /* Recalculate the value of the TREE_SIDE_EFFECTS flag for T. */
2768 recalculate_side_effects (tree t
)
2770 enum tree_code code
= TREE_CODE (t
);
2771 int len
= TREE_OPERAND_LENGTH (t
);
2774 switch (TREE_CODE_CLASS (code
))
2776 case tcc_expression
:
2782 case PREDECREMENT_EXPR
:
2783 case PREINCREMENT_EXPR
:
2784 case POSTDECREMENT_EXPR
:
2785 case POSTINCREMENT_EXPR
:
2786 /* All of these have side-effects, no matter what their
2795 case tcc_comparison
: /* a comparison expression */
2796 case tcc_unary
: /* a unary arithmetic expression */
2797 case tcc_binary
: /* a binary arithmetic expression */
2798 case tcc_reference
: /* a reference */
2799 case tcc_vl_exp
: /* a function call */
2800 TREE_SIDE_EFFECTS (t
) = TREE_THIS_VOLATILE (t
);
2801 for (i
= 0; i
< len
; ++i
)
2803 tree op
= TREE_OPERAND (t
, i
);
2804 if (op
&& TREE_SIDE_EFFECTS (op
))
2805 TREE_SIDE_EFFECTS (t
) = 1;
2810 /* No side-effects. */
2818 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
2822 : min_lval '[' val ']'
2824 | compound_lval '[' val ']'
2825 | compound_lval '.' ID
2827 This is not part of the original SIMPLE definition, which separates
2828 array and member references, but it seems reasonable to handle them
2829 together. Also, this way we don't run into problems with union
2830 aliasing; gcc requires that for accesses through a union to alias, the
2831 union reference must be explicit, which was not always the case when we
2832 were splitting up array and member refs.
2834 PRE_P points to the sequence where side effects that must happen before
2835 *EXPR_P should be stored.
2837 POST_P points to the sequence where side effects that must happen after
2838 *EXPR_P should be stored. */
2840 static enum gimplify_status
2841 gimplify_compound_lval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2842 fallback_t fallback
)
2845 enum gimplify_status ret
= GS_ALL_DONE
, tret
;
2847 location_t loc
= EXPR_LOCATION (*expr_p
);
2848 tree expr
= *expr_p
;
2850 /* Create a stack of the subexpressions so later we can walk them in
2851 order from inner to outer. */
2852 auto_vec
<tree
, 10> expr_stack
;
2854 /* We can handle anything that get_inner_reference can deal with. */
2855 for (p
= expr_p
; ; p
= &TREE_OPERAND (*p
, 0))
2858 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2859 if (TREE_CODE (*p
) == INDIRECT_REF
)
2860 *p
= fold_indirect_ref_loc (loc
, *p
);
2862 if (handled_component_p (*p
))
2864 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2865 additional COMPONENT_REFs. */
2866 else if ((VAR_P (*p
) || TREE_CODE (*p
) == PARM_DECL
)
2867 && gimplify_var_or_parm_decl (p
) == GS_OK
)
2872 expr_stack
.safe_push (*p
);
2875 gcc_assert (expr_stack
.length ());
2877 /* Now EXPR_STACK is a stack of pointers to all the refs we've
2878 walked through and P points to the innermost expression.
2880 Java requires that we elaborated nodes in source order. That
2881 means we must gimplify the inner expression followed by each of
2882 the indices, in order. But we can't gimplify the inner
2883 expression until we deal with any variable bounds, sizes, or
2884 positions in order to deal with PLACEHOLDER_EXPRs.
2886 So we do this in three steps. First we deal with the annotations
2887 for any variables in the components, then we gimplify the base,
2888 then we gimplify any indices, from left to right. */
2889 for (i
= expr_stack
.length () - 1; i
>= 0; i
--)
2891 tree t
= expr_stack
[i
];
2893 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2895 /* Gimplify the low bound and element type size and put them into
2896 the ARRAY_REF. If these values are set, they have already been
2898 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2900 tree low
= unshare_expr (array_ref_low_bound (t
));
2901 if (!is_gimple_min_invariant (low
))
2903 TREE_OPERAND (t
, 2) = low
;
2904 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2905 post_p
, is_gimple_reg
,
2907 ret
= MIN (ret
, tret
);
2912 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2913 is_gimple_reg
, fb_rvalue
);
2914 ret
= MIN (ret
, tret
);
2917 if (TREE_OPERAND (t
, 3) == NULL_TREE
)
2919 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0)));
2920 tree elmt_size
= unshare_expr (array_ref_element_size (t
));
2921 tree factor
= size_int (TYPE_ALIGN_UNIT (elmt_type
));
2923 /* Divide the element size by the alignment of the element
2926 = size_binop_loc (loc
, EXACT_DIV_EXPR
, elmt_size
, factor
);
2928 if (!is_gimple_min_invariant (elmt_size
))
2930 TREE_OPERAND (t
, 3) = elmt_size
;
2931 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
,
2932 post_p
, is_gimple_reg
,
2934 ret
= MIN (ret
, tret
);
2939 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
, post_p
,
2940 is_gimple_reg
, fb_rvalue
);
2941 ret
= MIN (ret
, tret
);
2944 else if (TREE_CODE (t
) == COMPONENT_REF
)
2946 /* Set the field offset into T and gimplify it. */
2947 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2949 tree offset
= unshare_expr (component_ref_field_offset (t
));
2950 tree field
= TREE_OPERAND (t
, 1);
2952 = size_int (DECL_OFFSET_ALIGN (field
) / BITS_PER_UNIT
);
2954 /* Divide the offset by its alignment. */
2955 offset
= size_binop_loc (loc
, EXACT_DIV_EXPR
, offset
, factor
);
2957 if (!is_gimple_min_invariant (offset
))
2959 TREE_OPERAND (t
, 2) = offset
;
2960 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2961 post_p
, is_gimple_reg
,
2963 ret
= MIN (ret
, tret
);
2968 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2969 is_gimple_reg
, fb_rvalue
);
2970 ret
= MIN (ret
, tret
);
2975 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2976 so as to match the min_lval predicate. Failure to do so may result
2977 in the creation of large aggregate temporaries. */
2978 tret
= gimplify_expr (p
, pre_p
, post_p
, is_gimple_min_lval
,
2979 fallback
| fb_lvalue
);
2980 ret
= MIN (ret
, tret
);
2982 /* And finally, the indices and operands of ARRAY_REF. During this
2983 loop we also remove any useless conversions. */
2984 for (; expr_stack
.length () > 0; )
2986 tree t
= expr_stack
.pop ();
2988 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2990 /* Gimplify the dimension. */
2991 if (!is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
2993 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2994 is_gimple_val
, fb_rvalue
);
2995 ret
= MIN (ret
, tret
);
2999 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t
, 0));
3001 /* The innermost expression P may have originally had
3002 TREE_SIDE_EFFECTS set which would have caused all the outer
3003 expressions in *EXPR_P leading to P to also have had
3004 TREE_SIDE_EFFECTS set. */
3005 recalculate_side_effects (t
);
3008 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
3009 if ((fallback
& fb_rvalue
) && TREE_CODE (*expr_p
) == COMPONENT_REF
)
3011 canonicalize_component_ref (expr_p
);
3014 expr_stack
.release ();
3016 gcc_assert (*expr_p
== expr
|| ret
!= GS_ALL_DONE
);
3021 /* Gimplify the self modifying expression pointed to by EXPR_P
3024 PRE_P points to the list where side effects that must happen before
3025 *EXPR_P should be stored.
3027 POST_P points to the list where side effects that must happen after
3028 *EXPR_P should be stored.
3030 WANT_VALUE is nonzero iff we want to use the value of this expression
3031 in another expression.
3033 ARITH_TYPE is the type the computation should be performed in. */
3035 enum gimplify_status
3036 gimplify_self_mod_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3037 bool want_value
, tree arith_type
)
3039 enum tree_code code
;
3040 tree lhs
, lvalue
, rhs
, t1
;
3041 gimple_seq post
= NULL
, *orig_post_p
= post_p
;
3043 enum tree_code arith_code
;
3044 enum gimplify_status ret
;
3045 location_t loc
= EXPR_LOCATION (*expr_p
);
3047 code
= TREE_CODE (*expr_p
);
3049 gcc_assert (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
3050 || code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
);
3052 /* Prefix or postfix? */
3053 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
3054 /* Faster to treat as prefix if result is not used. */
3055 postfix
= want_value
;
3059 /* For postfix, make sure the inner expression's post side effects
3060 are executed after side effects from this expression. */
3064 /* Add or subtract? */
3065 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
3066 arith_code
= PLUS_EXPR
;
3068 arith_code
= MINUS_EXPR
;
3070 /* Gimplify the LHS into a GIMPLE lvalue. */
3071 lvalue
= TREE_OPERAND (*expr_p
, 0);
3072 ret
= gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
3073 if (ret
== GS_ERROR
)
3076 /* Extract the operands to the arithmetic operation. */
3078 rhs
= TREE_OPERAND (*expr_p
, 1);
3080 /* For postfix operator, we evaluate the LHS to an rvalue and then use
3081 that as the result value and in the postqueue operation. */
3084 ret
= gimplify_expr (&lhs
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
3085 if (ret
== GS_ERROR
)
3088 lhs
= get_initialized_tmp_var (lhs
, pre_p
, NULL
);
3091 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
3092 if (POINTER_TYPE_P (TREE_TYPE (lhs
)))
3094 rhs
= convert_to_ptrofftype_loc (loc
, rhs
);
3095 if (arith_code
== MINUS_EXPR
)
3096 rhs
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
3097 t1
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (*expr_p
), lhs
, rhs
);
3100 t1
= fold_convert (TREE_TYPE (*expr_p
),
3101 fold_build2 (arith_code
, arith_type
,
3102 fold_convert (arith_type
, lhs
),
3103 fold_convert (arith_type
, rhs
)));
3107 gimplify_assign (lvalue
, t1
, pre_p
);
3108 gimplify_seq_add_seq (orig_post_p
, post
);
3114 *expr_p
= build2 (MODIFY_EXPR
, TREE_TYPE (lvalue
), lvalue
, t1
);
3119 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
3122 maybe_with_size_expr (tree
*expr_p
)
3124 tree expr
= *expr_p
;
3125 tree type
= TREE_TYPE (expr
);
3128 /* If we've already wrapped this or the type is error_mark_node, we can't do
3130 if (TREE_CODE (expr
) == WITH_SIZE_EXPR
3131 || type
== error_mark_node
)
3134 /* If the size isn't known or is a constant, we have nothing to do. */
3135 size
= TYPE_SIZE_UNIT (type
);
3136 if (!size
|| poly_int_tree_p (size
))
3139 /* Otherwise, make a WITH_SIZE_EXPR. */
3140 size
= unshare_expr (size
);
3141 size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (size
, expr
);
3142 *expr_p
= build2 (WITH_SIZE_EXPR
, type
, expr
, size
);
3145 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
3146 Store any side-effects in PRE_P. CALL_LOCATION is the location of
3147 the CALL_EXPR. If ALLOW_SSA is set the actual parameter may be
3148 gimplified to an SSA name. */
3150 enum gimplify_status
3151 gimplify_arg (tree
*arg_p
, gimple_seq
*pre_p
, location_t call_location
,
3154 bool (*test
) (tree
);
3157 /* In general, we allow lvalues for function arguments to avoid
3158 extra overhead of copying large aggregates out of even larger
3159 aggregates into temporaries only to copy the temporaries to
3160 the argument list. Make optimizers happy by pulling out to
3161 temporaries those types that fit in registers. */
3162 if (is_gimple_reg_type (TREE_TYPE (*arg_p
)))
3163 test
= is_gimple_val
, fb
= fb_rvalue
;
3166 test
= is_gimple_lvalue
, fb
= fb_either
;
3167 /* Also strip a TARGET_EXPR that would force an extra copy. */
3168 if (TREE_CODE (*arg_p
) == TARGET_EXPR
)
3170 tree init
= TARGET_EXPR_INITIAL (*arg_p
);
3172 && !VOID_TYPE_P (TREE_TYPE (init
)))
3177 /* If this is a variable sized type, we must remember the size. */
3178 maybe_with_size_expr (arg_p
);
3180 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
3181 /* Make sure arguments have the same location as the function call
3183 protected_set_expr_location (*arg_p
, call_location
);
3185 /* There is a sequence point before a function call. Side effects in
3186 the argument list must occur before the actual call. So, when
3187 gimplifying arguments, force gimplify_expr to use an internal
3188 post queue which is then appended to the end of PRE_P. */
3189 return gimplify_expr (arg_p
, pre_p
, NULL
, test
, fb
, allow_ssa
);
3192 /* Don't fold inside offloading or taskreg regions: it can break code by
3193 adding decl references that weren't in the source. We'll do it during
3194 omplower pass instead. */
3197 maybe_fold_stmt (gimple_stmt_iterator
*gsi
)
3199 struct gimplify_omp_ctx
*ctx
;
3200 for (ctx
= gimplify_omp_ctxp
; ctx
; ctx
= ctx
->outer_context
)
3201 if ((ctx
->region_type
& (ORT_TARGET
| ORT_PARALLEL
| ORT_TASK
)) != 0)
3203 else if ((ctx
->region_type
& ORT_HOST_TEAMS
) == ORT_HOST_TEAMS
)
3205 /* Delay folding of builtins until the IL is in consistent state
3206 so the diagnostic machinery can do a better job. */
3207 if (gimple_call_builtin_p (gsi_stmt (*gsi
)))
3209 return fold_stmt (gsi
);
3212 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
3213 WANT_VALUE is true if the result of the call is desired. */
3215 static enum gimplify_status
3216 gimplify_call_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
3218 tree fndecl
, parms
, p
, fnptrtype
;
3219 enum gimplify_status ret
;
3222 bool builtin_va_start_p
= false;
3223 location_t loc
= EXPR_LOCATION (*expr_p
);
3225 gcc_assert (TREE_CODE (*expr_p
) == CALL_EXPR
);
3227 /* For reliable diagnostics during inlining, it is necessary that
3228 every call_expr be annotated with file and line. */
3229 if (! EXPR_HAS_LOCATION (*expr_p
))
3230 SET_EXPR_LOCATION (*expr_p
, input_location
);
3232 /* Gimplify internal functions created in the FEs. */
3233 if (CALL_EXPR_FN (*expr_p
) == NULL_TREE
)
3238 nargs
= call_expr_nargs (*expr_p
);
3239 enum internal_fn ifn
= CALL_EXPR_IFN (*expr_p
);
3240 auto_vec
<tree
> vargs (nargs
);
3242 for (i
= 0; i
< nargs
; i
++)
3244 gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
3245 EXPR_LOCATION (*expr_p
));
3246 vargs
.quick_push (CALL_EXPR_ARG (*expr_p
, i
));
3249 gcall
*call
= gimple_build_call_internal_vec (ifn
, vargs
);
3250 gimple_call_set_nothrow (call
, TREE_NOTHROW (*expr_p
));
3251 gimplify_seq_add_stmt (pre_p
, call
);
3255 /* This may be a call to a builtin function.
3257 Builtin function calls may be transformed into different
3258 (and more efficient) builtin function calls under certain
3259 circumstances. Unfortunately, gimplification can muck things
3260 up enough that the builtin expanders are not aware that certain
3261 transformations are still valid.
3263 So we attempt transformation/gimplification of the call before
3264 we gimplify the CALL_EXPR. At this time we do not manage to
3265 transform all calls in the same manner as the expanders do, but
3266 we do transform most of them. */
3267 fndecl
= get_callee_fndecl (*expr_p
);
3268 if (fndecl
&& fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
3269 switch (DECL_FUNCTION_CODE (fndecl
))
3271 CASE_BUILT_IN_ALLOCA
:
3272 /* If the call has been built for a variable-sized object, then we
3273 want to restore the stack level when the enclosing BIND_EXPR is
3274 exited to reclaim the allocated space; otherwise, we precisely
3275 need to do the opposite and preserve the latest stack level. */
3276 if (CALL_ALLOCA_FOR_VAR_P (*expr_p
))
3277 gimplify_ctxp
->save_stack
= true;
3279 gimplify_ctxp
->keep_stack
= true;
3282 case BUILT_IN_VA_START
:
3284 builtin_va_start_p
= TRUE
;
3285 if (call_expr_nargs (*expr_p
) < 2)
3287 error ("too few arguments to function %<va_start%>");
3288 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
3292 if (fold_builtin_next_arg (*expr_p
, true))
3294 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
3303 if (fndecl
&& fndecl_built_in_p (fndecl
))
3305 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
3306 if (new_tree
&& new_tree
!= *expr_p
)
3308 /* There was a transformation of this call which computes the
3309 same value, but in a more efficient way. Return and try
3316 /* Remember the original function pointer type. */
3317 fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*expr_p
));
3319 /* There is a sequence point before the call, so any side effects in
3320 the calling expression must occur before the actual call. Force
3321 gimplify_expr to use an internal post queue. */
3322 ret
= gimplify_expr (&CALL_EXPR_FN (*expr_p
), pre_p
, NULL
,
3323 is_gimple_call_addr
, fb_rvalue
);
3325 nargs
= call_expr_nargs (*expr_p
);
3327 /* Get argument types for verification. */
3328 fndecl
= get_callee_fndecl (*expr_p
);
3331 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
3333 parms
= TYPE_ARG_TYPES (TREE_TYPE (fnptrtype
));
3335 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
3336 p
= DECL_ARGUMENTS (fndecl
);
3341 for (i
= 0; i
< nargs
&& p
; i
++, p
= TREE_CHAIN (p
))
3344 /* If the last argument is __builtin_va_arg_pack () and it is not
3345 passed as a named argument, decrease the number of CALL_EXPR
3346 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
3349 && TREE_CODE (CALL_EXPR_ARG (*expr_p
, nargs
- 1)) == CALL_EXPR
)
3351 tree last_arg
= CALL_EXPR_ARG (*expr_p
, nargs
- 1);
3352 tree last_arg_fndecl
= get_callee_fndecl (last_arg
);
3355 && fndecl_built_in_p (last_arg_fndecl
, BUILT_IN_VA_ARG_PACK
))
3357 tree call
= *expr_p
;
3360 *expr_p
= build_call_array_loc (loc
, TREE_TYPE (call
),
3361 CALL_EXPR_FN (call
),
3362 nargs
, CALL_EXPR_ARGP (call
));
3364 /* Copy all CALL_EXPR flags, location and block, except
3365 CALL_EXPR_VA_ARG_PACK flag. */
3366 CALL_EXPR_STATIC_CHAIN (*expr_p
) = CALL_EXPR_STATIC_CHAIN (call
);
3367 CALL_EXPR_TAILCALL (*expr_p
) = CALL_EXPR_TAILCALL (call
);
3368 CALL_EXPR_RETURN_SLOT_OPT (*expr_p
)
3369 = CALL_EXPR_RETURN_SLOT_OPT (call
);
3370 CALL_FROM_THUNK_P (*expr_p
) = CALL_FROM_THUNK_P (call
);
3371 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (call
));
3373 /* Set CALL_EXPR_VA_ARG_PACK. */
3374 CALL_EXPR_VA_ARG_PACK (*expr_p
) = 1;
3378 /* If the call returns twice then after building the CFG the call
3379 argument computations will no longer dominate the call because
3380 we add an abnormal incoming edge to the call. So do not use SSA
3382 bool returns_twice
= call_expr_flags (*expr_p
) & ECF_RETURNS_TWICE
;
3384 /* Gimplify the function arguments. */
3387 for (i
= (PUSH_ARGS_REVERSED
? nargs
- 1 : 0);
3388 PUSH_ARGS_REVERSED
? i
>= 0 : i
< nargs
;
3389 PUSH_ARGS_REVERSED
? i
-- : i
++)
3391 enum gimplify_status t
;
3393 /* Avoid gimplifying the second argument to va_start, which needs to
3394 be the plain PARM_DECL. */
3395 if ((i
!= 1) || !builtin_va_start_p
)
3397 t
= gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
3398 EXPR_LOCATION (*expr_p
), ! returns_twice
);
3406 /* Gimplify the static chain. */
3407 if (CALL_EXPR_STATIC_CHAIN (*expr_p
))
3409 if (fndecl
&& !DECL_STATIC_CHAIN (fndecl
))
3410 CALL_EXPR_STATIC_CHAIN (*expr_p
) = NULL
;
3413 enum gimplify_status t
;
3414 t
= gimplify_arg (&CALL_EXPR_STATIC_CHAIN (*expr_p
), pre_p
,
3415 EXPR_LOCATION (*expr_p
), ! returns_twice
);
3421 /* Verify the function result. */
3422 if (want_value
&& fndecl
3423 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype
))))
3425 error_at (loc
, "using result of function returning %<void%>");
3429 /* Try this again in case gimplification exposed something. */
3430 if (ret
!= GS_ERROR
)
3432 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
3434 if (new_tree
&& new_tree
!= *expr_p
)
3436 /* There was a transformation of this call which computes the
3437 same value, but in a more efficient way. Return and try
3445 *expr_p
= error_mark_node
;
3449 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
3450 decl. This allows us to eliminate redundant or useless
3451 calls to "const" functions. */
3452 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
3454 int flags
= call_expr_flags (*expr_p
);
3455 if (flags
& (ECF_CONST
| ECF_PURE
)
3456 /* An infinite loop is considered a side effect. */
3457 && !(flags
& (ECF_LOOPING_CONST_OR_PURE
)))
3458 TREE_SIDE_EFFECTS (*expr_p
) = 0;
3461 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
3462 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
3463 form and delegate the creation of a GIMPLE_CALL to
3464 gimplify_modify_expr. This is always possible because when
3465 WANT_VALUE is true, the caller wants the result of this call into
3466 a temporary, which means that we will emit an INIT_EXPR in
3467 internal_get_tmp_var which will then be handled by
3468 gimplify_modify_expr. */
3471 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
3472 have to do is replicate it as a GIMPLE_CALL tuple. */
3473 gimple_stmt_iterator gsi
;
3474 call
= gimple_build_call_from_tree (*expr_p
, fnptrtype
);
3475 notice_special_calls (call
);
3476 gimplify_seq_add_stmt (pre_p
, call
);
3477 gsi
= gsi_last (*pre_p
);
3478 maybe_fold_stmt (&gsi
);
3479 *expr_p
= NULL_TREE
;
3482 /* Remember the original function type. */
3483 CALL_EXPR_FN (*expr_p
) = build1 (NOP_EXPR
, fnptrtype
,
3484 CALL_EXPR_FN (*expr_p
));
3489 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
3490 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
3492 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
3493 condition is true or false, respectively. If null, we should generate
3494 our own to skip over the evaluation of this specific expression.
3496 LOCUS is the source location of the COND_EXPR.
3498 This function is the tree equivalent of do_jump.
3500 shortcut_cond_r should only be called by shortcut_cond_expr. */
3503 shortcut_cond_r (tree pred
, tree
*true_label_p
, tree
*false_label_p
,
3506 tree local_label
= NULL_TREE
;
3507 tree t
, expr
= NULL
;
3509 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
3510 retain the shortcut semantics. Just insert the gotos here;
3511 shortcut_cond_expr will append the real blocks later. */
3512 if (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
3514 location_t new_locus
;
3516 /* Turn if (a && b) into
3518 if (a); else goto no;
3519 if (b) goto yes; else goto no;
3522 if (false_label_p
== NULL
)
3523 false_label_p
= &local_label
;
3525 /* Keep the original source location on the first 'if'. */
3526 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), NULL
, false_label_p
, locus
);
3527 append_to_statement_list (t
, &expr
);
3529 /* Set the source location of the && on the second 'if'. */
3530 new_locus
= rexpr_location (pred
, locus
);
3531 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
3533 append_to_statement_list (t
, &expr
);
3535 else if (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
3537 location_t new_locus
;
3539 /* Turn if (a || b) into
3542 if (b) goto yes; else goto no;
3545 if (true_label_p
== NULL
)
3546 true_label_p
= &local_label
;
3548 /* Keep the original source location on the first 'if'. */
3549 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), true_label_p
, NULL
, locus
);
3550 append_to_statement_list (t
, &expr
);
3552 /* Set the source location of the || on the second 'if'. */
3553 new_locus
= rexpr_location (pred
, locus
);
3554 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
3556 append_to_statement_list (t
, &expr
);
3558 else if (TREE_CODE (pred
) == COND_EXPR
3559 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 1)))
3560 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 2))))
3562 location_t new_locus
;
3564 /* As long as we're messing with gotos, turn if (a ? b : c) into
3566 if (b) goto yes; else goto no;
3568 if (c) goto yes; else goto no;
3570 Don't do this if one of the arms has void type, which can happen
3571 in C++ when the arm is throw. */
3573 /* Keep the original source location on the first 'if'. Set the source
3574 location of the ? on the second 'if'. */
3575 new_locus
= rexpr_location (pred
, locus
);
3576 expr
= build3 (COND_EXPR
, void_type_node
, TREE_OPERAND (pred
, 0),
3577 shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
,
3578 false_label_p
, locus
),
3579 shortcut_cond_r (TREE_OPERAND (pred
, 2), true_label_p
,
3580 false_label_p
, new_locus
));
3584 expr
= build3 (COND_EXPR
, void_type_node
, pred
,
3585 build_and_jump (true_label_p
),
3586 build_and_jump (false_label_p
));
3587 SET_EXPR_LOCATION (expr
, locus
);
3592 t
= build1 (LABEL_EXPR
, void_type_node
, local_label
);
3593 append_to_statement_list (t
, &expr
);
3599 /* If EXPR is a GOTO_EXPR, return it. If it is a STATEMENT_LIST, skip
3600 any of its leading DEBUG_BEGIN_STMTS and recurse on the subsequent
3601 statement, if it is the last one. Otherwise, return NULL. */
3604 find_goto (tree expr
)
3609 if (TREE_CODE (expr
) == GOTO_EXPR
)
3612 if (TREE_CODE (expr
) != STATEMENT_LIST
)
3615 tree_stmt_iterator i
= tsi_start (expr
);
3617 while (!tsi_end_p (i
) && TREE_CODE (tsi_stmt (i
)) == DEBUG_BEGIN_STMT
)
3620 if (!tsi_one_before_end_p (i
))
3623 return find_goto (tsi_stmt (i
));
3626 /* Same as find_goto, except that it returns NULL if the destination
3627 is not a LABEL_DECL. */
3630 find_goto_label (tree expr
)
3632 tree dest
= find_goto (expr
);
3633 if (dest
&& TREE_CODE (GOTO_DESTINATION (dest
)) == LABEL_DECL
)
3638 /* Given a conditional expression EXPR with short-circuit boolean
3639 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
3640 predicate apart into the equivalent sequence of conditionals. */
3643 shortcut_cond_expr (tree expr
)
3645 tree pred
= TREE_OPERAND (expr
, 0);
3646 tree then_
= TREE_OPERAND (expr
, 1);
3647 tree else_
= TREE_OPERAND (expr
, 2);
3648 tree true_label
, false_label
, end_label
, t
;
3650 tree
*false_label_p
;
3651 bool emit_end
, emit_false
, jump_over_else
;
3652 bool then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
3653 bool else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
3655 /* First do simple transformations. */
3658 /* If there is no 'else', turn
3661 if (a) if (b) then c. */
3662 while (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
3664 /* Keep the original source location on the first 'if'. */
3665 location_t locus
= EXPR_LOC_OR_LOC (expr
, input_location
);
3666 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
3667 /* Set the source location of the && on the second 'if'. */
3668 if (rexpr_has_location (pred
))
3669 SET_EXPR_LOCATION (expr
, rexpr_location (pred
));
3670 then_
= shortcut_cond_expr (expr
);
3671 then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
3672 pred
= TREE_OPERAND (pred
, 0);
3673 expr
= build3 (COND_EXPR
, void_type_node
, pred
, then_
, NULL_TREE
);
3674 SET_EXPR_LOCATION (expr
, locus
);
3680 /* If there is no 'then', turn
3683 if (a); else if (b); else d. */
3684 while (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
3686 /* Keep the original source location on the first 'if'. */
3687 location_t locus
= EXPR_LOC_OR_LOC (expr
, input_location
);
3688 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
3689 /* Set the source location of the || on the second 'if'. */
3690 if (rexpr_has_location (pred
))
3691 SET_EXPR_LOCATION (expr
, rexpr_location (pred
));
3692 else_
= shortcut_cond_expr (expr
);
3693 else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
3694 pred
= TREE_OPERAND (pred
, 0);
3695 expr
= build3 (COND_EXPR
, void_type_node
, pred
, NULL_TREE
, else_
);
3696 SET_EXPR_LOCATION (expr
, locus
);
3700 /* If we're done, great. */
3701 if (TREE_CODE (pred
) != TRUTH_ANDIF_EXPR
3702 && TREE_CODE (pred
) != TRUTH_ORIF_EXPR
)
3705 /* Otherwise we need to mess with gotos. Change
3708 if (a); else goto no;
3711 and recursively gimplify the condition. */
3713 true_label
= false_label
= end_label
= NULL_TREE
;
3715 /* If our arms just jump somewhere, hijack those labels so we don't
3716 generate jumps to jumps. */
3718 if (tree then_goto
= find_goto_label (then_
))
3720 true_label
= GOTO_DESTINATION (then_goto
);
3725 if (tree else_goto
= find_goto_label (else_
))
3727 false_label
= GOTO_DESTINATION (else_goto
);
3732 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
3734 true_label_p
= &true_label
;
3736 true_label_p
= NULL
;
3738 /* The 'else' branch also needs a label if it contains interesting code. */
3739 if (false_label
|| else_se
)
3740 false_label_p
= &false_label
;
3742 false_label_p
= NULL
;
3744 /* If there was nothing else in our arms, just forward the label(s). */
3745 if (!then_se
&& !else_se
)
3746 return shortcut_cond_r (pred
, true_label_p
, false_label_p
,
3747 EXPR_LOC_OR_LOC (expr
, input_location
));
3749 /* If our last subexpression already has a terminal label, reuse it. */
3751 t
= expr_last (else_
);
3753 t
= expr_last (then_
);
3756 if (t
&& TREE_CODE (t
) == LABEL_EXPR
)
3757 end_label
= LABEL_EXPR_LABEL (t
);
3759 /* If we don't care about jumping to the 'else' branch, jump to the end
3760 if the condition is false. */
3762 false_label_p
= &end_label
;
3764 /* We only want to emit these labels if we aren't hijacking them. */
3765 emit_end
= (end_label
== NULL_TREE
);
3766 emit_false
= (false_label
== NULL_TREE
);
3768 /* We only emit the jump over the else clause if we have to--if the
3769 then clause may fall through. Otherwise we can wind up with a
3770 useless jump and a useless label at the end of gimplified code,
3771 which will cause us to think that this conditional as a whole
3772 falls through even if it doesn't. If we then inline a function
3773 which ends with such a condition, that can cause us to issue an
3774 inappropriate warning about control reaching the end of a
3775 non-void function. */
3776 jump_over_else
= block_may_fallthru (then_
);
3778 pred
= shortcut_cond_r (pred
, true_label_p
, false_label_p
,
3779 EXPR_LOC_OR_LOC (expr
, input_location
));
3782 append_to_statement_list (pred
, &expr
);
3784 append_to_statement_list (then_
, &expr
);
3789 tree last
= expr_last (expr
);
3790 t
= build_and_jump (&end_label
);
3791 if (rexpr_has_location (last
))
3792 SET_EXPR_LOCATION (t
, rexpr_location (last
));
3793 append_to_statement_list (t
, &expr
);
3797 t
= build1 (LABEL_EXPR
, void_type_node
, false_label
);
3798 append_to_statement_list (t
, &expr
);
3800 append_to_statement_list (else_
, &expr
);
3802 if (emit_end
&& end_label
)
3804 t
= build1 (LABEL_EXPR
, void_type_node
, end_label
);
3805 append_to_statement_list (t
, &expr
);
3811 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
3814 gimple_boolify (tree expr
)
3816 tree type
= TREE_TYPE (expr
);
3817 location_t loc
= EXPR_LOCATION (expr
);
3819 if (TREE_CODE (expr
) == NE_EXPR
3820 && TREE_CODE (TREE_OPERAND (expr
, 0)) == CALL_EXPR
3821 && integer_zerop (TREE_OPERAND (expr
, 1)))
3823 tree call
= TREE_OPERAND (expr
, 0);
3824 tree fn
= get_callee_fndecl (call
);
3826 /* For __builtin_expect ((long) (x), y) recurse into x as well
3827 if x is truth_value_p. */
3829 && fndecl_built_in_p (fn
, BUILT_IN_EXPECT
)
3830 && call_expr_nargs (call
) == 2)
3832 tree arg
= CALL_EXPR_ARG (call
, 0);
3835 if (TREE_CODE (arg
) == NOP_EXPR
3836 && TREE_TYPE (arg
) == TREE_TYPE (call
))
3837 arg
= TREE_OPERAND (arg
, 0);
3838 if (truth_value_p (TREE_CODE (arg
)))
3840 arg
= gimple_boolify (arg
);
3841 CALL_EXPR_ARG (call
, 0)
3842 = fold_convert_loc (loc
, TREE_TYPE (call
), arg
);
3848 switch (TREE_CODE (expr
))
3850 case TRUTH_AND_EXPR
:
3852 case TRUTH_XOR_EXPR
:
3853 case TRUTH_ANDIF_EXPR
:
3854 case TRUTH_ORIF_EXPR
:
3855 /* Also boolify the arguments of truth exprs. */
3856 TREE_OPERAND (expr
, 1) = gimple_boolify (TREE_OPERAND (expr
, 1));
3859 case TRUTH_NOT_EXPR
:
3860 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3862 /* These expressions always produce boolean results. */
3863 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3864 TREE_TYPE (expr
) = boolean_type_node
;
3868 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (expr
, 1)))
3870 case annot_expr_ivdep_kind
:
3871 case annot_expr_unroll_kind
:
3872 case annot_expr_no_vector_kind
:
3873 case annot_expr_vector_kind
:
3874 case annot_expr_parallel_kind
:
3875 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3876 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3877 TREE_TYPE (expr
) = boolean_type_node
;
3884 if (COMPARISON_CLASS_P (expr
))
3886 /* There expressions always prduce boolean results. */
3887 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3888 TREE_TYPE (expr
) = boolean_type_node
;
3891 /* Other expressions that get here must have boolean values, but
3892 might need to be converted to the appropriate mode. */
3893 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
3895 return fold_convert_loc (loc
, boolean_type_node
, expr
);
3899 /* Given a conditional expression *EXPR_P without side effects, gimplify
3900 its operands. New statements are inserted to PRE_P. */
3902 static enum gimplify_status
3903 gimplify_pure_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
)
3905 tree expr
= *expr_p
, cond
;
3906 enum gimplify_status ret
, tret
;
3907 enum tree_code code
;
3909 cond
= gimple_boolify (COND_EXPR_COND (expr
));
3911 /* We need to handle && and || specially, as their gimplification
3912 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
3913 code
= TREE_CODE (cond
);
3914 if (code
== TRUTH_ANDIF_EXPR
)
3915 TREE_SET_CODE (cond
, TRUTH_AND_EXPR
);
3916 else if (code
== TRUTH_ORIF_EXPR
)
3917 TREE_SET_CODE (cond
, TRUTH_OR_EXPR
);
3918 ret
= gimplify_expr (&cond
, pre_p
, NULL
, is_gimple_condexpr
, fb_rvalue
);
3919 COND_EXPR_COND (*expr_p
) = cond
;
3921 tret
= gimplify_expr (&COND_EXPR_THEN (expr
), pre_p
, NULL
,
3922 is_gimple_val
, fb_rvalue
);
3923 ret
= MIN (ret
, tret
);
3924 tret
= gimplify_expr (&COND_EXPR_ELSE (expr
), pre_p
, NULL
,
3925 is_gimple_val
, fb_rvalue
);
3927 return MIN (ret
, tret
);
3930 /* Return true if evaluating EXPR could trap.
3931 EXPR is GENERIC, while tree_could_trap_p can be called
3935 generic_expr_could_trap_p (tree expr
)
3939 if (!expr
|| is_gimple_val (expr
))
3942 if (!EXPR_P (expr
) || tree_could_trap_p (expr
))
3945 n
= TREE_OPERAND_LENGTH (expr
);
3946 for (i
= 0; i
< n
; i
++)
3947 if (generic_expr_could_trap_p (TREE_OPERAND (expr
, i
)))
3953 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3962 The second form is used when *EXPR_P is of type void.
3964 PRE_P points to the list where side effects that must happen before
3965 *EXPR_P should be stored. */
3967 static enum gimplify_status
3968 gimplify_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
, fallback_t fallback
)
3970 tree expr
= *expr_p
;
3971 tree type
= TREE_TYPE (expr
);
3972 location_t loc
= EXPR_LOCATION (expr
);
3973 tree tmp
, arm1
, arm2
;
3974 enum gimplify_status ret
;
3975 tree label_true
, label_false
, label_cont
;
3976 bool have_then_clause_p
, have_else_clause_p
;
3978 enum tree_code pred_code
;
3979 gimple_seq seq
= NULL
;
3981 /* If this COND_EXPR has a value, copy the values into a temporary within
3983 if (!VOID_TYPE_P (type
))
3985 tree then_
= TREE_OPERAND (expr
, 1), else_
= TREE_OPERAND (expr
, 2);
3988 /* If either an rvalue is ok or we do not require an lvalue, create the
3989 temporary. But we cannot do that if the type is addressable. */
3990 if (((fallback
& fb_rvalue
) || !(fallback
& fb_lvalue
))
3991 && !TREE_ADDRESSABLE (type
))
3993 if (gimplify_ctxp
->allow_rhs_cond_expr
3994 /* If either branch has side effects or could trap, it can't be
3995 evaluated unconditionally. */
3996 && !TREE_SIDE_EFFECTS (then_
)
3997 && !generic_expr_could_trap_p (then_
)
3998 && !TREE_SIDE_EFFECTS (else_
)
3999 && !generic_expr_could_trap_p (else_
))
4000 return gimplify_pure_cond_expr (expr_p
, pre_p
);
4002 tmp
= create_tmp_var (type
, "iftmp");
4006 /* Otherwise, only create and copy references to the values. */
4009 type
= build_pointer_type (type
);
4011 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
4012 then_
= build_fold_addr_expr_loc (loc
, then_
);
4014 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
4015 else_
= build_fold_addr_expr_loc (loc
, else_
);
4018 = build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0), then_
, else_
);
4020 tmp
= create_tmp_var (type
, "iftmp");
4021 result
= build_simple_mem_ref_loc (loc
, tmp
);
4024 /* Build the new then clause, `tmp = then_;'. But don't build the
4025 assignment if the value is void; in C++ it can be if it's a throw. */
4026 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
4027 TREE_OPERAND (expr
, 1) = build2 (INIT_EXPR
, type
, tmp
, then_
);
4029 /* Similarly, build the new else clause, `tmp = else_;'. */
4030 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
4031 TREE_OPERAND (expr
, 2) = build2 (INIT_EXPR
, type
, tmp
, else_
);
4033 TREE_TYPE (expr
) = void_type_node
;
4034 recalculate_side_effects (expr
);
4036 /* Move the COND_EXPR to the prequeue. */
4037 gimplify_stmt (&expr
, pre_p
);
4043 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
4044 STRIP_TYPE_NOPS (TREE_OPERAND (expr
, 0));
4045 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == COMPOUND_EXPR
)
4046 gimplify_compound_expr (&TREE_OPERAND (expr
, 0), pre_p
, true);
4048 /* Make sure the condition has BOOLEAN_TYPE. */
4049 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
4051 /* Break apart && and || conditions. */
4052 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ANDIF_EXPR
4053 || TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ORIF_EXPR
)
4055 expr
= shortcut_cond_expr (expr
);
4057 if (expr
!= *expr_p
)
4061 /* We can't rely on gimplify_expr to re-gimplify the expanded
4062 form properly, as cleanups might cause the target labels to be
4063 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
4064 set up a conditional context. */
4065 gimple_push_condition ();
4066 gimplify_stmt (expr_p
, &seq
);
4067 gimple_pop_condition (pre_p
);
4068 gimple_seq_add_seq (pre_p
, seq
);
4074 /* Now do the normal gimplification. */
4076 /* Gimplify condition. */
4077 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, NULL
, is_gimple_condexpr
,
4079 if (ret
== GS_ERROR
)
4081 gcc_assert (TREE_OPERAND (expr
, 0) != NULL_TREE
);
4083 gimple_push_condition ();
4085 have_then_clause_p
= have_else_clause_p
= false;
4086 label_true
= find_goto_label (TREE_OPERAND (expr
, 1));
4088 && DECL_CONTEXT (GOTO_DESTINATION (label_true
)) == current_function_decl
4089 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
4090 have different locations, otherwise we end up with incorrect
4091 location information on the branches. */
4093 || !EXPR_HAS_LOCATION (expr
)
4094 || !rexpr_has_location (label_true
)
4095 || EXPR_LOCATION (expr
) == rexpr_location (label_true
)))
4097 have_then_clause_p
= true;
4098 label_true
= GOTO_DESTINATION (label_true
);
4101 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
4102 label_false
= find_goto_label (TREE_OPERAND (expr
, 2));
4104 && DECL_CONTEXT (GOTO_DESTINATION (label_false
)) == current_function_decl
4105 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
4106 have different locations, otherwise we end up with incorrect
4107 location information on the branches. */
4109 || !EXPR_HAS_LOCATION (expr
)
4110 || !rexpr_has_location (label_false
)
4111 || EXPR_LOCATION (expr
) == rexpr_location (label_false
)))
4113 have_else_clause_p
= true;
4114 label_false
= GOTO_DESTINATION (label_false
);
4117 label_false
= create_artificial_label (UNKNOWN_LOCATION
);
4119 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr
), &pred_code
, &arm1
,
4121 cond_stmt
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
,
4123 gimple_set_no_warning (cond_stmt
, TREE_NO_WARNING (COND_EXPR_COND (expr
)));
4124 gimplify_seq_add_stmt (&seq
, cond_stmt
);
4125 gimple_stmt_iterator gsi
= gsi_last (seq
);
4126 maybe_fold_stmt (&gsi
);
4128 label_cont
= NULL_TREE
;
4129 if (!have_then_clause_p
)
4131 /* For if (...) {} else { code; } put label_true after
4133 if (TREE_OPERAND (expr
, 1) == NULL_TREE
4134 && !have_else_clause_p
4135 && TREE_OPERAND (expr
, 2) != NULL_TREE
)
4136 label_cont
= label_true
;
4139 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_true
));
4140 have_then_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 1), &seq
);
4141 /* For if (...) { code; } else {} or
4142 if (...) { code; } else goto label; or
4143 if (...) { code; return; } else { ... }
4144 label_cont isn't needed. */
4145 if (!have_else_clause_p
4146 && TREE_OPERAND (expr
, 2) != NULL_TREE
4147 && gimple_seq_may_fallthru (seq
))
4150 label_cont
= create_artificial_label (UNKNOWN_LOCATION
);
4152 g
= gimple_build_goto (label_cont
);
4154 /* GIMPLE_COND's are very low level; they have embedded
4155 gotos. This particular embedded goto should not be marked
4156 with the location of the original COND_EXPR, as it would
4157 correspond to the COND_EXPR's condition, not the ELSE or the
4158 THEN arms. To avoid marking it with the wrong location, flag
4159 it as "no location". */
4160 gimple_set_do_not_emit_location (g
);
4162 gimplify_seq_add_stmt (&seq
, g
);
4166 if (!have_else_clause_p
)
4168 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_false
));
4169 have_else_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 2), &seq
);
4172 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_cont
));
4174 gimple_pop_condition (pre_p
);
4175 gimple_seq_add_seq (pre_p
, seq
);
4177 if (ret
== GS_ERROR
)
4179 else if (have_then_clause_p
|| have_else_clause_p
)
4183 /* Both arms are empty; replace the COND_EXPR with its predicate. */
4184 expr
= TREE_OPERAND (expr
, 0);
4185 gimplify_stmt (&expr
, pre_p
);
4192 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
4193 to be marked addressable.
4195 We cannot rely on such an expression being directly markable if a temporary
4196 has been created by the gimplification. In this case, we create another
4197 temporary and initialize it with a copy, which will become a store after we
4198 mark it addressable. This can happen if the front-end passed us something
4199 that it could not mark addressable yet, like a Fortran pass-by-reference
4200 parameter (int) floatvar. */
4203 prepare_gimple_addressable (tree
*expr_p
, gimple_seq
*seq_p
)
4205 while (handled_component_p (*expr_p
))
4206 expr_p
= &TREE_OPERAND (*expr_p
, 0);
4207 if (is_gimple_reg (*expr_p
))
4209 /* Do not allow an SSA name as the temporary. */
4210 tree var
= get_initialized_tmp_var (*expr_p
, seq_p
, NULL
, false);
4211 DECL_GIMPLE_REG_P (var
) = 0;
4216 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
4217 a call to __builtin_memcpy. */
4219 static enum gimplify_status
4220 gimplify_modify_expr_to_memcpy (tree
*expr_p
, tree size
, bool want_value
,
4223 tree t
, to
, to_ptr
, from
, from_ptr
;
4225 location_t loc
= EXPR_LOCATION (*expr_p
);
4227 to
= TREE_OPERAND (*expr_p
, 0);
4228 from
= TREE_OPERAND (*expr_p
, 1);
4230 /* Mark the RHS addressable. Beware that it may not be possible to do so
4231 directly if a temporary has been created by the gimplification. */
4232 prepare_gimple_addressable (&from
, seq_p
);
4234 mark_addressable (from
);
4235 from_ptr
= build_fold_addr_expr_loc (loc
, from
);
4236 gimplify_arg (&from_ptr
, seq_p
, loc
);
4238 mark_addressable (to
);
4239 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
4240 gimplify_arg (&to_ptr
, seq_p
, loc
);
4242 t
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
4244 gs
= gimple_build_call (t
, 3, to_ptr
, from_ptr
, size
);
4248 /* tmp = memcpy() */
4249 t
= create_tmp_var (TREE_TYPE (to_ptr
));
4250 gimple_call_set_lhs (gs
, t
);
4251 gimplify_seq_add_stmt (seq_p
, gs
);
4253 *expr_p
= build_simple_mem_ref (t
);
4257 gimplify_seq_add_stmt (seq_p
, gs
);
4262 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
4263 a call to __builtin_memset. In this case we know that the RHS is
4264 a CONSTRUCTOR with an empty element list. */
4266 static enum gimplify_status
4267 gimplify_modify_expr_to_memset (tree
*expr_p
, tree size
, bool want_value
,
4270 tree t
, from
, to
, to_ptr
;
4272 location_t loc
= EXPR_LOCATION (*expr_p
);
4274 /* Assert our assumptions, to abort instead of producing wrong code
4275 silently if they are not met. Beware that the RHS CONSTRUCTOR might
4276 not be immediately exposed. */
4277 from
= TREE_OPERAND (*expr_p
, 1);
4278 if (TREE_CODE (from
) == WITH_SIZE_EXPR
)
4279 from
= TREE_OPERAND (from
, 0);
4281 gcc_assert (TREE_CODE (from
) == CONSTRUCTOR
4282 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from
)));
4285 to
= TREE_OPERAND (*expr_p
, 0);
4287 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
4288 gimplify_arg (&to_ptr
, seq_p
, loc
);
4289 t
= builtin_decl_implicit (BUILT_IN_MEMSET
);
4291 gs
= gimple_build_call (t
, 3, to_ptr
, integer_zero_node
, size
);
4295 /* tmp = memset() */
4296 t
= create_tmp_var (TREE_TYPE (to_ptr
));
4297 gimple_call_set_lhs (gs
, t
);
4298 gimplify_seq_add_stmt (seq_p
, gs
);
4300 *expr_p
= build1 (INDIRECT_REF
, TREE_TYPE (to
), t
);
4304 gimplify_seq_add_stmt (seq_p
, gs
);
4309 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
4310 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
4311 assignment. Return non-null if we detect a potential overlap. */
4313 struct gimplify_init_ctor_preeval_data
4315 /* The base decl of the lhs object. May be NULL, in which case we
4316 have to assume the lhs is indirect. */
4319 /* The alias set of the lhs object. */
4320 alias_set_type lhs_alias_set
;
4324 gimplify_init_ctor_preeval_1 (tree
*tp
, int *walk_subtrees
, void *xdata
)
4326 struct gimplify_init_ctor_preeval_data
*data
4327 = (struct gimplify_init_ctor_preeval_data
*) xdata
;
4330 /* If we find the base object, obviously we have overlap. */
4331 if (data
->lhs_base_decl
== t
)
4334 /* If the constructor component is indirect, determine if we have a
4335 potential overlap with the lhs. The only bits of information we
4336 have to go on at this point are addressability and alias sets. */
4337 if ((INDIRECT_REF_P (t
)
4338 || TREE_CODE (t
) == MEM_REF
)
4339 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
4340 && alias_sets_conflict_p (data
->lhs_alias_set
, get_alias_set (t
)))
4343 /* If the constructor component is a call, determine if it can hide a
4344 potential overlap with the lhs through an INDIRECT_REF like above.
4345 ??? Ugh - this is completely broken. In fact this whole analysis
4346 doesn't look conservative. */
4347 if (TREE_CODE (t
) == CALL_EXPR
)
4349 tree type
, fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t
)));
4351 for (type
= TYPE_ARG_TYPES (fntype
); type
; type
= TREE_CHAIN (type
))
4352 if (POINTER_TYPE_P (TREE_VALUE (type
))
4353 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
4354 && alias_sets_conflict_p (data
->lhs_alias_set
,
4356 (TREE_TYPE (TREE_VALUE (type
)))))
4360 if (IS_TYPE_OR_DECL_P (t
))
4365 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
4366 force values that overlap with the lhs (as described by *DATA)
4367 into temporaries. */
4370 gimplify_init_ctor_preeval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4371 struct gimplify_init_ctor_preeval_data
*data
)
4373 enum gimplify_status one
;
4375 /* If the value is constant, then there's nothing to pre-evaluate. */
4376 if (TREE_CONSTANT (*expr_p
))
4378 /* Ensure it does not have side effects, it might contain a reference to
4379 the object we're initializing. */
4380 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p
));
4384 /* If the type has non-trivial constructors, we can't pre-evaluate. */
4385 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p
)))
4388 /* Recurse for nested constructors. */
4389 if (TREE_CODE (*expr_p
) == CONSTRUCTOR
)
4391 unsigned HOST_WIDE_INT ix
;
4392 constructor_elt
*ce
;
4393 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (*expr_p
);
4395 FOR_EACH_VEC_SAFE_ELT (v
, ix
, ce
)
4396 gimplify_init_ctor_preeval (&ce
->value
, pre_p
, post_p
, data
);
4401 /* If this is a variable sized type, we must remember the size. */
4402 maybe_with_size_expr (expr_p
);
4404 /* Gimplify the constructor element to something appropriate for the rhs
4405 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
4406 the gimplifier will consider this a store to memory. Doing this
4407 gimplification now means that we won't have to deal with complicated
4408 language-specific trees, nor trees like SAVE_EXPR that can induce
4409 exponential search behavior. */
4410 one
= gimplify_expr (expr_p
, pre_p
, post_p
, is_gimple_mem_rhs
, fb_rvalue
);
4411 if (one
== GS_ERROR
)
4417 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
4418 with the lhs, since "a = { .x=a }" doesn't make sense. This will
4419 always be true for all scalars, since is_gimple_mem_rhs insists on a
4420 temporary variable for them. */
4421 if (DECL_P (*expr_p
))
4424 /* If this is of variable size, we have no choice but to assume it doesn't
4425 overlap since we can't make a temporary for it. */
4426 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p
))) != INTEGER_CST
)
4429 /* Otherwise, we must search for overlap ... */
4430 if (!walk_tree (expr_p
, gimplify_init_ctor_preeval_1
, data
, NULL
))
4433 /* ... and if found, force the value into a temporary. */
4434 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
4437 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
4438 a RANGE_EXPR in a CONSTRUCTOR for an array.
4442 object[var] = value;
4449 We increment var _after_ the loop exit check because we might otherwise
4450 fail if upper == TYPE_MAX_VALUE (type for upper).
4452 Note that we never have to deal with SAVE_EXPRs here, because this has
4453 already been taken care of for us, in gimplify_init_ctor_preeval(). */
4455 static void gimplify_init_ctor_eval (tree
, vec
<constructor_elt
, va_gc
> *,
4456 gimple_seq
*, bool);
4459 gimplify_init_ctor_eval_range (tree object
, tree lower
, tree upper
,
4460 tree value
, tree array_elt_type
,
4461 gimple_seq
*pre_p
, bool cleared
)
4463 tree loop_entry_label
, loop_exit_label
, fall_thru_label
;
4464 tree var
, var_type
, cref
, tmp
;
4466 loop_entry_label
= create_artificial_label (UNKNOWN_LOCATION
);
4467 loop_exit_label
= create_artificial_label (UNKNOWN_LOCATION
);
4468 fall_thru_label
= create_artificial_label (UNKNOWN_LOCATION
);
4470 /* Create and initialize the index variable. */
4471 var_type
= TREE_TYPE (upper
);
4472 var
= create_tmp_var (var_type
);
4473 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, lower
));
4475 /* Add the loop entry label. */
4476 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_entry_label
));
4478 /* Build the reference. */
4479 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
4480 var
, NULL_TREE
, NULL_TREE
);
4482 /* If we are a constructor, just call gimplify_init_ctor_eval to do
4483 the store. Otherwise just assign value to the reference. */
4485 if (TREE_CODE (value
) == CONSTRUCTOR
)
4486 /* NB we might have to call ourself recursively through
4487 gimplify_init_ctor_eval if the value is a constructor. */
4488 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
4491 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (cref
, value
));
4493 /* We exit the loop when the index var is equal to the upper bound. */
4494 gimplify_seq_add_stmt (pre_p
,
4495 gimple_build_cond (EQ_EXPR
, var
, upper
,
4496 loop_exit_label
, fall_thru_label
));
4498 gimplify_seq_add_stmt (pre_p
, gimple_build_label (fall_thru_label
));
4500 /* Otherwise, increment the index var... */
4501 tmp
= build2 (PLUS_EXPR
, var_type
, var
,
4502 fold_convert (var_type
, integer_one_node
));
4503 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, tmp
));
4505 /* ...and jump back to the loop entry. */
4506 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (loop_entry_label
));
4508 /* Add the loop exit label. */
4509 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_exit_label
));
4512 /* Return true if FDECL is accessing a field that is zero sized. */
4515 zero_sized_field_decl (const_tree fdecl
)
4517 if (TREE_CODE (fdecl
) == FIELD_DECL
&& DECL_SIZE (fdecl
)
4518 && integer_zerop (DECL_SIZE (fdecl
)))
4523 /* Return true if TYPE is zero sized. */
4526 zero_sized_type (const_tree type
)
4528 if (AGGREGATE_TYPE_P (type
) && TYPE_SIZE (type
)
4529 && integer_zerop (TYPE_SIZE (type
)))
4534 /* A subroutine of gimplify_init_constructor. Generate individual
4535 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
4536 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
4537 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
4541 gimplify_init_ctor_eval (tree object
, vec
<constructor_elt
, va_gc
> *elts
,
4542 gimple_seq
*pre_p
, bool cleared
)
4544 tree array_elt_type
= NULL
;
4545 unsigned HOST_WIDE_INT ix
;
4546 tree purpose
, value
;
4548 if (TREE_CODE (TREE_TYPE (object
)) == ARRAY_TYPE
)
4549 array_elt_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object
)));
4551 FOR_EACH_CONSTRUCTOR_ELT (elts
, ix
, purpose
, value
)
4555 /* NULL values are created above for gimplification errors. */
4559 if (cleared
&& initializer_zerop (value
))
4562 /* ??? Here's to hoping the front end fills in all of the indices,
4563 so we don't have to figure out what's missing ourselves. */
4564 gcc_assert (purpose
);
4566 /* Skip zero-sized fields, unless value has side-effects. This can
4567 happen with calls to functions returning a zero-sized type, which
4568 we shouldn't discard. As a number of downstream passes don't
4569 expect sets of zero-sized fields, we rely on the gimplification of
4570 the MODIFY_EXPR we make below to drop the assignment statement. */
4571 if (! TREE_SIDE_EFFECTS (value
) && zero_sized_field_decl (purpose
))
4574 /* If we have a RANGE_EXPR, we have to build a loop to assign the
4576 if (TREE_CODE (purpose
) == RANGE_EXPR
)
4578 tree lower
= TREE_OPERAND (purpose
, 0);
4579 tree upper
= TREE_OPERAND (purpose
, 1);
4581 /* If the lower bound is equal to upper, just treat it as if
4582 upper was the index. */
4583 if (simple_cst_equal (lower
, upper
))
4587 gimplify_init_ctor_eval_range (object
, lower
, upper
, value
,
4588 array_elt_type
, pre_p
, cleared
);
4595 /* Do not use bitsizetype for ARRAY_REF indices. */
4596 if (TYPE_DOMAIN (TREE_TYPE (object
)))
4598 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object
))),
4600 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
4601 purpose
, NULL_TREE
, NULL_TREE
);
4605 gcc_assert (TREE_CODE (purpose
) == FIELD_DECL
);
4606 cref
= build3 (COMPONENT_REF
, TREE_TYPE (purpose
),
4607 unshare_expr (object
), purpose
, NULL_TREE
);
4610 if (TREE_CODE (value
) == CONSTRUCTOR
4611 && TREE_CODE (TREE_TYPE (value
)) != VECTOR_TYPE
)
4612 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
4616 tree init
= build2 (INIT_EXPR
, TREE_TYPE (cref
), cref
, value
);
4617 gimplify_and_add (init
, pre_p
);
4623 /* Return the appropriate RHS predicate for this LHS. */
4626 rhs_predicate_for (tree lhs
)
4628 if (is_gimple_reg (lhs
))
4629 return is_gimple_reg_rhs_or_call
;
4631 return is_gimple_mem_rhs_or_call
;
4634 /* Return the initial guess for an appropriate RHS predicate for this LHS,
4635 before the LHS has been gimplified. */
4637 static gimple_predicate
4638 initial_rhs_predicate_for (tree lhs
)
4640 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
4641 return is_gimple_reg_rhs_or_call
;
4643 return is_gimple_mem_rhs_or_call
;
4646 /* Gimplify a C99 compound literal expression. This just means adding
4647 the DECL_EXPR before the current statement and using its anonymous
4650 static enum gimplify_status
4651 gimplify_compound_literal_expr (tree
*expr_p
, gimple_seq
*pre_p
,
4652 bool (*gimple_test_f
) (tree
),
4653 fallback_t fallback
)
4655 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p
);
4656 tree decl
= DECL_EXPR_DECL (decl_s
);
4657 tree init
= DECL_INITIAL (decl
);
4658 /* Mark the decl as addressable if the compound literal
4659 expression is addressable now, otherwise it is marked too late
4660 after we gimplify the initialization expression. */
4661 if (TREE_ADDRESSABLE (*expr_p
))
4662 TREE_ADDRESSABLE (decl
) = 1;
4663 /* Otherwise, if we don't need an lvalue and have a literal directly
4664 substitute it. Check if it matches the gimple predicate, as
4665 otherwise we'd generate a new temporary, and we can as well just
4666 use the decl we already have. */
4667 else if (!TREE_ADDRESSABLE (decl
)
4668 && !TREE_THIS_VOLATILE (decl
)
4670 && (fallback
& fb_lvalue
) == 0
4671 && gimple_test_f (init
))
4677 /* Preliminarily mark non-addressed complex variables as eligible
4678 for promotion to gimple registers. We'll transform their uses
4680 if ((TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
4681 || TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
)
4682 && !TREE_THIS_VOLATILE (decl
)
4683 && !needs_to_live_in_memory (decl
))
4684 DECL_GIMPLE_REG_P (decl
) = 1;
4686 /* If the decl is not addressable, then it is being used in some
4687 expression or on the right hand side of a statement, and it can
4688 be put into a readonly data section. */
4689 if (!TREE_ADDRESSABLE (decl
) && (fallback
& fb_lvalue
) == 0)
4690 TREE_READONLY (decl
) = 1;
4692 /* This decl isn't mentioned in the enclosing block, so add it to the
4693 list of temps. FIXME it seems a bit of a kludge to say that
4694 anonymous artificial vars aren't pushed, but everything else is. */
4695 if (DECL_NAME (decl
) == NULL_TREE
&& !DECL_SEEN_IN_BIND_EXPR_P (decl
))
4696 gimple_add_tmp_var (decl
);
4698 gimplify_and_add (decl_s
, pre_p
);
4703 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
4704 return a new CONSTRUCTOR if something changed. */
4707 optimize_compound_literals_in_ctor (tree orig_ctor
)
4709 tree ctor
= orig_ctor
;
4710 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
4711 unsigned int idx
, num
= vec_safe_length (elts
);
4713 for (idx
= 0; idx
< num
; idx
++)
4715 tree value
= (*elts
)[idx
].value
;
4716 tree newval
= value
;
4717 if (TREE_CODE (value
) == CONSTRUCTOR
)
4718 newval
= optimize_compound_literals_in_ctor (value
);
4719 else if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
4721 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (value
);
4722 tree decl
= DECL_EXPR_DECL (decl_s
);
4723 tree init
= DECL_INITIAL (decl
);
4725 if (!TREE_ADDRESSABLE (value
)
4726 && !TREE_ADDRESSABLE (decl
)
4728 && TREE_CODE (init
) == CONSTRUCTOR
)
4729 newval
= optimize_compound_literals_in_ctor (init
);
4731 if (newval
== value
)
4734 if (ctor
== orig_ctor
)
4736 ctor
= copy_node (orig_ctor
);
4737 CONSTRUCTOR_ELTS (ctor
) = vec_safe_copy (elts
);
4738 elts
= CONSTRUCTOR_ELTS (ctor
);
4740 (*elts
)[idx
].value
= newval
;
4745 /* A subroutine of gimplify_modify_expr. Break out elements of a
4746 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
4748 Note that we still need to clear any elements that don't have explicit
4749 initializers, so if not all elements are initialized we keep the
4750 original MODIFY_EXPR, we just remove all of the constructor elements.
4752 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
4753 GS_ERROR if we would have to create a temporary when gimplifying
4754 this constructor. Otherwise, return GS_OK.
4756 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
4758 static enum gimplify_status
4759 gimplify_init_constructor (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4760 bool want_value
, bool notify_temp_creation
)
4762 tree object
, ctor
, type
;
4763 enum gimplify_status ret
;
4764 vec
<constructor_elt
, va_gc
> *elts
;
4766 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == CONSTRUCTOR
);
4768 if (!notify_temp_creation
)
4770 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
4771 is_gimple_lvalue
, fb_lvalue
);
4772 if (ret
== GS_ERROR
)
4776 object
= TREE_OPERAND (*expr_p
, 0);
4777 ctor
= TREE_OPERAND (*expr_p
, 1)
4778 = optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p
, 1));
4779 type
= TREE_TYPE (ctor
);
4780 elts
= CONSTRUCTOR_ELTS (ctor
);
4783 switch (TREE_CODE (type
))
4787 case QUAL_UNION_TYPE
:
4790 struct gimplify_init_ctor_preeval_data preeval_data
;
4791 HOST_WIDE_INT num_ctor_elements
, num_nonzero_elements
;
4792 HOST_WIDE_INT num_unique_nonzero_elements
;
4793 bool cleared
, complete_p
, valid_const_initializer
;
4794 /* Use readonly data for initializers of this or smaller size
4795 regardless of the num_nonzero_elements / num_unique_nonzero_elements
4797 const HOST_WIDE_INT min_unique_size
= 64;
4798 /* If num_nonzero_elements / num_unique_nonzero_elements ratio
4799 is smaller than this, use readonly data. */
4800 const int unique_nonzero_ratio
= 8;
4802 /* Aggregate types must lower constructors to initialization of
4803 individual elements. The exception is that a CONSTRUCTOR node
4804 with no elements indicates zero-initialization of the whole. */
4805 if (vec_safe_is_empty (elts
))
4807 if (notify_temp_creation
)
4812 /* Fetch information about the constructor to direct later processing.
4813 We might want to make static versions of it in various cases, and
4814 can only do so if it known to be a valid constant initializer. */
4815 valid_const_initializer
4816 = categorize_ctor_elements (ctor
, &num_nonzero_elements
,
4817 &num_unique_nonzero_elements
,
4818 &num_ctor_elements
, &complete_p
);
4820 /* If a const aggregate variable is being initialized, then it
4821 should never be a lose to promote the variable to be static. */
4822 if (valid_const_initializer
4823 && num_nonzero_elements
> 1
4824 && TREE_READONLY (object
)
4826 && (flag_merge_constants
>= 2 || !TREE_ADDRESSABLE (object
))
4827 /* For ctors that have many repeated nonzero elements
4828 represented through RANGE_EXPRs, prefer initializing
4829 those through runtime loops over copies of large amounts
4830 of data from readonly data section. */
4831 && (num_unique_nonzero_elements
4832 > num_nonzero_elements
/ unique_nonzero_ratio
4833 || ((unsigned HOST_WIDE_INT
) int_size_in_bytes (type
)
4834 <= (unsigned HOST_WIDE_INT
) min_unique_size
)))
4836 if (notify_temp_creation
)
4838 DECL_INITIAL (object
) = ctor
;
4839 TREE_STATIC (object
) = 1;
4840 if (!DECL_NAME (object
))
4841 DECL_NAME (object
) = create_tmp_var_name ("C");
4842 walk_tree (&DECL_INITIAL (object
), force_labels_r
, NULL
, NULL
);
4844 /* ??? C++ doesn't automatically append a .<number> to the
4845 assembler name, and even when it does, it looks at FE private
4846 data structures to figure out what that number should be,
4847 which are not set for this variable. I suppose this is
4848 important for local statics for inline functions, which aren't
4849 "local" in the object file sense. So in order to get a unique
4850 TU-local symbol, we must invoke the lhd version now. */
4851 lhd_set_decl_assembler_name (object
);
4853 *expr_p
= NULL_TREE
;
4857 /* If there are "lots" of initialized elements, even discounting
4858 those that are not address constants (and thus *must* be
4859 computed at runtime), then partition the constructor into
4860 constant and non-constant parts. Block copy the constant
4861 parts in, then generate code for the non-constant parts. */
4862 /* TODO. There's code in cp/typeck.c to do this. */
4864 if (int_size_in_bytes (TREE_TYPE (ctor
)) < 0)
4865 /* store_constructor will ignore the clearing of variable-sized
4866 objects. Initializers for such objects must explicitly set
4867 every field that needs to be set. */
4869 else if (!complete_p
)
4870 /* If the constructor isn't complete, clear the whole object
4871 beforehand, unless CONSTRUCTOR_NO_CLEARING is set on it.
4873 ??? This ought not to be needed. For any element not present
4874 in the initializer, we should simply set them to zero. Except
4875 we'd need to *find* the elements that are not present, and that
4876 requires trickery to avoid quadratic compile-time behavior in
4877 large cases or excessive memory use in small cases. */
4878 cleared
= !CONSTRUCTOR_NO_CLEARING (ctor
);
4879 else if (num_ctor_elements
- num_nonzero_elements
4880 > CLEAR_RATIO (optimize_function_for_speed_p (cfun
))
4881 && num_nonzero_elements
< num_ctor_elements
/ 4)
4882 /* If there are "lots" of zeros, it's more efficient to clear
4883 the memory and then set the nonzero elements. */
4888 /* If there are "lots" of initialized elements, and all of them
4889 are valid address constants, then the entire initializer can
4890 be dropped to memory, and then memcpy'd out. Don't do this
4891 for sparse arrays, though, as it's more efficient to follow
4892 the standard CONSTRUCTOR behavior of memset followed by
4893 individual element initialization. Also don't do this for small
4894 all-zero initializers (which aren't big enough to merit
4895 clearing), and don't try to make bitwise copies of
4896 TREE_ADDRESSABLE types. */
4898 if (valid_const_initializer
4899 && !(cleared
|| num_nonzero_elements
== 0)
4900 && !TREE_ADDRESSABLE (type
))
4902 HOST_WIDE_INT size
= int_size_in_bytes (type
);
4905 /* ??? We can still get unbounded array types, at least
4906 from the C++ front end. This seems wrong, but attempt
4907 to work around it for now. */
4910 size
= int_size_in_bytes (TREE_TYPE (object
));
4912 TREE_TYPE (ctor
) = type
= TREE_TYPE (object
);
4915 /* Find the maximum alignment we can assume for the object. */
4916 /* ??? Make use of DECL_OFFSET_ALIGN. */
4917 if (DECL_P (object
))
4918 align
= DECL_ALIGN (object
);
4920 align
= TYPE_ALIGN (type
);
4922 /* Do a block move either if the size is so small as to make
4923 each individual move a sub-unit move on average, or if it
4924 is so large as to make individual moves inefficient. */
4926 && num_nonzero_elements
> 1
4927 /* For ctors that have many repeated nonzero elements
4928 represented through RANGE_EXPRs, prefer initializing
4929 those through runtime loops over copies of large amounts
4930 of data from readonly data section. */
4931 && (num_unique_nonzero_elements
4932 > num_nonzero_elements
/ unique_nonzero_ratio
4933 || size
<= min_unique_size
)
4934 && (size
< num_nonzero_elements
4935 || !can_move_by_pieces (size
, align
)))
4937 if (notify_temp_creation
)
4940 walk_tree (&ctor
, force_labels_r
, NULL
, NULL
);
4941 ctor
= tree_output_constant_def (ctor
);
4942 if (!useless_type_conversion_p (type
, TREE_TYPE (ctor
)))
4943 ctor
= build1 (VIEW_CONVERT_EXPR
, type
, ctor
);
4944 TREE_OPERAND (*expr_p
, 1) = ctor
;
4946 /* This is no longer an assignment of a CONSTRUCTOR, but
4947 we still may have processing to do on the LHS. So
4948 pretend we didn't do anything here to let that happen. */
4949 return GS_UNHANDLED
;
4953 /* If the target is volatile, we have non-zero elements and more than
4954 one field to assign, initialize the target from a temporary. */
4955 if (TREE_THIS_VOLATILE (object
)
4956 && !TREE_ADDRESSABLE (type
)
4957 && num_nonzero_elements
> 0
4958 && vec_safe_length (elts
) > 1)
4960 tree temp
= create_tmp_var (TYPE_MAIN_VARIANT (type
));
4961 TREE_OPERAND (*expr_p
, 0) = temp
;
4962 *expr_p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*expr_p
),
4964 build2 (MODIFY_EXPR
, void_type_node
,
4969 if (notify_temp_creation
)
4972 /* If there are nonzero elements and if needed, pre-evaluate to capture
4973 elements overlapping with the lhs into temporaries. We must do this
4974 before clearing to fetch the values before they are zeroed-out. */
4975 if (num_nonzero_elements
> 0 && TREE_CODE (*expr_p
) != INIT_EXPR
)
4977 preeval_data
.lhs_base_decl
= get_base_address (object
);
4978 if (!DECL_P (preeval_data
.lhs_base_decl
))
4979 preeval_data
.lhs_base_decl
= NULL
;
4980 preeval_data
.lhs_alias_set
= get_alias_set (object
);
4982 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p
, 1),
4983 pre_p
, post_p
, &preeval_data
);
4986 bool ctor_has_side_effects_p
4987 = TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p
, 1));
4991 /* Zap the CONSTRUCTOR element list, which simplifies this case.
4992 Note that we still have to gimplify, in order to handle the
4993 case of variable sized types. Avoid shared tree structures. */
4994 CONSTRUCTOR_ELTS (ctor
) = NULL
;
4995 TREE_SIDE_EFFECTS (ctor
) = 0;
4996 object
= unshare_expr (object
);
4997 gimplify_stmt (expr_p
, pre_p
);
5000 /* If we have not block cleared the object, or if there are nonzero
5001 elements in the constructor, or if the constructor has side effects,
5002 add assignments to the individual scalar fields of the object. */
5004 || num_nonzero_elements
> 0
5005 || ctor_has_side_effects_p
)
5006 gimplify_init_ctor_eval (object
, elts
, pre_p
, cleared
);
5008 *expr_p
= NULL_TREE
;
5016 if (notify_temp_creation
)
5019 /* Extract the real and imaginary parts out of the ctor. */
5020 gcc_assert (elts
->length () == 2);
5021 r
= (*elts
)[0].value
;
5022 i
= (*elts
)[1].value
;
5023 if (r
== NULL
|| i
== NULL
)
5025 tree zero
= build_zero_cst (TREE_TYPE (type
));
5032 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
5033 represent creation of a complex value. */
5034 if (TREE_CONSTANT (r
) && TREE_CONSTANT (i
))
5036 ctor
= build_complex (type
, r
, i
);
5037 TREE_OPERAND (*expr_p
, 1) = ctor
;
5041 ctor
= build2 (COMPLEX_EXPR
, type
, r
, i
);
5042 TREE_OPERAND (*expr_p
, 1) = ctor
;
5043 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1),
5046 rhs_predicate_for (TREE_OPERAND (*expr_p
, 0)),
5054 unsigned HOST_WIDE_INT ix
;
5055 constructor_elt
*ce
;
5057 if (notify_temp_creation
)
5060 /* Go ahead and simplify constant constructors to VECTOR_CST. */
5061 if (TREE_CONSTANT (ctor
))
5063 bool constant_p
= true;
5066 /* Even when ctor is constant, it might contain non-*_CST
5067 elements, such as addresses or trapping values like
5068 1.0/0.0 - 1.0/0.0. Such expressions don't belong
5069 in VECTOR_CST nodes. */
5070 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
5071 if (!CONSTANT_CLASS_P (value
))
5079 TREE_OPERAND (*expr_p
, 1) = build_vector_from_ctor (type
, elts
);
5083 TREE_CONSTANT (ctor
) = 0;
5086 /* Vector types use CONSTRUCTOR all the way through gimple
5087 compilation as a general initializer. */
5088 FOR_EACH_VEC_SAFE_ELT (elts
, ix
, ce
)
5090 enum gimplify_status tret
;
5091 tret
= gimplify_expr (&ce
->value
, pre_p
, post_p
, is_gimple_val
,
5093 if (tret
== GS_ERROR
)
5095 else if (TREE_STATIC (ctor
)
5096 && !initializer_constant_valid_p (ce
->value
,
5097 TREE_TYPE (ce
->value
)))
5098 TREE_STATIC (ctor
) = 0;
5100 if (!is_gimple_reg (TREE_OPERAND (*expr_p
, 0)))
5101 TREE_OPERAND (*expr_p
, 1) = get_formal_tmp_var (ctor
, pre_p
);
5106 /* So how did we get a CONSTRUCTOR for a scalar type? */
5110 if (ret
== GS_ERROR
)
5112 /* If we have gimplified both sides of the initializer but have
5113 not emitted an assignment, do so now. */
5116 tree lhs
= TREE_OPERAND (*expr_p
, 0);
5117 tree rhs
= TREE_OPERAND (*expr_p
, 1);
5118 if (want_value
&& object
== lhs
)
5119 lhs
= unshare_expr (lhs
);
5120 gassign
*init
= gimple_build_assign (lhs
, rhs
);
5121 gimplify_seq_add_stmt (pre_p
, init
);
5135 /* Given a pointer value OP0, return a simplified version of an
5136 indirection through OP0, or NULL_TREE if no simplification is
5137 possible. This may only be applied to a rhs of an expression.
5138 Note that the resulting type may be different from the type pointed
5139 to in the sense that it is still compatible from the langhooks
5143 gimple_fold_indirect_ref_rhs (tree t
)
5145 return gimple_fold_indirect_ref (t
);
5148 /* Subroutine of gimplify_modify_expr to do simplifications of
5149 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
5150 something changes. */
5152 static enum gimplify_status
5153 gimplify_modify_expr_rhs (tree
*expr_p
, tree
*from_p
, tree
*to_p
,
5154 gimple_seq
*pre_p
, gimple_seq
*post_p
,
5157 enum gimplify_status ret
= GS_UNHANDLED
;
5163 switch (TREE_CODE (*from_p
))
5166 /* If we're assigning from a read-only variable initialized with
5167 a constructor, do the direct assignment from the constructor,
5168 but only if neither source nor target are volatile since this
5169 latter assignment might end up being done on a per-field basis. */
5170 if (DECL_INITIAL (*from_p
)
5171 && TREE_READONLY (*from_p
)
5172 && !TREE_THIS_VOLATILE (*from_p
)
5173 && !TREE_THIS_VOLATILE (*to_p
)
5174 && TREE_CODE (DECL_INITIAL (*from_p
)) == CONSTRUCTOR
)
5176 tree old_from
= *from_p
;
5177 enum gimplify_status subret
;
5179 /* Move the constructor into the RHS. */
5180 *from_p
= unshare_expr (DECL_INITIAL (*from_p
));
5182 /* Let's see if gimplify_init_constructor will need to put
5184 subret
= gimplify_init_constructor (expr_p
, NULL
, NULL
,
5186 if (subret
== GS_ERROR
)
5188 /* If so, revert the change. */
5200 /* If we have code like
5204 where the type of "x" is a (possibly cv-qualified variant
5205 of "A"), treat the entire expression as identical to "x".
5206 This kind of code arises in C++ when an object is bound
5207 to a const reference, and if "x" is a TARGET_EXPR we want
5208 to take advantage of the optimization below. */
5209 bool volatile_p
= TREE_THIS_VOLATILE (*from_p
);
5210 tree t
= gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p
, 0));
5213 if (TREE_THIS_VOLATILE (t
) != volatile_p
)
5216 t
= build_simple_mem_ref_loc (EXPR_LOCATION (*from_p
),
5217 build_fold_addr_expr (t
));
5218 if (REFERENCE_CLASS_P (t
))
5219 TREE_THIS_VOLATILE (t
) = volatile_p
;
5230 /* If we are initializing something from a TARGET_EXPR, strip the
5231 TARGET_EXPR and initialize it directly, if possible. This can't
5232 be done if the initializer is void, since that implies that the
5233 temporary is set in some non-trivial way.
5235 ??? What about code that pulls out the temp and uses it
5236 elsewhere? I think that such code never uses the TARGET_EXPR as
5237 an initializer. If I'm wrong, we'll die because the temp won't
5238 have any RTL. In that case, I guess we'll need to replace
5239 references somehow. */
5240 tree init
= TARGET_EXPR_INITIAL (*from_p
);
5243 && (TREE_CODE (*expr_p
) != MODIFY_EXPR
5244 || !TARGET_EXPR_NO_ELIDE (*from_p
))
5245 && !VOID_TYPE_P (TREE_TYPE (init
)))
5255 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
5257 gimplify_compound_expr (from_p
, pre_p
, true);
5263 /* If we already made some changes, let the front end have a
5264 crack at this before we break it down. */
5265 if (ret
!= GS_UNHANDLED
)
5267 /* If we're initializing from a CONSTRUCTOR, break this into
5268 individual MODIFY_EXPRs. */
5269 return gimplify_init_constructor (expr_p
, pre_p
, post_p
, want_value
,
5273 /* If we're assigning to a non-register type, push the assignment
5274 down into the branches. This is mandatory for ADDRESSABLE types,
5275 since we cannot generate temporaries for such, but it saves a
5276 copy in other cases as well. */
5277 if (!is_gimple_reg_type (TREE_TYPE (*from_p
)))
5279 /* This code should mirror the code in gimplify_cond_expr. */
5280 enum tree_code code
= TREE_CODE (*expr_p
);
5281 tree cond
= *from_p
;
5282 tree result
= *to_p
;
5284 ret
= gimplify_expr (&result
, pre_p
, post_p
,
5285 is_gimple_lvalue
, fb_lvalue
);
5286 if (ret
!= GS_ERROR
)
5289 /* If we are going to write RESULT more than once, clear
5290 TREE_READONLY flag, otherwise we might incorrectly promote
5291 the variable to static const and initialize it at compile
5292 time in one of the branches. */
5294 && TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
5295 && TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
5296 TREE_READONLY (result
) = 0;
5297 if (TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
)
5298 TREE_OPERAND (cond
, 1)
5299 = build2 (code
, void_type_node
, result
,
5300 TREE_OPERAND (cond
, 1));
5301 if (TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
5302 TREE_OPERAND (cond
, 2)
5303 = build2 (code
, void_type_node
, unshare_expr (result
),
5304 TREE_OPERAND (cond
, 2));
5306 TREE_TYPE (cond
) = void_type_node
;
5307 recalculate_side_effects (cond
);
5311 gimplify_and_add (cond
, pre_p
);
5312 *expr_p
= unshare_expr (result
);
5321 /* For calls that return in memory, give *to_p as the CALL_EXPR's
5322 return slot so that we don't generate a temporary. */
5323 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p
)
5324 && aggregate_value_p (*from_p
, *from_p
))
5328 if (!(rhs_predicate_for (*to_p
))(*from_p
))
5329 /* If we need a temporary, *to_p isn't accurate. */
5331 /* It's OK to use the return slot directly unless it's an NRV. */
5332 else if (TREE_CODE (*to_p
) == RESULT_DECL
5333 && DECL_NAME (*to_p
) == NULL_TREE
5334 && needs_to_live_in_memory (*to_p
))
5336 else if (is_gimple_reg_type (TREE_TYPE (*to_p
))
5337 || (DECL_P (*to_p
) && DECL_REGISTER (*to_p
)))
5338 /* Don't force regs into memory. */
5340 else if (TREE_CODE (*expr_p
) == INIT_EXPR
)
5341 /* It's OK to use the target directly if it's being
5344 else if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (*to_p
)))
5346 /* Always use the target and thus RSO for variable-sized types.
5347 GIMPLE cannot deal with a variable-sized assignment
5348 embedded in a call statement. */
5350 else if (TREE_CODE (*to_p
) != SSA_NAME
5351 && (!is_gimple_variable (*to_p
)
5352 || needs_to_live_in_memory (*to_p
)))
5353 /* Don't use the original target if it's already addressable;
5354 if its address escapes, and the called function uses the
5355 NRV optimization, a conforming program could see *to_p
5356 change before the called function returns; see c++/19317.
5357 When optimizing, the return_slot pass marks more functions
5358 as safe after we have escape info. */
5365 CALL_EXPR_RETURN_SLOT_OPT (*from_p
) = 1;
5366 mark_addressable (*to_p
);
5371 case WITH_SIZE_EXPR
:
5372 /* Likewise for calls that return an aggregate of non-constant size,
5373 since we would not be able to generate a temporary at all. */
5374 if (TREE_CODE (TREE_OPERAND (*from_p
, 0)) == CALL_EXPR
)
5376 *from_p
= TREE_OPERAND (*from_p
, 0);
5377 /* We don't change ret in this case because the
5378 WITH_SIZE_EXPR might have been added in
5379 gimplify_modify_expr, so returning GS_OK would lead to an
5385 /* If we're initializing from a container, push the initialization
5387 case CLEANUP_POINT_EXPR
:
5389 case STATEMENT_LIST
:
5391 tree wrap
= *from_p
;
5394 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_min_lval
,
5396 if (ret
!= GS_ERROR
)
5399 t
= voidify_wrapper_expr (wrap
, *expr_p
);
5400 gcc_assert (t
== *expr_p
);
5404 gimplify_and_add (wrap
, pre_p
);
5405 *expr_p
= unshare_expr (*to_p
);
5412 case COMPOUND_LITERAL_EXPR
:
5414 tree complit
= TREE_OPERAND (*expr_p
, 1);
5415 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (complit
);
5416 tree decl
= DECL_EXPR_DECL (decl_s
);
5417 tree init
= DECL_INITIAL (decl
);
5419 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
5420 into struct T x = { 0, 1, 2 } if the address of the
5421 compound literal has never been taken. */
5422 if (!TREE_ADDRESSABLE (complit
)
5423 && !TREE_ADDRESSABLE (decl
)
5426 *expr_p
= copy_node (*expr_p
);
5427 TREE_OPERAND (*expr_p
, 1) = init
;
5442 /* Return true if T looks like a valid GIMPLE statement. */
5445 is_gimple_stmt (tree t
)
5447 const enum tree_code code
= TREE_CODE (t
);
5452 /* The only valid NOP_EXPR is the empty statement. */
5453 return IS_EMPTY_STMT (t
);
5457 /* These are only valid if they're void. */
5458 return TREE_TYPE (t
) == NULL
|| VOID_TYPE_P (TREE_TYPE (t
));
5464 case CASE_LABEL_EXPR
:
5465 case TRY_CATCH_EXPR
:
5466 case TRY_FINALLY_EXPR
:
5467 case EH_FILTER_EXPR
:
5470 case STATEMENT_LIST
:
5474 case OACC_HOST_DATA
:
5477 case OACC_ENTER_DATA
:
5478 case OACC_EXIT_DATA
:
5483 case OMP_DISTRIBUTE
:
5494 case OMP_TARGET_DATA
:
5495 case OMP_TARGET_UPDATE
:
5496 case OMP_TARGET_ENTER_DATA
:
5497 case OMP_TARGET_EXIT_DATA
:
5500 /* These are always void. */
5506 /* These are valid regardless of their type. */
5515 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
5516 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
5517 DECL_GIMPLE_REG_P set.
5519 IMPORTANT NOTE: This promotion is performed by introducing a load of the
5520 other, unmodified part of the complex object just before the total store.
5521 As a consequence, if the object is still uninitialized, an undefined value
5522 will be loaded into a register, which may result in a spurious exception
5523 if the register is floating-point and the value happens to be a signaling
5524 NaN for example. Then the fully-fledged complex operations lowering pass
5525 followed by a DCE pass are necessary in order to fix things up. */
5527 static enum gimplify_status
5528 gimplify_modify_expr_complex_part (tree
*expr_p
, gimple_seq
*pre_p
,
5531 enum tree_code code
, ocode
;
5532 tree lhs
, rhs
, new_rhs
, other
, realpart
, imagpart
;
5534 lhs
= TREE_OPERAND (*expr_p
, 0);
5535 rhs
= TREE_OPERAND (*expr_p
, 1);
5536 code
= TREE_CODE (lhs
);
5537 lhs
= TREE_OPERAND (lhs
, 0);
5539 ocode
= code
== REALPART_EXPR
? IMAGPART_EXPR
: REALPART_EXPR
;
5540 other
= build1 (ocode
, TREE_TYPE (rhs
), lhs
);
5541 TREE_NO_WARNING (other
) = 1;
5542 other
= get_formal_tmp_var (other
, pre_p
);
5544 realpart
= code
== REALPART_EXPR
? rhs
: other
;
5545 imagpart
= code
== REALPART_EXPR
? other
: rhs
;
5547 if (TREE_CONSTANT (realpart
) && TREE_CONSTANT (imagpart
))
5548 new_rhs
= build_complex (TREE_TYPE (lhs
), realpart
, imagpart
);
5550 new_rhs
= build2 (COMPLEX_EXPR
, TREE_TYPE (lhs
), realpart
, imagpart
);
5552 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (lhs
, new_rhs
));
5553 *expr_p
= (want_value
) ? rhs
: NULL_TREE
;
5558 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
5564 PRE_P points to the list where side effects that must happen before
5565 *EXPR_P should be stored.
5567 POST_P points to the list where side effects that must happen after
5568 *EXPR_P should be stored.
5570 WANT_VALUE is nonzero iff we want to use the value of this expression
5571 in another expression. */
5573 static enum gimplify_status
5574 gimplify_modify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
5577 tree
*from_p
= &TREE_OPERAND (*expr_p
, 1);
5578 tree
*to_p
= &TREE_OPERAND (*expr_p
, 0);
5579 enum gimplify_status ret
= GS_UNHANDLED
;
5581 location_t loc
= EXPR_LOCATION (*expr_p
);
5582 gimple_stmt_iterator gsi
;
5584 gcc_assert (TREE_CODE (*expr_p
) == MODIFY_EXPR
5585 || TREE_CODE (*expr_p
) == INIT_EXPR
);
5587 /* Trying to simplify a clobber using normal logic doesn't work,
5588 so handle it here. */
5589 if (TREE_CLOBBER_P (*from_p
))
5591 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
5592 if (ret
== GS_ERROR
)
5594 gcc_assert (!want_value
);
5595 if (!VAR_P (*to_p
) && TREE_CODE (*to_p
) != MEM_REF
)
5597 tree addr
= get_initialized_tmp_var (build_fold_addr_expr (*to_p
),
5599 *to_p
= build_simple_mem_ref_loc (EXPR_LOCATION (*to_p
), addr
);
5601 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (*to_p
, *from_p
));
5606 /* Insert pointer conversions required by the middle-end that are not
5607 required by the frontend. This fixes middle-end type checking for
5608 for example gcc.dg/redecl-6.c. */
5609 if (POINTER_TYPE_P (TREE_TYPE (*to_p
)))
5611 STRIP_USELESS_TYPE_CONVERSION (*from_p
);
5612 if (!useless_type_conversion_p (TREE_TYPE (*to_p
), TREE_TYPE (*from_p
)))
5613 *from_p
= fold_convert_loc (loc
, TREE_TYPE (*to_p
), *from_p
);
5616 /* See if any simplifications can be done based on what the RHS is. */
5617 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
5619 if (ret
!= GS_UNHANDLED
)
5622 /* For zero sized types only gimplify the left hand side and right hand
5623 side as statements and throw away the assignment. Do this after
5624 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
5626 if (zero_sized_type (TREE_TYPE (*from_p
))
5628 /* Don't do this for calls that return addressable types, expand_call
5629 relies on those having a lhs. */
5630 && !(TREE_ADDRESSABLE (TREE_TYPE (*from_p
))
5631 && TREE_CODE (*from_p
) == CALL_EXPR
))
5633 gimplify_stmt (from_p
, pre_p
);
5634 gimplify_stmt (to_p
, pre_p
);
5635 *expr_p
= NULL_TREE
;
5639 /* If the value being copied is of variable width, compute the length
5640 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
5641 before gimplifying any of the operands so that we can resolve any
5642 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
5643 the size of the expression to be copied, not of the destination, so
5644 that is what we must do here. */
5645 maybe_with_size_expr (from_p
);
5647 /* As a special case, we have to temporarily allow for assignments
5648 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
5649 a toplevel statement, when gimplifying the GENERIC expression
5650 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
5651 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
5653 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
5654 prevent gimplify_expr from trying to create a new temporary for
5655 foo's LHS, we tell it that it should only gimplify until it
5656 reaches the CALL_EXPR. On return from gimplify_expr, the newly
5657 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
5658 and all we need to do here is set 'a' to be its LHS. */
5660 /* Gimplify the RHS first for C++17 and bug 71104. */
5661 gimple_predicate initial_pred
= initial_rhs_predicate_for (*to_p
);
5662 ret
= gimplify_expr (from_p
, pre_p
, post_p
, initial_pred
, fb_rvalue
);
5663 if (ret
== GS_ERROR
)
5666 /* Then gimplify the LHS. */
5667 /* If we gimplified the RHS to a CALL_EXPR and that call may return
5668 twice we have to make sure to gimplify into non-SSA as otherwise
5669 the abnormal edge added later will make those defs not dominate
5671 ??? Technically this applies only to the registers used in the
5672 resulting non-register *TO_P. */
5673 bool saved_into_ssa
= gimplify_ctxp
->into_ssa
;
5675 && TREE_CODE (*from_p
) == CALL_EXPR
5676 && call_expr_flags (*from_p
) & ECF_RETURNS_TWICE
)
5677 gimplify_ctxp
->into_ssa
= false;
5678 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
5679 gimplify_ctxp
->into_ssa
= saved_into_ssa
;
5680 if (ret
== GS_ERROR
)
5683 /* Now that the LHS is gimplified, re-gimplify the RHS if our initial
5684 guess for the predicate was wrong. */
5685 gimple_predicate final_pred
= rhs_predicate_for (*to_p
);
5686 if (final_pred
!= initial_pred
)
5688 ret
= gimplify_expr (from_p
, pre_p
, post_p
, final_pred
, fb_rvalue
);
5689 if (ret
== GS_ERROR
)
5693 /* In case of va_arg internal fn wrappped in a WITH_SIZE_EXPR, add the type
5694 size as argument to the call. */
5695 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
5697 tree call
= TREE_OPERAND (*from_p
, 0);
5698 tree vlasize
= TREE_OPERAND (*from_p
, 1);
5700 if (TREE_CODE (call
) == CALL_EXPR
5701 && CALL_EXPR_IFN (call
) == IFN_VA_ARG
)
5703 int nargs
= call_expr_nargs (call
);
5704 tree type
= TREE_TYPE (call
);
5705 tree ap
= CALL_EXPR_ARG (call
, 0);
5706 tree tag
= CALL_EXPR_ARG (call
, 1);
5707 tree aptag
= CALL_EXPR_ARG (call
, 2);
5708 tree newcall
= build_call_expr_internal_loc (EXPR_LOCATION (call
),
5712 TREE_OPERAND (*from_p
, 0) = newcall
;
5716 /* Now see if the above changed *from_p to something we handle specially. */
5717 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
5719 if (ret
!= GS_UNHANDLED
)
5722 /* If we've got a variable sized assignment between two lvalues (i.e. does
5723 not involve a call), then we can make things a bit more straightforward
5724 by converting the assignment to memcpy or memset. */
5725 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
5727 tree from
= TREE_OPERAND (*from_p
, 0);
5728 tree size
= TREE_OPERAND (*from_p
, 1);
5730 if (TREE_CODE (from
) == CONSTRUCTOR
)
5731 return gimplify_modify_expr_to_memset (expr_p
, size
, want_value
, pre_p
);
5733 if (is_gimple_addressable (from
))
5736 return gimplify_modify_expr_to_memcpy (expr_p
, size
, want_value
,
5741 /* Transform partial stores to non-addressable complex variables into
5742 total stores. This allows us to use real instead of virtual operands
5743 for these variables, which improves optimization. */
5744 if ((TREE_CODE (*to_p
) == REALPART_EXPR
5745 || TREE_CODE (*to_p
) == IMAGPART_EXPR
)
5746 && is_gimple_reg (TREE_OPERAND (*to_p
, 0)))
5747 return gimplify_modify_expr_complex_part (expr_p
, pre_p
, want_value
);
5749 /* Try to alleviate the effects of the gimplification creating artificial
5750 temporaries (see for example is_gimple_reg_rhs) on the debug info, but
5751 make sure not to create DECL_DEBUG_EXPR links across functions. */
5752 if (!gimplify_ctxp
->into_ssa
5754 && DECL_IGNORED_P (*from_p
)
5756 && !DECL_IGNORED_P (*to_p
)
5757 && decl_function_context (*to_p
) == current_function_decl
5758 && decl_function_context (*from_p
) == current_function_decl
)
5760 if (!DECL_NAME (*from_p
) && DECL_NAME (*to_p
))
5762 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p
)));
5763 DECL_HAS_DEBUG_EXPR_P (*from_p
) = 1;
5764 SET_DECL_DEBUG_EXPR (*from_p
, *to_p
);
5767 if (want_value
&& TREE_THIS_VOLATILE (*to_p
))
5768 *from_p
= get_initialized_tmp_var (*from_p
, pre_p
, post_p
);
5770 if (TREE_CODE (*from_p
) == CALL_EXPR
)
5772 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
5773 instead of a GIMPLE_ASSIGN. */
5775 if (CALL_EXPR_FN (*from_p
) == NULL_TREE
)
5777 /* Gimplify internal functions created in the FEs. */
5778 int nargs
= call_expr_nargs (*from_p
), i
;
5779 enum internal_fn ifn
= CALL_EXPR_IFN (*from_p
);
5780 auto_vec
<tree
> vargs (nargs
);
5782 for (i
= 0; i
< nargs
; i
++)
5784 gimplify_arg (&CALL_EXPR_ARG (*from_p
, i
), pre_p
,
5785 EXPR_LOCATION (*from_p
));
5786 vargs
.quick_push (CALL_EXPR_ARG (*from_p
, i
));
5788 call_stmt
= gimple_build_call_internal_vec (ifn
, vargs
);
5789 gimple_call_set_nothrow (call_stmt
, TREE_NOTHROW (*from_p
));
5790 gimple_set_location (call_stmt
, EXPR_LOCATION (*expr_p
));
5794 tree fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*from_p
));
5795 CALL_EXPR_FN (*from_p
) = TREE_OPERAND (CALL_EXPR_FN (*from_p
), 0);
5796 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p
));
5797 tree fndecl
= get_callee_fndecl (*from_p
);
5799 && fndecl_built_in_p (fndecl
, BUILT_IN_EXPECT
)
5800 && call_expr_nargs (*from_p
) == 3)
5801 call_stmt
= gimple_build_call_internal (IFN_BUILTIN_EXPECT
, 3,
5802 CALL_EXPR_ARG (*from_p
, 0),
5803 CALL_EXPR_ARG (*from_p
, 1),
5804 CALL_EXPR_ARG (*from_p
, 2));
5807 call_stmt
= gimple_build_call_from_tree (*from_p
, fnptrtype
);
5810 notice_special_calls (call_stmt
);
5811 if (!gimple_call_noreturn_p (call_stmt
) || !should_remove_lhs_p (*to_p
))
5812 gimple_call_set_lhs (call_stmt
, *to_p
);
5813 else if (TREE_CODE (*to_p
) == SSA_NAME
)
5814 /* The above is somewhat premature, avoid ICEing later for a
5815 SSA name w/o a definition. We may have uses in the GIMPLE IL.
5816 ??? This doesn't make it a default-def. */
5817 SSA_NAME_DEF_STMT (*to_p
) = gimple_build_nop ();
5823 assign
= gimple_build_assign (*to_p
, *from_p
);
5824 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
5825 if (COMPARISON_CLASS_P (*from_p
))
5826 gimple_set_no_warning (assign
, TREE_NO_WARNING (*from_p
));
5829 if (gimplify_ctxp
->into_ssa
&& is_gimple_reg (*to_p
))
5831 /* We should have got an SSA name from the start. */
5832 gcc_assert (TREE_CODE (*to_p
) == SSA_NAME
5833 || ! gimple_in_ssa_p (cfun
));
5836 gimplify_seq_add_stmt (pre_p
, assign
);
5837 gsi
= gsi_last (*pre_p
);
5838 maybe_fold_stmt (&gsi
);
5842 *expr_p
= TREE_THIS_VOLATILE (*to_p
) ? *from_p
: unshare_expr (*to_p
);
5851 /* Gimplify a comparison between two variable-sized objects. Do this
5852 with a call to BUILT_IN_MEMCMP. */
5854 static enum gimplify_status
5855 gimplify_variable_sized_compare (tree
*expr_p
)
5857 location_t loc
= EXPR_LOCATION (*expr_p
);
5858 tree op0
= TREE_OPERAND (*expr_p
, 0);
5859 tree op1
= TREE_OPERAND (*expr_p
, 1);
5860 tree t
, arg
, dest
, src
, expr
;
5862 arg
= TYPE_SIZE_UNIT (TREE_TYPE (op0
));
5863 arg
= unshare_expr (arg
);
5864 arg
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg
, op0
);
5865 src
= build_fold_addr_expr_loc (loc
, op1
);
5866 dest
= build_fold_addr_expr_loc (loc
, op0
);
5867 t
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
5868 t
= build_call_expr_loc (loc
, t
, 3, dest
, src
, arg
);
5871 = build2 (TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), t
, integer_zero_node
);
5872 SET_EXPR_LOCATION (expr
, loc
);
5878 /* Gimplify a comparison between two aggregate objects of integral scalar
5879 mode as a comparison between the bitwise equivalent scalar values. */
5881 static enum gimplify_status
5882 gimplify_scalar_mode_aggregate_compare (tree
*expr_p
)
5884 location_t loc
= EXPR_LOCATION (*expr_p
);
5885 tree op0
= TREE_OPERAND (*expr_p
, 0);
5886 tree op1
= TREE_OPERAND (*expr_p
, 1);
5888 tree type
= TREE_TYPE (op0
);
5889 tree scalar_type
= lang_hooks
.types
.type_for_mode (TYPE_MODE (type
), 1);
5891 op0
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op0
);
5892 op1
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op1
);
5895 = fold_build2_loc (loc
, TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), op0
, op1
);
5900 /* Gimplify an expression sequence. This function gimplifies each
5901 expression and rewrites the original expression with the last
5902 expression of the sequence in GIMPLE form.
5904 PRE_P points to the list where the side effects for all the
5905 expressions in the sequence will be emitted.
5907 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
5909 static enum gimplify_status
5910 gimplify_compound_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
5916 tree
*sub_p
= &TREE_OPERAND (t
, 0);
5918 if (TREE_CODE (*sub_p
) == COMPOUND_EXPR
)
5919 gimplify_compound_expr (sub_p
, pre_p
, false);
5921 gimplify_stmt (sub_p
, pre_p
);
5923 t
= TREE_OPERAND (t
, 1);
5925 while (TREE_CODE (t
) == COMPOUND_EXPR
);
5932 gimplify_stmt (expr_p
, pre_p
);
5937 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
5938 gimplify. After gimplification, EXPR_P will point to a new temporary
5939 that holds the original value of the SAVE_EXPR node.
5941 PRE_P points to the list where side effects that must happen before
5942 *EXPR_P should be stored. */
5944 static enum gimplify_status
5945 gimplify_save_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5947 enum gimplify_status ret
= GS_ALL_DONE
;
5950 gcc_assert (TREE_CODE (*expr_p
) == SAVE_EXPR
);
5951 val
= TREE_OPERAND (*expr_p
, 0);
5953 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
5954 if (!SAVE_EXPR_RESOLVED_P (*expr_p
))
5956 /* The operand may be a void-valued expression. It is
5957 being executed only for its side-effects. */
5958 if (TREE_TYPE (val
) == void_type_node
)
5960 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
5961 is_gimple_stmt
, fb_none
);
5965 /* The temporary may not be an SSA name as later abnormal and EH
5966 control flow may invalidate use/def domination. When in SSA
5967 form then assume there are no such issues and SAVE_EXPRs only
5968 appear via GENERIC foldings. */
5969 val
= get_initialized_tmp_var (val
, pre_p
, post_p
,
5970 gimple_in_ssa_p (cfun
));
5972 TREE_OPERAND (*expr_p
, 0) = val
;
5973 SAVE_EXPR_RESOLVED_P (*expr_p
) = 1;
5981 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
5988 PRE_P points to the list where side effects that must happen before
5989 *EXPR_P should be stored.
5991 POST_P points to the list where side effects that must happen after
5992 *EXPR_P should be stored. */
5994 static enum gimplify_status
5995 gimplify_addr_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5997 tree expr
= *expr_p
;
5998 tree op0
= TREE_OPERAND (expr
, 0);
5999 enum gimplify_status ret
;
6000 location_t loc
= EXPR_LOCATION (*expr_p
);
6002 switch (TREE_CODE (op0
))
6006 /* Check if we are dealing with an expression of the form '&*ptr'.
6007 While the front end folds away '&*ptr' into 'ptr', these
6008 expressions may be generated internally by the compiler (e.g.,
6009 builtins like __builtin_va_end). */
6010 /* Caution: the silent array decomposition semantics we allow for
6011 ADDR_EXPR means we can't always discard the pair. */
6012 /* Gimplification of the ADDR_EXPR operand may drop
6013 cv-qualification conversions, so make sure we add them if
6016 tree op00
= TREE_OPERAND (op0
, 0);
6017 tree t_expr
= TREE_TYPE (expr
);
6018 tree t_op00
= TREE_TYPE (op00
);
6020 if (!useless_type_conversion_p (t_expr
, t_op00
))
6021 op00
= fold_convert_loc (loc
, TREE_TYPE (expr
), op00
);
6027 case VIEW_CONVERT_EXPR
:
6028 /* Take the address of our operand and then convert it to the type of
6031 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
6032 all clear. The impact of this transformation is even less clear. */
6034 /* If the operand is a useless conversion, look through it. Doing so
6035 guarantees that the ADDR_EXPR and its operand will remain of the
6037 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0
, 0)))
6038 op0
= TREE_OPERAND (op0
, 0);
6040 *expr_p
= fold_convert_loc (loc
, TREE_TYPE (expr
),
6041 build_fold_addr_expr_loc (loc
,
6042 TREE_OPERAND (op0
, 0)));
6047 if (integer_zerop (TREE_OPERAND (op0
, 1)))
6048 goto do_indirect_ref
;
6053 /* If we see a call to a declared builtin or see its address
6054 being taken (we can unify those cases here) then we can mark
6055 the builtin for implicit generation by GCC. */
6056 if (TREE_CODE (op0
) == FUNCTION_DECL
6057 && fndecl_built_in_p (op0
, BUILT_IN_NORMAL
)
6058 && builtin_decl_declared_p (DECL_FUNCTION_CODE (op0
)))
6059 set_builtin_decl_implicit_p (DECL_FUNCTION_CODE (op0
), true);
6061 /* We use fb_either here because the C frontend sometimes takes
6062 the address of a call that returns a struct; see
6063 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
6064 the implied temporary explicit. */
6066 /* Make the operand addressable. */
6067 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, post_p
,
6068 is_gimple_addressable
, fb_either
);
6069 if (ret
== GS_ERROR
)
6072 /* Then mark it. Beware that it may not be possible to do so directly
6073 if a temporary has been created by the gimplification. */
6074 prepare_gimple_addressable (&TREE_OPERAND (expr
, 0), pre_p
);
6076 op0
= TREE_OPERAND (expr
, 0);
6078 /* For various reasons, the gimplification of the expression
6079 may have made a new INDIRECT_REF. */
6080 if (TREE_CODE (op0
) == INDIRECT_REF
)
6081 goto do_indirect_ref
;
6083 mark_addressable (TREE_OPERAND (expr
, 0));
6085 /* The FEs may end up building ADDR_EXPRs early on a decl with
6086 an incomplete type. Re-build ADDR_EXPRs in canonical form
6088 if (!types_compatible_p (TREE_TYPE (op0
), TREE_TYPE (TREE_TYPE (expr
))))
6089 *expr_p
= build_fold_addr_expr (op0
);
6091 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
6092 recompute_tree_invariant_for_addr_expr (*expr_p
);
6094 /* If we re-built the ADDR_EXPR add a conversion to the original type
6096 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
6097 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
6105 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
6106 value; output operands should be a gimple lvalue. */
6108 static enum gimplify_status
6109 gimplify_asm_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
6113 const char **oconstraints
;
6116 const char *constraint
;
6117 bool allows_mem
, allows_reg
, is_inout
;
6118 enum gimplify_status ret
, tret
;
6120 vec
<tree
, va_gc
> *inputs
;
6121 vec
<tree
, va_gc
> *outputs
;
6122 vec
<tree
, va_gc
> *clobbers
;
6123 vec
<tree
, va_gc
> *labels
;
6127 noutputs
= list_length (ASM_OUTPUTS (expr
));
6128 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
6136 link_next
= NULL_TREE
;
6137 for (i
= 0, link
= ASM_OUTPUTS (expr
); link
; ++i
, link
= link_next
)
6140 size_t constraint_len
;
6142 link_next
= TREE_CHAIN (link
);
6146 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
6147 constraint_len
= strlen (constraint
);
6148 if (constraint_len
== 0)
6151 ok
= parse_output_constraint (&constraint
, i
, 0, 0,
6152 &allows_mem
, &allows_reg
, &is_inout
);
6159 /* If we can't make copies, we can only accept memory. */
6160 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link
))))
6166 error ("impossible constraint in %<asm%>");
6167 error ("non-memory output %d must stay in memory", i
);
6172 if (!allows_reg
&& allows_mem
)
6173 mark_addressable (TREE_VALUE (link
));
6175 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
6176 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
6177 fb_lvalue
| fb_mayfail
);
6178 if (tret
== GS_ERROR
)
6180 error ("invalid lvalue in asm output %d", i
);
6184 /* If the constraint does not allow memory make sure we gimplify
6185 it to a register if it is not already but its base is. This
6186 happens for complex and vector components. */
6189 tree op
= TREE_VALUE (link
);
6190 if (! is_gimple_val (op
)
6191 && is_gimple_reg_type (TREE_TYPE (op
))
6192 && is_gimple_reg (get_base_address (op
)))
6194 tree tem
= create_tmp_reg (TREE_TYPE (op
));
6198 ass
= build2 (MODIFY_EXPR
, TREE_TYPE (tem
),
6199 tem
, unshare_expr (op
));
6200 gimplify_and_add (ass
, pre_p
);
6202 ass
= build2 (MODIFY_EXPR
, TREE_TYPE (tem
), op
, tem
);
6203 gimplify_and_add (ass
, post_p
);
6205 TREE_VALUE (link
) = tem
;
6210 vec_safe_push (outputs
, link
);
6211 TREE_CHAIN (link
) = NULL_TREE
;
6215 /* An input/output operand. To give the optimizers more
6216 flexibility, split it into separate input and output
6219 /* Buffer big enough to format a 32-bit UINT_MAX into. */
6222 /* Turn the in/out constraint into an output constraint. */
6223 char *p
= xstrdup (constraint
);
6225 TREE_VALUE (TREE_PURPOSE (link
)) = build_string (constraint_len
, p
);
6227 /* And add a matching input constraint. */
6230 sprintf (buf
, "%u", i
);
6232 /* If there are multiple alternatives in the constraint,
6233 handle each of them individually. Those that allow register
6234 will be replaced with operand number, the others will stay
6236 if (strchr (p
, ',') != NULL
)
6238 size_t len
= 0, buflen
= strlen (buf
);
6239 char *beg
, *end
, *str
, *dst
;
6243 end
= strchr (beg
, ',');
6245 end
= strchr (beg
, '\0');
6246 if ((size_t) (end
- beg
) < buflen
)
6249 len
+= end
- beg
+ 1;
6256 str
= (char *) alloca (len
);
6257 for (beg
= p
+ 1, dst
= str
;;)
6260 bool mem_p
, reg_p
, inout_p
;
6262 end
= strchr (beg
, ',');
6267 parse_output_constraint (&tem
, i
, 0, 0,
6268 &mem_p
, ®_p
, &inout_p
);
6273 memcpy (dst
, buf
, buflen
);
6282 memcpy (dst
, beg
, len
);
6291 input
= build_string (dst
- str
, str
);
6294 input
= build_string (strlen (buf
), buf
);
6297 input
= build_string (constraint_len
- 1, constraint
+ 1);
6301 input
= build_tree_list (build_tree_list (NULL_TREE
, input
),
6302 unshare_expr (TREE_VALUE (link
)));
6303 ASM_INPUTS (expr
) = chainon (ASM_INPUTS (expr
), input
);
6307 link_next
= NULL_TREE
;
6308 for (link
= ASM_INPUTS (expr
); link
; ++i
, link
= link_next
)
6310 link_next
= TREE_CHAIN (link
);
6311 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
6312 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
6313 oconstraints
, &allows_mem
, &allows_reg
);
6315 /* If we can't make copies, we can only accept memory. */
6316 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link
))))
6322 error ("impossible constraint in %<asm%>");
6323 error ("non-memory input %d must stay in memory", i
);
6328 /* If the operand is a memory input, it should be an lvalue. */
6329 if (!allows_reg
&& allows_mem
)
6331 tree inputv
= TREE_VALUE (link
);
6332 STRIP_NOPS (inputv
);
6333 if (TREE_CODE (inputv
) == PREDECREMENT_EXPR
6334 || TREE_CODE (inputv
) == PREINCREMENT_EXPR
6335 || TREE_CODE (inputv
) == POSTDECREMENT_EXPR
6336 || TREE_CODE (inputv
) == POSTINCREMENT_EXPR
6337 || TREE_CODE (inputv
) == MODIFY_EXPR
)
6338 TREE_VALUE (link
) = error_mark_node
;
6339 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
6340 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
6341 if (tret
!= GS_ERROR
)
6343 /* Unlike output operands, memory inputs are not guaranteed
6344 to be lvalues by the FE, and while the expressions are
6345 marked addressable there, if it is e.g. a statement
6346 expression, temporaries in it might not end up being
6347 addressable. They might be already used in the IL and thus
6348 it is too late to make them addressable now though. */
6349 tree x
= TREE_VALUE (link
);
6350 while (handled_component_p (x
))
6351 x
= TREE_OPERAND (x
, 0);
6352 if (TREE_CODE (x
) == MEM_REF
6353 && TREE_CODE (TREE_OPERAND (x
, 0)) == ADDR_EXPR
)
6354 x
= TREE_OPERAND (TREE_OPERAND (x
, 0), 0);
6356 || TREE_CODE (x
) == PARM_DECL
6357 || TREE_CODE (x
) == RESULT_DECL
)
6358 && !TREE_ADDRESSABLE (x
)
6359 && is_gimple_reg (x
))
6361 warning_at (EXPR_LOC_OR_LOC (TREE_VALUE (link
),
6363 "memory input %d is not directly addressable",
6365 prepare_gimple_addressable (&TREE_VALUE (link
), pre_p
);
6368 mark_addressable (TREE_VALUE (link
));
6369 if (tret
== GS_ERROR
)
6371 error_at (EXPR_LOC_OR_LOC (TREE_VALUE (link
), input_location
),
6372 "memory input %d is not directly addressable", i
);
6378 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
6379 is_gimple_asm_val
, fb_rvalue
);
6380 if (tret
== GS_ERROR
)
6384 TREE_CHAIN (link
) = NULL_TREE
;
6385 vec_safe_push (inputs
, link
);
6388 link_next
= NULL_TREE
;
6389 for (link
= ASM_CLOBBERS (expr
); link
; ++i
, link
= link_next
)
6391 link_next
= TREE_CHAIN (link
);
6392 TREE_CHAIN (link
) = NULL_TREE
;
6393 vec_safe_push (clobbers
, link
);
6396 link_next
= NULL_TREE
;
6397 for (link
= ASM_LABELS (expr
); link
; ++i
, link
= link_next
)
6399 link_next
= TREE_CHAIN (link
);
6400 TREE_CHAIN (link
) = NULL_TREE
;
6401 vec_safe_push (labels
, link
);
6404 /* Do not add ASMs with errors to the gimple IL stream. */
6405 if (ret
!= GS_ERROR
)
6407 stmt
= gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr
)),
6408 inputs
, outputs
, clobbers
, labels
);
6410 gimple_asm_set_volatile (stmt
, ASM_VOLATILE_P (expr
) || noutputs
== 0);
6411 gimple_asm_set_input (stmt
, ASM_INPUT_P (expr
));
6412 gimple_asm_set_inline (stmt
, ASM_INLINE_P (expr
));
6414 gimplify_seq_add_stmt (pre_p
, stmt
);
6420 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
6421 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
6422 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
6423 return to this function.
6425 FIXME should we complexify the prequeue handling instead? Or use flags
6426 for all the cleanups and let the optimizer tighten them up? The current
6427 code seems pretty fragile; it will break on a cleanup within any
6428 non-conditional nesting. But any such nesting would be broken, anyway;
6429 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
6430 and continues out of it. We can do that at the RTL level, though, so
6431 having an optimizer to tighten up try/finally regions would be a Good
6434 static enum gimplify_status
6435 gimplify_cleanup_point_expr (tree
*expr_p
, gimple_seq
*pre_p
)
6437 gimple_stmt_iterator iter
;
6438 gimple_seq body_sequence
= NULL
;
6440 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
6442 /* We only care about the number of conditions between the innermost
6443 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
6444 any cleanups collected outside the CLEANUP_POINT_EXPR. */
6445 int old_conds
= gimplify_ctxp
->conditions
;
6446 gimple_seq old_cleanups
= gimplify_ctxp
->conditional_cleanups
;
6447 bool old_in_cleanup_point_expr
= gimplify_ctxp
->in_cleanup_point_expr
;
6448 gimplify_ctxp
->conditions
= 0;
6449 gimplify_ctxp
->conditional_cleanups
= NULL
;
6450 gimplify_ctxp
->in_cleanup_point_expr
= true;
6452 gimplify_stmt (&TREE_OPERAND (*expr_p
, 0), &body_sequence
);
6454 gimplify_ctxp
->conditions
= old_conds
;
6455 gimplify_ctxp
->conditional_cleanups
= old_cleanups
;
6456 gimplify_ctxp
->in_cleanup_point_expr
= old_in_cleanup_point_expr
;
6458 for (iter
= gsi_start (body_sequence
); !gsi_end_p (iter
); )
6460 gimple
*wce
= gsi_stmt (iter
);
6462 if (gimple_code (wce
) == GIMPLE_WITH_CLEANUP_EXPR
)
6464 if (gsi_one_before_end_p (iter
))
6466 /* Note that gsi_insert_seq_before and gsi_remove do not
6467 scan operands, unlike some other sequence mutators. */
6468 if (!gimple_wce_cleanup_eh_only (wce
))
6469 gsi_insert_seq_before_without_update (&iter
,
6470 gimple_wce_cleanup (wce
),
6472 gsi_remove (&iter
, true);
6479 enum gimple_try_flags kind
;
6481 if (gimple_wce_cleanup_eh_only (wce
))
6482 kind
= GIMPLE_TRY_CATCH
;
6484 kind
= GIMPLE_TRY_FINALLY
;
6485 seq
= gsi_split_seq_after (iter
);
6487 gtry
= gimple_build_try (seq
, gimple_wce_cleanup (wce
), kind
);
6488 /* Do not use gsi_replace here, as it may scan operands.
6489 We want to do a simple structural modification only. */
6490 gsi_set_stmt (&iter
, gtry
);
6491 iter
= gsi_start (gtry
->eval
);
6498 gimplify_seq_add_seq (pre_p
, body_sequence
);
6511 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
6512 is the cleanup action required. EH_ONLY is true if the cleanup should
6513 only be executed if an exception is thrown, not on normal exit.
6514 If FORCE_UNCOND is true perform the cleanup unconditionally; this is
6515 only valid for clobbers. */
6518 gimple_push_cleanup (tree var
, tree cleanup
, bool eh_only
, gimple_seq
*pre_p
,
6519 bool force_uncond
= false)
6522 gimple_seq cleanup_stmts
= NULL
;
6524 /* Errors can result in improperly nested cleanups. Which results in
6525 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
6529 if (gimple_conditional_context ())
6531 /* If we're in a conditional context, this is more complex. We only
6532 want to run the cleanup if we actually ran the initialization that
6533 necessitates it, but we want to run it after the end of the
6534 conditional context. So we wrap the try/finally around the
6535 condition and use a flag to determine whether or not to actually
6536 run the destructor. Thus
6540 becomes (approximately)
6544 if (test) { A::A(temp); flag = 1; val = f(temp); }
6547 if (flag) A::~A(temp);
6553 gimplify_stmt (&cleanup
, &cleanup_stmts
);
6554 wce
= gimple_build_wce (cleanup_stmts
);
6555 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
6559 tree flag
= create_tmp_var (boolean_type_node
, "cleanup");
6560 gassign
*ffalse
= gimple_build_assign (flag
, boolean_false_node
);
6561 gassign
*ftrue
= gimple_build_assign (flag
, boolean_true_node
);
6563 cleanup
= build3 (COND_EXPR
, void_type_node
, flag
, cleanup
, NULL
);
6564 gimplify_stmt (&cleanup
, &cleanup_stmts
);
6565 wce
= gimple_build_wce (cleanup_stmts
);
6567 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, ffalse
);
6568 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
6569 gimplify_seq_add_stmt (pre_p
, ftrue
);
6571 /* Because of this manipulation, and the EH edges that jump
6572 threading cannot redirect, the temporary (VAR) will appear
6573 to be used uninitialized. Don't warn. */
6574 TREE_NO_WARNING (var
) = 1;
6579 gimplify_stmt (&cleanup
, &cleanup_stmts
);
6580 wce
= gimple_build_wce (cleanup_stmts
);
6581 gimple_wce_set_cleanup_eh_only (wce
, eh_only
);
6582 gimplify_seq_add_stmt (pre_p
, wce
);
6586 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
6588 static enum gimplify_status
6589 gimplify_target_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
6591 tree targ
= *expr_p
;
6592 tree temp
= TARGET_EXPR_SLOT (targ
);
6593 tree init
= TARGET_EXPR_INITIAL (targ
);
6594 enum gimplify_status ret
;
6596 bool unpoison_empty_seq
= false;
6597 gimple_stmt_iterator unpoison_it
;
6601 tree cleanup
= NULL_TREE
;
6603 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
6604 to the temps list. Handle also variable length TARGET_EXPRs. */
6605 if (TREE_CODE (DECL_SIZE (temp
)) != INTEGER_CST
)
6607 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp
)))
6608 gimplify_type_sizes (TREE_TYPE (temp
), pre_p
);
6609 gimplify_vla_decl (temp
, pre_p
);
6613 /* Save location where we need to place unpoisoning. It's possible
6614 that a variable will be converted to needs_to_live_in_memory. */
6615 unpoison_it
= gsi_last (*pre_p
);
6616 unpoison_empty_seq
= gsi_end_p (unpoison_it
);
6618 gimple_add_tmp_var (temp
);
6621 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
6622 expression is supposed to initialize the slot. */
6623 if (VOID_TYPE_P (TREE_TYPE (init
)))
6624 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
6627 tree init_expr
= build2 (INIT_EXPR
, void_type_node
, temp
, init
);
6629 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
6631 ggc_free (init_expr
);
6633 if (ret
== GS_ERROR
)
6635 /* PR c++/28266 Make sure this is expanded only once. */
6636 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
6640 gimplify_and_add (init
, pre_p
);
6642 /* If needed, push the cleanup for the temp. */
6643 if (TARGET_EXPR_CLEANUP (targ
))
6645 if (CLEANUP_EH_ONLY (targ
))
6646 gimple_push_cleanup (temp
, TARGET_EXPR_CLEANUP (targ
),
6647 CLEANUP_EH_ONLY (targ
), pre_p
);
6649 cleanup
= TARGET_EXPR_CLEANUP (targ
);
6652 /* Add a clobber for the temporary going out of scope, like
6653 gimplify_bind_expr. */
6654 if (gimplify_ctxp
->in_cleanup_point_expr
6655 && needs_to_live_in_memory (temp
))
6657 if (flag_stack_reuse
== SR_ALL
)
6659 tree clobber
= build_clobber (TREE_TYPE (temp
));
6660 clobber
= build2 (MODIFY_EXPR
, TREE_TYPE (temp
), temp
, clobber
);
6661 gimple_push_cleanup (temp
, clobber
, false, pre_p
, true);
6663 if (asan_poisoned_variables
6664 && DECL_ALIGN (temp
) <= MAX_SUPPORTED_STACK_ALIGNMENT
6665 && dbg_cnt (asan_use_after_scope
)
6666 && !gimplify_omp_ctxp
)
6668 tree asan_cleanup
= build_asan_poison_call_expr (temp
);
6671 if (unpoison_empty_seq
)
6672 unpoison_it
= gsi_start (*pre_p
);
6674 asan_poison_variable (temp
, false, &unpoison_it
,
6675 unpoison_empty_seq
);
6676 gimple_push_cleanup (temp
, asan_cleanup
, false, pre_p
);
6681 gimple_push_cleanup (temp
, cleanup
, false, pre_p
);
6683 /* Only expand this once. */
6684 TREE_OPERAND (targ
, 3) = init
;
6685 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
6688 /* We should have expanded this before. */
6689 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp
));
6695 /* Gimplification of expression trees. */
6697 /* Gimplify an expression which appears at statement context. The
6698 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
6699 NULL, a new sequence is allocated.
6701 Return true if we actually added a statement to the queue. */
6704 gimplify_stmt (tree
*stmt_p
, gimple_seq
*seq_p
)
6706 gimple_seq_node last
;
6708 last
= gimple_seq_last (*seq_p
);
6709 gimplify_expr (stmt_p
, seq_p
, NULL
, is_gimple_stmt
, fb_none
);
6710 return last
!= gimple_seq_last (*seq_p
);
6713 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
6714 to CTX. If entries already exist, force them to be some flavor of private.
6715 If there is no enclosing parallel, do nothing. */
6718 omp_firstprivatize_variable (struct gimplify_omp_ctx
*ctx
, tree decl
)
6722 if (decl
== NULL
|| !DECL_P (decl
) || ctx
->region_type
== ORT_NONE
)
6727 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
6730 if (n
->value
& GOVD_SHARED
)
6731 n
->value
= GOVD_FIRSTPRIVATE
| (n
->value
& GOVD_SEEN
);
6732 else if (n
->value
& GOVD_MAP
)
6733 n
->value
|= GOVD_MAP_TO_ONLY
;
6737 else if ((ctx
->region_type
& ORT_TARGET
) != 0)
6739 if (ctx
->defaultmap
[GDMK_SCALAR
] & GOVD_FIRSTPRIVATE
)
6740 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
6742 omp_add_variable (ctx
, decl
, GOVD_MAP
| GOVD_MAP_TO_ONLY
);
6744 else if (ctx
->region_type
!= ORT_WORKSHARE
6745 && ctx
->region_type
!= ORT_TASKGROUP
6746 && ctx
->region_type
!= ORT_SIMD
6747 && ctx
->region_type
!= ORT_ACC
6748 && !(ctx
->region_type
& ORT_TARGET_DATA
))
6749 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
6751 ctx
= ctx
->outer_context
;
6756 /* Similarly for each of the type sizes of TYPE. */
6759 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx
*ctx
, tree type
)
6761 if (type
== NULL
|| type
== error_mark_node
)
6763 type
= TYPE_MAIN_VARIANT (type
);
6765 if (ctx
->privatized_types
->add (type
))
6768 switch (TREE_CODE (type
))
6774 case FIXED_POINT_TYPE
:
6775 omp_firstprivatize_variable (ctx
, TYPE_MIN_VALUE (type
));
6776 omp_firstprivatize_variable (ctx
, TYPE_MAX_VALUE (type
));
6780 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
6781 omp_firstprivatize_type_sizes (ctx
, TYPE_DOMAIN (type
));
6786 case QUAL_UNION_TYPE
:
6789 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
6790 if (TREE_CODE (field
) == FIELD_DECL
)
6792 omp_firstprivatize_variable (ctx
, DECL_FIELD_OFFSET (field
));
6793 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (field
));
6799 case REFERENCE_TYPE
:
6800 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
6807 omp_firstprivatize_variable (ctx
, TYPE_SIZE (type
));
6808 omp_firstprivatize_variable (ctx
, TYPE_SIZE_UNIT (type
));
6809 lang_hooks
.types
.omp_firstprivatize_type_sizes (ctx
, type
);
6812 /* Add an entry for DECL in the OMP context CTX with FLAGS. */
6815 omp_add_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned int flags
)
6818 unsigned int nflags
;
6821 if (error_operand_p (decl
) || ctx
->region_type
== ORT_NONE
)
6824 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
6825 there are constructors involved somewhere. Exception is a shared clause,
6826 there is nothing privatized in that case. */
6827 if ((flags
& GOVD_SHARED
) == 0
6828 && (TREE_ADDRESSABLE (TREE_TYPE (decl
))
6829 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))))
6832 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
6833 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
6835 /* We shouldn't be re-adding the decl with the same data
6837 gcc_assert ((n
->value
& GOVD_DATA_SHARE_CLASS
& flags
) == 0);
6838 nflags
= n
->value
| flags
;
6839 /* The only combination of data sharing classes we should see is
6840 FIRSTPRIVATE and LASTPRIVATE. However, OpenACC permits
6841 reduction variables to be used in data sharing clauses. */
6842 gcc_assert ((ctx
->region_type
& ORT_ACC
) != 0
6843 || ((nflags
& GOVD_DATA_SHARE_CLASS
)
6844 == (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
))
6845 || (flags
& GOVD_DATA_SHARE_CLASS
) == 0);
6850 /* When adding a variable-sized variable, we have to handle all sorts
6851 of additional bits of data: the pointer replacement variable, and
6852 the parameters of the type. */
6853 if (DECL_SIZE (decl
) && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6855 /* Add the pointer replacement variable as PRIVATE if the variable
6856 replacement is private, else FIRSTPRIVATE since we'll need the
6857 address of the original variable either for SHARED, or for the
6858 copy into or out of the context. */
6859 if (!(flags
& GOVD_LOCAL
) && ctx
->region_type
!= ORT_TASKGROUP
)
6861 if (flags
& GOVD_MAP
)
6862 nflags
= GOVD_MAP
| GOVD_MAP_TO_ONLY
| GOVD_EXPLICIT
;
6863 else if (flags
& GOVD_PRIVATE
)
6864 nflags
= GOVD_PRIVATE
;
6865 else if ((ctx
->region_type
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0
6866 && (flags
& GOVD_FIRSTPRIVATE
))
6867 nflags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
6869 nflags
= GOVD_FIRSTPRIVATE
;
6870 nflags
|= flags
& GOVD_SEEN
;
6871 t
= DECL_VALUE_EXPR (decl
);
6872 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
6873 t
= TREE_OPERAND (t
, 0);
6874 gcc_assert (DECL_P (t
));
6875 omp_add_variable (ctx
, t
, nflags
);
6878 /* Add all of the variable and type parameters (which should have
6879 been gimplified to a formal temporary) as FIRSTPRIVATE. */
6880 omp_firstprivatize_variable (ctx
, DECL_SIZE_UNIT (decl
));
6881 omp_firstprivatize_variable (ctx
, DECL_SIZE (decl
));
6882 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
6884 /* The variable-sized variable itself is never SHARED, only some form
6885 of PRIVATE. The sharing would take place via the pointer variable
6886 which we remapped above. */
6887 if (flags
& GOVD_SHARED
)
6888 flags
= GOVD_SHARED
| GOVD_DEBUG_PRIVATE
6889 | (flags
& (GOVD_SEEN
| GOVD_EXPLICIT
));
6891 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
6892 alloca statement we generate for the variable, so make sure it
6893 is available. This isn't automatically needed for the SHARED
6894 case, since we won't be allocating local storage then.
6895 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
6896 in this case omp_notice_variable will be called later
6897 on when it is gimplified. */
6898 else if (! (flags
& (GOVD_LOCAL
| GOVD_MAP
))
6899 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl
))))
6900 omp_notice_variable (ctx
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)), true);
6902 else if ((flags
& (GOVD_MAP
| GOVD_LOCAL
)) == 0
6903 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
6905 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
6907 /* Similar to the direct variable sized case above, we'll need the
6908 size of references being privatized. */
6909 if ((flags
& GOVD_SHARED
) == 0)
6911 t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
6913 omp_notice_variable (ctx
, t
, true);
6920 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, flags
);
6922 /* For reductions clauses in OpenACC loop directives, by default create a
6923 copy clause on the enclosing parallel construct for carrying back the
6925 if (ctx
->region_type
== ORT_ACC
&& (flags
& GOVD_REDUCTION
))
6927 struct gimplify_omp_ctx
*outer_ctx
= ctx
->outer_context
;
6930 n
= splay_tree_lookup (outer_ctx
->variables
, (splay_tree_key
)decl
);
6933 /* Ignore local variables and explicitly declared clauses. */
6934 if (n
->value
& (GOVD_LOCAL
| GOVD_EXPLICIT
))
6936 else if (outer_ctx
->region_type
== ORT_ACC_KERNELS
)
6938 /* According to the OpenACC spec, such a reduction variable
6939 should already have a copy map on a kernels construct,
6940 verify that here. */
6941 gcc_assert (!(n
->value
& GOVD_FIRSTPRIVATE
)
6942 && (n
->value
& GOVD_MAP
));
6944 else if (outer_ctx
->region_type
== ORT_ACC_PARALLEL
)
6946 /* Remove firstprivate and make it a copy map. */
6947 n
->value
&= ~GOVD_FIRSTPRIVATE
;
6948 n
->value
|= GOVD_MAP
;
6951 else if (outer_ctx
->region_type
== ORT_ACC_PARALLEL
)
6953 splay_tree_insert (outer_ctx
->variables
, (splay_tree_key
)decl
,
6954 GOVD_MAP
| GOVD_SEEN
);
6957 outer_ctx
= outer_ctx
->outer_context
;
6962 /* Notice a threadprivate variable DECL used in OMP context CTX.
6963 This just prints out diagnostics about threadprivate variable uses
6964 in untied tasks. If DECL2 is non-NULL, prevent this warning
6965 on that variable. */
6968 omp_notice_threadprivate_variable (struct gimplify_omp_ctx
*ctx
, tree decl
,
6972 struct gimplify_omp_ctx
*octx
;
6974 for (octx
= ctx
; octx
; octx
= octx
->outer_context
)
6975 if ((octx
->region_type
& ORT_TARGET
) != 0)
6977 n
= splay_tree_lookup (octx
->variables
, (splay_tree_key
)decl
);
6980 error ("threadprivate variable %qE used in target region",
6982 error_at (octx
->location
, "enclosing target region");
6983 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl
, 0);
6986 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl2
, 0);
6989 if (ctx
->region_type
!= ORT_UNTIED_TASK
)
6991 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
6994 error ("threadprivate variable %qE used in untied task",
6996 error_at (ctx
->location
, "enclosing task");
6997 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, 0);
7000 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl2
, 0);
7004 /* Return true if global var DECL is device resident. */
7007 device_resident_p (tree decl
)
7009 tree attr
= lookup_attribute ("oacc declare target", DECL_ATTRIBUTES (decl
));
7014 for (tree t
= TREE_VALUE (attr
); t
; t
= TREE_PURPOSE (t
))
7016 tree c
= TREE_VALUE (t
);
7017 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_DEVICE_RESIDENT
)
7024 /* Return true if DECL has an ACC DECLARE attribute. */
7027 is_oacc_declared (tree decl
)
7029 tree t
= TREE_CODE (decl
) == MEM_REF
? TREE_OPERAND (decl
, 0) : decl
;
7030 tree declared
= lookup_attribute ("oacc declare target", DECL_ATTRIBUTES (t
));
7031 return declared
!= NULL_TREE
;
7034 /* Determine outer default flags for DECL mentioned in an OMP region
7035 but not declared in an enclosing clause.
7037 ??? Some compiler-generated variables (like SAVE_EXPRs) could be
7038 remapped firstprivate instead of shared. To some extent this is
7039 addressed in omp_firstprivatize_type_sizes, but not
7043 omp_default_clause (struct gimplify_omp_ctx
*ctx
, tree decl
,
7044 bool in_code
, unsigned flags
)
7046 enum omp_clause_default_kind default_kind
= ctx
->default_kind
;
7047 enum omp_clause_default_kind kind
;
7049 kind
= lang_hooks
.decls
.omp_predetermined_sharing (decl
);
7050 if (kind
!= OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
7051 default_kind
= kind
;
7053 switch (default_kind
)
7055 case OMP_CLAUSE_DEFAULT_NONE
:
7059 if (ctx
->region_type
& ORT_PARALLEL
)
7061 else if ((ctx
->region_type
& ORT_TASKLOOP
) == ORT_TASKLOOP
)
7063 else if (ctx
->region_type
& ORT_TASK
)
7065 else if (ctx
->region_type
& ORT_TEAMS
)
7070 error ("%qE not specified in enclosing %qs",
7071 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)), rtype
);
7072 error_at (ctx
->location
, "enclosing %qs", rtype
);
7075 case OMP_CLAUSE_DEFAULT_SHARED
:
7076 flags
|= GOVD_SHARED
;
7078 case OMP_CLAUSE_DEFAULT_PRIVATE
:
7079 flags
|= GOVD_PRIVATE
;
7081 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
7082 flags
|= GOVD_FIRSTPRIVATE
;
7084 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
7085 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
7086 gcc_assert ((ctx
->region_type
& ORT_TASK
) != 0);
7087 if (struct gimplify_omp_ctx
*octx
= ctx
->outer_context
)
7089 omp_notice_variable (octx
, decl
, in_code
);
7090 for (; octx
; octx
= octx
->outer_context
)
7094 n2
= splay_tree_lookup (octx
->variables
, (splay_tree_key
) decl
);
7095 if ((octx
->region_type
& (ORT_TARGET_DATA
| ORT_TARGET
)) != 0
7096 && (n2
== NULL
|| (n2
->value
& GOVD_DATA_SHARE_CLASS
) == 0))
7098 if (n2
&& (n2
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
)
7100 flags
|= GOVD_FIRSTPRIVATE
;
7103 if ((octx
->region_type
& (ORT_PARALLEL
| ORT_TEAMS
)) != 0)
7105 flags
|= GOVD_SHARED
;
7111 if (TREE_CODE (decl
) == PARM_DECL
7112 || (!is_global_var (decl
)
7113 && DECL_CONTEXT (decl
) == current_function_decl
))
7114 flags
|= GOVD_FIRSTPRIVATE
;
7116 flags
|= GOVD_SHARED
;
7128 /* Determine outer default flags for DECL mentioned in an OACC region
7129 but not declared in an enclosing clause. */
7132 oacc_default_clause (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned flags
)
7135 bool on_device
= false;
7136 bool declared
= is_oacc_declared (decl
);
7137 tree type
= TREE_TYPE (decl
);
7139 if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
7140 type
= TREE_TYPE (type
);
7142 if ((ctx
->region_type
& (ORT_ACC_PARALLEL
| ORT_ACC_KERNELS
)) != 0
7143 && is_global_var (decl
)
7144 && device_resident_p (decl
))
7147 flags
|= GOVD_MAP_TO_ONLY
;
7150 switch (ctx
->region_type
)
7152 case ORT_ACC_KERNELS
:
7155 if (AGGREGATE_TYPE_P (type
))
7157 /* Aggregates default to 'present_or_copy', or 'present'. */
7158 if (ctx
->default_kind
!= OMP_CLAUSE_DEFAULT_PRESENT
)
7161 flags
|= GOVD_MAP
| GOVD_MAP_FORCE_PRESENT
;
7164 /* Scalars default to 'copy'. */
7165 flags
|= GOVD_MAP
| GOVD_MAP_FORCE
;
7169 case ORT_ACC_PARALLEL
:
7172 if (on_device
|| declared
)
7174 else if (AGGREGATE_TYPE_P (type
))
7176 /* Aggregates default to 'present_or_copy', or 'present'. */
7177 if (ctx
->default_kind
!= OMP_CLAUSE_DEFAULT_PRESENT
)
7180 flags
|= GOVD_MAP
| GOVD_MAP_FORCE_PRESENT
;
7183 /* Scalars default to 'firstprivate'. */
7184 flags
|= GOVD_FIRSTPRIVATE
;
7192 if (DECL_ARTIFICIAL (decl
))
7193 ; /* We can get compiler-generated decls, and should not complain
7195 else if (ctx
->default_kind
== OMP_CLAUSE_DEFAULT_NONE
)
7197 error ("%qE not specified in enclosing OpenACC %qs construct",
7198 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)), rkind
);
7199 inform (ctx
->location
, "enclosing OpenACC %qs construct", rkind
);
7201 else if (ctx
->default_kind
== OMP_CLAUSE_DEFAULT_PRESENT
)
7202 ; /* Handled above. */
7204 gcc_checking_assert (ctx
->default_kind
== OMP_CLAUSE_DEFAULT_SHARED
);
7209 /* Record the fact that DECL was used within the OMP context CTX.
7210 IN_CODE is true when real code uses DECL, and false when we should
7211 merely emit default(none) errors. Return true if DECL is going to
7212 be remapped and thus DECL shouldn't be gimplified into its
7213 DECL_VALUE_EXPR (if any). */
7216 omp_notice_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, bool in_code
)
7219 unsigned flags
= in_code
? GOVD_SEEN
: 0;
7220 bool ret
= false, shared
;
7222 if (error_operand_p (decl
))
7225 if (ctx
->region_type
== ORT_NONE
)
7226 return lang_hooks
.decls
.omp_disregard_value_expr (decl
, false);
7228 if (is_global_var (decl
))
7230 /* Threadprivate variables are predetermined. */
7231 if (DECL_THREAD_LOCAL_P (decl
))
7232 return omp_notice_threadprivate_variable (ctx
, decl
, NULL_TREE
);
7234 if (DECL_HAS_VALUE_EXPR_P (decl
))
7236 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
7238 if (value
&& DECL_P (value
) && DECL_THREAD_LOCAL_P (value
))
7239 return omp_notice_threadprivate_variable (ctx
, decl
, value
);
7242 if (gimplify_omp_ctxp
->outer_context
== NULL
7244 && oacc_get_fn_attrib (current_function_decl
))
7246 location_t loc
= DECL_SOURCE_LOCATION (decl
);
7248 if (lookup_attribute ("omp declare target link",
7249 DECL_ATTRIBUTES (decl
)))
7252 "%qE with %<link%> clause used in %<routine%> function",
7256 else if (!lookup_attribute ("omp declare target",
7257 DECL_ATTRIBUTES (decl
)))
7260 "%qE requires a %<declare%> directive for use "
7261 "in a %<routine%> function", DECL_NAME (decl
));
7267 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
7268 if ((ctx
->region_type
& ORT_TARGET
) != 0)
7270 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, true);
7273 unsigned nflags
= flags
;
7274 if ((ctx
->region_type
& ORT_ACC
) == 0)
7276 bool is_declare_target
= false;
7277 if (is_global_var (decl
)
7278 && varpool_node::get_create (decl
)->offloadable
)
7280 struct gimplify_omp_ctx
*octx
;
7281 for (octx
= ctx
->outer_context
;
7282 octx
; octx
= octx
->outer_context
)
7284 n
= splay_tree_lookup (octx
->variables
,
7285 (splay_tree_key
)decl
);
7287 && (n
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
7288 && (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
7291 is_declare_target
= octx
== NULL
;
7293 if (!is_declare_target
)
7296 if (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
7297 || (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
7298 && (TREE_CODE (TREE_TYPE (TREE_TYPE (decl
)))
7300 gdmk
= GDMK_POINTER
;
7301 else if (lang_hooks
.decls
.omp_scalar_p (decl
))
7304 gdmk
= GDMK_AGGREGATE
;
7305 if (ctx
->defaultmap
[gdmk
] == 0)
7307 tree d
= lang_hooks
.decls
.omp_report_decl (decl
);
7308 error ("%qE not specified in enclosing %<target%>",
7310 error_at (ctx
->location
, "enclosing %<target%>");
7312 else if (ctx
->defaultmap
[gdmk
]
7313 & (GOVD_MAP_0LEN_ARRAY
| GOVD_FIRSTPRIVATE
))
7314 nflags
|= ctx
->defaultmap
[gdmk
];
7317 gcc_assert (ctx
->defaultmap
[gdmk
] & GOVD_MAP
);
7318 nflags
|= ctx
->defaultmap
[gdmk
] & ~GOVD_MAP
;
7323 struct gimplify_omp_ctx
*octx
= ctx
->outer_context
;
7324 if ((ctx
->region_type
& ORT_ACC
) && octx
)
7326 /* Look in outer OpenACC contexts, to see if there's a
7327 data attribute for this variable. */
7328 omp_notice_variable (octx
, decl
, in_code
);
7330 for (; octx
; octx
= octx
->outer_context
)
7332 if (!(octx
->region_type
& (ORT_TARGET_DATA
| ORT_TARGET
)))
7335 = splay_tree_lookup (octx
->variables
,
7336 (splay_tree_key
) decl
);
7339 if (octx
->region_type
== ORT_ACC_HOST_DATA
)
7340 error ("variable %qE declared in enclosing "
7341 "%<host_data%> region", DECL_NAME (decl
));
7343 if (octx
->region_type
== ORT_ACC_DATA
7344 && (n2
->value
& GOVD_MAP_0LEN_ARRAY
))
7345 nflags
|= GOVD_MAP_0LEN_ARRAY
;
7351 if ((nflags
& ~(GOVD_MAP_TO_ONLY
| GOVD_MAP_FROM_ONLY
7352 | GOVD_MAP_ALLOC_ONLY
)) == flags
)
7354 tree type
= TREE_TYPE (decl
);
7356 if (gimplify_omp_ctxp
->target_firstprivatize_array_bases
7357 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
7358 type
= TREE_TYPE (type
);
7359 if (!lang_hooks
.types
.omp_mappable_type (type
))
7361 error ("%qD referenced in target region does not have "
7362 "a mappable type", decl
);
7363 nflags
|= GOVD_MAP
| GOVD_EXPLICIT
;
7367 if ((ctx
->region_type
& ORT_ACC
) != 0)
7368 nflags
= oacc_default_clause (ctx
, decl
, flags
);
7374 omp_add_variable (ctx
, decl
, nflags
);
7378 /* If nothing changed, there's nothing left to do. */
7379 if ((n
->value
& flags
) == flags
)
7389 if (ctx
->region_type
== ORT_WORKSHARE
7390 || ctx
->region_type
== ORT_TASKGROUP
7391 || ctx
->region_type
== ORT_SIMD
7392 || ctx
->region_type
== ORT_ACC
7393 || (ctx
->region_type
& ORT_TARGET_DATA
) != 0)
7396 flags
= omp_default_clause (ctx
, decl
, in_code
, flags
);
7398 if ((flags
& GOVD_PRIVATE
)
7399 && lang_hooks
.decls
.omp_private_outer_ref (decl
))
7400 flags
|= GOVD_PRIVATE_OUTER_REF
;
7402 omp_add_variable (ctx
, decl
, flags
);
7404 shared
= (flags
& GOVD_SHARED
) != 0;
7405 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
7409 if ((n
->value
& (GOVD_SEEN
| GOVD_LOCAL
)) == 0
7410 && (flags
& (GOVD_SEEN
| GOVD_LOCAL
)) == GOVD_SEEN
7411 && DECL_SIZE (decl
))
7413 if (TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
7416 tree t
= DECL_VALUE_EXPR (decl
);
7417 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
7418 t
= TREE_OPERAND (t
, 0);
7419 gcc_assert (DECL_P (t
));
7420 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
7421 n2
->value
|= GOVD_SEEN
;
7423 else if (lang_hooks
.decls
.omp_privatize_by_reference (decl
)
7424 && TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)))
7425 && (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
))))
7429 tree t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
7430 gcc_assert (DECL_P (t
));
7431 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
7433 omp_notice_variable (ctx
, t
, true);
7437 shared
= ((flags
| n
->value
) & GOVD_SHARED
) != 0;
7438 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
7440 /* If nothing changed, there's nothing left to do. */
7441 if ((n
->value
& flags
) == flags
)
7447 /* If the variable is private in the current context, then we don't
7448 need to propagate anything to an outer context. */
7449 if ((flags
& GOVD_PRIVATE
) && !(flags
& GOVD_PRIVATE_OUTER_REF
))
7451 if ((flags
& (GOVD_LINEAR
| GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
7452 == (GOVD_LINEAR
| GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
7454 if ((flags
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
7455 | GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
7456 == (GOVD_LASTPRIVATE
| GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
7458 if (ctx
->outer_context
7459 && omp_notice_variable (ctx
->outer_context
, decl
, in_code
))
7464 /* Verify that DECL is private within CTX. If there's specific information
7465 to the contrary in the innermost scope, generate an error. */
7468 omp_is_private (struct gimplify_omp_ctx
*ctx
, tree decl
, int simd
)
7472 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
7475 if (n
->value
& GOVD_SHARED
)
7477 if (ctx
== gimplify_omp_ctxp
)
7480 error ("iteration variable %qE is predetermined linear",
7483 error ("iteration variable %qE should be private",
7485 n
->value
= GOVD_PRIVATE
;
7491 else if ((n
->value
& GOVD_EXPLICIT
) != 0
7492 && (ctx
== gimplify_omp_ctxp
7493 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
7494 && gimplify_omp_ctxp
->outer_context
== ctx
)))
7496 if ((n
->value
& GOVD_FIRSTPRIVATE
) != 0)
7497 error ("iteration variable %qE should not be firstprivate",
7499 else if ((n
->value
& GOVD_REDUCTION
) != 0)
7500 error ("iteration variable %qE should not be reduction",
7502 else if (simd
!= 1 && (n
->value
& GOVD_LINEAR
) != 0)
7503 error ("iteration variable %qE should not be linear",
7506 return (ctx
== gimplify_omp_ctxp
7507 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
7508 && gimplify_omp_ctxp
->outer_context
== ctx
));
7511 if (ctx
->region_type
!= ORT_WORKSHARE
7512 && ctx
->region_type
!= ORT_TASKGROUP
7513 && ctx
->region_type
!= ORT_SIMD
7514 && ctx
->region_type
!= ORT_ACC
)
7516 else if (ctx
->outer_context
)
7517 return omp_is_private (ctx
->outer_context
, decl
, simd
);
7521 /* Return true if DECL is private within a parallel region
7522 that binds to the current construct's context or in parallel
7523 region's REDUCTION clause. */
7526 omp_check_private (struct gimplify_omp_ctx
*ctx
, tree decl
, bool copyprivate
)
7532 ctx
= ctx
->outer_context
;
7535 if (is_global_var (decl
))
7538 /* References might be private, but might be shared too,
7539 when checking for copyprivate, assume they might be
7540 private, otherwise assume they might be shared. */
7544 if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
7547 /* Treat C++ privatized non-static data members outside
7548 of the privatization the same. */
7549 if (omp_member_access_dummy_var (decl
))
7555 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
7557 if ((ctx
->region_type
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0
7558 && (n
== NULL
|| (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0))
7563 if ((n
->value
& GOVD_LOCAL
) != 0
7564 && omp_member_access_dummy_var (decl
))
7566 return (n
->value
& GOVD_SHARED
) == 0;
7569 while (ctx
->region_type
== ORT_WORKSHARE
7570 || ctx
->region_type
== ORT_TASKGROUP
7571 || ctx
->region_type
== ORT_SIMD
7572 || ctx
->region_type
== ORT_ACC
);
7576 /* Callback for walk_tree to find a DECL_EXPR for the given DECL. */
7579 find_decl_expr (tree
*tp
, int *walk_subtrees
, void *data
)
7583 /* If this node has been visited, unmark it and keep looking. */
7584 if (TREE_CODE (t
) == DECL_EXPR
&& DECL_EXPR_DECL (t
) == (tree
) data
)
7587 if (IS_TYPE_OR_DECL_P (t
))
7592 /* If *LIST_P contains any OpenMP depend clauses with iterators,
7593 lower all the depend clauses by populating corresponding depend
7594 array. Returns 0 if there are no such depend clauses, or
7595 2 if all depend clauses should be removed, 1 otherwise. */
7598 gimplify_omp_depend (tree
*list_p
, gimple_seq
*pre_p
)
7602 size_t n
[4] = { 0, 0, 0, 0 };
7604 tree counts
[4] = { NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
};
7605 tree last_iter
= NULL_TREE
, last_count
= NULL_TREE
;
7607 location_t first_loc
= UNKNOWN_LOCATION
;
7609 for (c
= *list_p
; c
; c
= OMP_CLAUSE_CHAIN (c
))
7610 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
)
7612 switch (OMP_CLAUSE_DEPEND_KIND (c
))
7614 case OMP_CLAUSE_DEPEND_IN
:
7617 case OMP_CLAUSE_DEPEND_OUT
:
7618 case OMP_CLAUSE_DEPEND_INOUT
:
7621 case OMP_CLAUSE_DEPEND_MUTEXINOUTSET
:
7624 case OMP_CLAUSE_DEPEND_DEPOBJ
:
7627 case OMP_CLAUSE_DEPEND_SOURCE
:
7628 case OMP_CLAUSE_DEPEND_SINK
:
7633 tree t
= OMP_CLAUSE_DECL (c
);
7634 if (first_loc
== UNKNOWN_LOCATION
)
7635 first_loc
= OMP_CLAUSE_LOCATION (c
);
7636 if (TREE_CODE (t
) == TREE_LIST
7638 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
7640 if (TREE_PURPOSE (t
) != last_iter
)
7642 tree tcnt
= size_one_node
;
7643 for (tree it
= TREE_PURPOSE (t
); it
; it
= TREE_CHAIN (it
))
7645 if (gimplify_expr (&TREE_VEC_ELT (it
, 1), pre_p
, NULL
,
7646 is_gimple_val
, fb_rvalue
) == GS_ERROR
7647 || gimplify_expr (&TREE_VEC_ELT (it
, 2), pre_p
, NULL
,
7648 is_gimple_val
, fb_rvalue
) == GS_ERROR
7649 || gimplify_expr (&TREE_VEC_ELT (it
, 3), pre_p
, NULL
,
7650 is_gimple_val
, fb_rvalue
) == GS_ERROR
7651 || (gimplify_expr (&TREE_VEC_ELT (it
, 4), pre_p
, NULL
,
7652 is_gimple_val
, fb_rvalue
)
7655 tree var
= TREE_VEC_ELT (it
, 0);
7656 tree begin
= TREE_VEC_ELT (it
, 1);
7657 tree end
= TREE_VEC_ELT (it
, 2);
7658 tree step
= TREE_VEC_ELT (it
, 3);
7659 tree orig_step
= TREE_VEC_ELT (it
, 4);
7660 tree type
= TREE_TYPE (var
);
7661 tree stype
= TREE_TYPE (step
);
7662 location_t loc
= DECL_SOURCE_LOCATION (var
);
7664 /* Compute count for this iterator as
7666 ? (begin < end ? (end - begin + (step - 1)) / step : 0)
7667 : (begin > end ? (end - begin + (step + 1)) / step : 0)
7668 and compute product of those for the entire depend
7670 if (POINTER_TYPE_P (type
))
7671 endmbegin
= fold_build2_loc (loc
, POINTER_DIFF_EXPR
,
7674 endmbegin
= fold_build2_loc (loc
, MINUS_EXPR
, type
,
7676 tree stepm1
= fold_build2_loc (loc
, MINUS_EXPR
, stype
,
7678 build_int_cst (stype
, 1));
7679 tree stepp1
= fold_build2_loc (loc
, PLUS_EXPR
, stype
, step
,
7680 build_int_cst (stype
, 1));
7681 tree pos
= fold_build2_loc (loc
, PLUS_EXPR
, stype
,
7682 unshare_expr (endmbegin
),
7684 pos
= fold_build2_loc (loc
, TRUNC_DIV_EXPR
, stype
,
7686 tree neg
= fold_build2_loc (loc
, PLUS_EXPR
, stype
,
7688 if (TYPE_UNSIGNED (stype
))
7690 neg
= fold_build1_loc (loc
, NEGATE_EXPR
, stype
, neg
);
7691 step
= fold_build1_loc (loc
, NEGATE_EXPR
, stype
, step
);
7693 neg
= fold_build2_loc (loc
, TRUNC_DIV_EXPR
, stype
,
7696 tree cond
= fold_build2_loc (loc
, LT_EXPR
,
7699 pos
= fold_build3_loc (loc
, COND_EXPR
, stype
, cond
, pos
,
7700 build_int_cst (stype
, 0));
7701 cond
= fold_build2_loc (loc
, LT_EXPR
, boolean_type_node
,
7703 neg
= fold_build3_loc (loc
, COND_EXPR
, stype
, cond
, neg
,
7704 build_int_cst (stype
, 0));
7705 tree osteptype
= TREE_TYPE (orig_step
);
7706 cond
= fold_build2_loc (loc
, GT_EXPR
, boolean_type_node
,
7708 build_int_cst (osteptype
, 0));
7709 tree cnt
= fold_build3_loc (loc
, COND_EXPR
, stype
,
7711 cnt
= fold_convert_loc (loc
, sizetype
, cnt
);
7712 if (gimplify_expr (&cnt
, pre_p
, NULL
, is_gimple_val
,
7713 fb_rvalue
) == GS_ERROR
)
7715 tcnt
= size_binop_loc (loc
, MULT_EXPR
, tcnt
, cnt
);
7717 if (gimplify_expr (&tcnt
, pre_p
, NULL
, is_gimple_val
,
7718 fb_rvalue
) == GS_ERROR
)
7720 last_iter
= TREE_PURPOSE (t
);
7723 if (counts
[i
] == NULL_TREE
)
7724 counts
[i
] = last_count
;
7726 counts
[i
] = size_binop_loc (OMP_CLAUSE_LOCATION (c
),
7727 PLUS_EXPR
, counts
[i
], last_count
);
7732 for (i
= 0; i
< 4; i
++)
7738 tree total
= size_zero_node
;
7739 for (i
= 0; i
< 4; i
++)
7741 unused
[i
] = counts
[i
] == NULL_TREE
&& n
[i
] == 0;
7742 if (counts
[i
] == NULL_TREE
)
7743 counts
[i
] = size_zero_node
;
7745 counts
[i
] = size_binop (PLUS_EXPR
, counts
[i
], size_int (n
[i
]));
7746 if (gimplify_expr (&counts
[i
], pre_p
, NULL
, is_gimple_val
,
7747 fb_rvalue
) == GS_ERROR
)
7749 total
= size_binop (PLUS_EXPR
, total
, counts
[i
]);
7752 if (gimplify_expr (&total
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7755 bool is_old
= unused
[1] && unused
[3];
7756 tree totalpx
= size_binop (PLUS_EXPR
, unshare_expr (total
),
7757 size_int (is_old
? 1 : 4));
7758 tree type
= build_array_type (ptr_type_node
, build_index_type (totalpx
));
7759 tree array
= create_tmp_var_raw (type
);
7760 TREE_ADDRESSABLE (array
) = 1;
7761 if (TREE_CODE (totalpx
) != INTEGER_CST
)
7763 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (array
)))
7764 gimplify_type_sizes (TREE_TYPE (array
), pre_p
);
7765 if (gimplify_omp_ctxp
)
7767 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
7769 && (ctx
->region_type
== ORT_WORKSHARE
7770 || ctx
->region_type
== ORT_TASKGROUP
7771 || ctx
->region_type
== ORT_SIMD
7772 || ctx
->region_type
== ORT_ACC
))
7773 ctx
= ctx
->outer_context
;
7775 omp_add_variable (ctx
, array
, GOVD_LOCAL
| GOVD_SEEN
);
7777 gimplify_vla_decl (array
, pre_p
);
7780 gimple_add_tmp_var (array
);
7781 tree r
= build4 (ARRAY_REF
, ptr_type_node
, array
, size_int (0), NULL_TREE
,
7786 tem
= build2 (MODIFY_EXPR
, void_type_node
, r
,
7787 build_int_cst (ptr_type_node
, 0));
7788 gimplify_and_add (tem
, pre_p
);
7789 r
= build4 (ARRAY_REF
, ptr_type_node
, array
, size_int (1), NULL_TREE
,
7792 tem
= build2 (MODIFY_EXPR
, void_type_node
, r
,
7793 fold_convert (ptr_type_node
, total
));
7794 gimplify_and_add (tem
, pre_p
);
7795 for (i
= 1; i
< (is_old
? 2 : 4); i
++)
7797 r
= build4 (ARRAY_REF
, ptr_type_node
, array
, size_int (i
+ !is_old
),
7798 NULL_TREE
, NULL_TREE
);
7799 tem
= build2 (MODIFY_EXPR
, void_type_node
, r
, counts
[i
- 1]);
7800 gimplify_and_add (tem
, pre_p
);
7807 for (i
= 0; i
< 4; i
++)
7809 if (i
&& (i
>= j
|| unused
[i
- 1]))
7811 cnts
[i
] = cnts
[i
- 1];
7814 cnts
[i
] = create_tmp_var (sizetype
);
7816 g
= gimple_build_assign (cnts
[i
], size_int (is_old
? 2 : 5));
7821 t
= size_binop (PLUS_EXPR
, counts
[0], size_int (2));
7823 t
= size_binop (PLUS_EXPR
, cnts
[i
- 1], counts
[i
- 1]);
7824 if (gimplify_expr (&t
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7827 g
= gimple_build_assign (cnts
[i
], t
);
7829 gimple_seq_add_stmt (pre_p
, g
);
7832 last_iter
= NULL_TREE
;
7833 tree last_bind
= NULL_TREE
;
7834 tree
*last_body
= NULL
;
7835 for (c
= *list_p
; c
; c
= OMP_CLAUSE_CHAIN (c
))
7836 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
)
7838 switch (OMP_CLAUSE_DEPEND_KIND (c
))
7840 case OMP_CLAUSE_DEPEND_IN
:
7843 case OMP_CLAUSE_DEPEND_OUT
:
7844 case OMP_CLAUSE_DEPEND_INOUT
:
7847 case OMP_CLAUSE_DEPEND_MUTEXINOUTSET
:
7850 case OMP_CLAUSE_DEPEND_DEPOBJ
:
7853 case OMP_CLAUSE_DEPEND_SOURCE
:
7854 case OMP_CLAUSE_DEPEND_SINK
:
7859 tree t
= OMP_CLAUSE_DECL (c
);
7860 if (TREE_CODE (t
) == TREE_LIST
7862 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
7864 if (TREE_PURPOSE (t
) != last_iter
)
7867 gimplify_and_add (last_bind
, pre_p
);
7868 tree block
= TREE_VEC_ELT (TREE_PURPOSE (t
), 5);
7869 last_bind
= build3 (BIND_EXPR
, void_type_node
,
7870 BLOCK_VARS (block
), NULL
, block
);
7871 TREE_SIDE_EFFECTS (last_bind
) = 1;
7872 SET_EXPR_LOCATION (last_bind
, OMP_CLAUSE_LOCATION (c
));
7873 tree
*p
= &BIND_EXPR_BODY (last_bind
);
7874 for (tree it
= TREE_PURPOSE (t
); it
; it
= TREE_CHAIN (it
))
7876 tree var
= TREE_VEC_ELT (it
, 0);
7877 tree begin
= TREE_VEC_ELT (it
, 1);
7878 tree end
= TREE_VEC_ELT (it
, 2);
7879 tree step
= TREE_VEC_ELT (it
, 3);
7880 tree orig_step
= TREE_VEC_ELT (it
, 4);
7881 tree type
= TREE_TYPE (var
);
7882 location_t loc
= DECL_SOURCE_LOCATION (var
);
7890 if (orig_step > 0) {
7891 if (var < end) goto beg_label;
7893 if (var > end) goto beg_label;
7895 for each iterator, with inner iterators added to
7897 tree beg_label
= create_artificial_label (loc
);
7898 tree cond_label
= NULL_TREE
;
7899 tem
= build2_loc (loc
, MODIFY_EXPR
, void_type_node
,
7901 append_to_statement_list_force (tem
, p
);
7902 tem
= build_and_jump (&cond_label
);
7903 append_to_statement_list_force (tem
, p
);
7904 tem
= build1 (LABEL_EXPR
, void_type_node
, beg_label
);
7905 append_to_statement_list (tem
, p
);
7906 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL_TREE
,
7907 NULL_TREE
, NULL_TREE
);
7908 TREE_SIDE_EFFECTS (bind
) = 1;
7909 SET_EXPR_LOCATION (bind
, loc
);
7910 append_to_statement_list_force (bind
, p
);
7911 if (POINTER_TYPE_P (type
))
7912 tem
= build2_loc (loc
, POINTER_PLUS_EXPR
, type
,
7913 var
, fold_convert_loc (loc
, sizetype
,
7916 tem
= build2_loc (loc
, PLUS_EXPR
, type
, var
, step
);
7917 tem
= build2_loc (loc
, MODIFY_EXPR
, void_type_node
,
7919 append_to_statement_list_force (tem
, p
);
7920 tem
= build1 (LABEL_EXPR
, void_type_node
, cond_label
);
7921 append_to_statement_list (tem
, p
);
7922 tree cond
= fold_build2_loc (loc
, LT_EXPR
,
7926 = fold_build3_loc (loc
, COND_EXPR
, void_type_node
,
7927 cond
, build_and_jump (&beg_label
),
7929 cond
= fold_build2_loc (loc
, GT_EXPR
, boolean_type_node
,
7932 = fold_build3_loc (loc
, COND_EXPR
, void_type_node
,
7933 cond
, build_and_jump (&beg_label
),
7935 tree osteptype
= TREE_TYPE (orig_step
);
7936 cond
= fold_build2_loc (loc
, GT_EXPR
, boolean_type_node
,
7938 build_int_cst (osteptype
, 0));
7939 tem
= fold_build3_loc (loc
, COND_EXPR
, void_type_node
,
7941 append_to_statement_list_force (tem
, p
);
7942 p
= &BIND_EXPR_BODY (bind
);
7946 last_iter
= TREE_PURPOSE (t
);
7947 if (TREE_CODE (TREE_VALUE (t
)) == COMPOUND_EXPR
)
7949 append_to_statement_list (TREE_OPERAND (TREE_VALUE (t
),
7951 TREE_VALUE (t
) = TREE_OPERAND (TREE_VALUE (t
), 1);
7953 if (error_operand_p (TREE_VALUE (t
)))
7955 TREE_VALUE (t
) = build_fold_addr_expr (TREE_VALUE (t
));
7956 r
= build4 (ARRAY_REF
, ptr_type_node
, array
, cnts
[i
],
7957 NULL_TREE
, NULL_TREE
);
7958 tem
= build2_loc (OMP_CLAUSE_LOCATION (c
), MODIFY_EXPR
,
7959 void_type_node
, r
, TREE_VALUE (t
));
7960 append_to_statement_list_force (tem
, last_body
);
7961 tem
= build2_loc (OMP_CLAUSE_LOCATION (c
), MODIFY_EXPR
,
7962 void_type_node
, cnts
[i
],
7963 size_binop (PLUS_EXPR
, cnts
[i
], size_int (1)));
7964 append_to_statement_list_force (tem
, last_body
);
7965 TREE_VALUE (t
) = null_pointer_node
;
7971 gimplify_and_add (last_bind
, pre_p
);
7972 last_bind
= NULL_TREE
;
7974 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == COMPOUND_EXPR
)
7976 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0), pre_p
,
7977 NULL
, is_gimple_val
, fb_rvalue
);
7978 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (OMP_CLAUSE_DECL (c
), 1);
7980 if (error_operand_p (OMP_CLAUSE_DECL (c
)))
7982 OMP_CLAUSE_DECL (c
) = build_fold_addr_expr (OMP_CLAUSE_DECL (c
));
7983 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
, NULL
,
7984 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
7986 r
= build4 (ARRAY_REF
, ptr_type_node
, array
, cnts
[i
],
7987 NULL_TREE
, NULL_TREE
);
7988 tem
= build2 (MODIFY_EXPR
, void_type_node
, r
, OMP_CLAUSE_DECL (c
));
7989 gimplify_and_add (tem
, pre_p
);
7990 g
= gimple_build_assign (cnts
[i
], size_binop (PLUS_EXPR
, cnts
[i
],
7992 gimple_seq_add_stmt (pre_p
, g
);
7996 gimplify_and_add (last_bind
, pre_p
);
7997 tree cond
= boolean_false_node
;
8001 cond
= build2_loc (first_loc
, NE_EXPR
, boolean_type_node
, cnts
[0],
8002 size_binop_loc (first_loc
, PLUS_EXPR
, counts
[0],
8005 cond
= build2_loc (first_loc
, TRUTH_OR_EXPR
, boolean_type_node
, cond
,
8006 build2_loc (first_loc
, NE_EXPR
, boolean_type_node
,
8008 size_binop_loc (first_loc
, PLUS_EXPR
,
8014 tree prev
= size_int (5);
8015 for (i
= 0; i
< 4; i
++)
8019 prev
= size_binop_loc (first_loc
, PLUS_EXPR
, counts
[i
], prev
);
8020 cond
= build2_loc (first_loc
, TRUTH_OR_EXPR
, boolean_type_node
, cond
,
8021 build2_loc (first_loc
, NE_EXPR
, boolean_type_node
,
8022 cnts
[i
], unshare_expr (prev
)));
8025 tem
= build3_loc (first_loc
, COND_EXPR
, void_type_node
, cond
,
8026 build_call_expr_loc (first_loc
,
8027 builtin_decl_explicit (BUILT_IN_TRAP
),
8029 gimplify_and_add (tem
, pre_p
);
8030 c
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE_DEPEND
);
8031 OMP_CLAUSE_DEPEND_KIND (c
) = OMP_CLAUSE_DEPEND_LAST
;
8032 OMP_CLAUSE_DECL (c
) = build_fold_addr_expr (array
);
8033 OMP_CLAUSE_CHAIN (c
) = *list_p
;
8038 /* Scan the OMP clauses in *LIST_P, installing mappings into a new
8039 and previous omp contexts. */
8042 gimplify_scan_omp_clauses (tree
*list_p
, gimple_seq
*pre_p
,
8043 enum omp_region_type region_type
,
8044 enum tree_code code
)
8046 struct gimplify_omp_ctx
*ctx
, *outer_ctx
;
8048 hash_map
<tree
, tree
> *struct_map_to_clause
= NULL
;
8049 tree
*prev_list_p
= NULL
;
8050 int handled_depend_iterators
= -1;
8053 ctx
= new_omp_context (region_type
);
8054 outer_ctx
= ctx
->outer_context
;
8055 if (code
== OMP_TARGET
)
8057 if (!lang_GNU_Fortran ())
8058 ctx
->defaultmap
[GDMK_POINTER
] = GOVD_MAP
| GOVD_MAP_0LEN_ARRAY
;
8059 ctx
->defaultmap
[GDMK_SCALAR
] = GOVD_FIRSTPRIVATE
;
8061 if (!lang_GNU_Fortran ())
8065 case OMP_TARGET_DATA
:
8066 case OMP_TARGET_ENTER_DATA
:
8067 case OMP_TARGET_EXIT_DATA
:
8069 case OACC_HOST_DATA
:
8072 ctx
->target_firstprivatize_array_bases
= true;
8077 while ((c
= *list_p
) != NULL
)
8079 bool remove
= false;
8080 bool notice_outer
= true;
8081 const char *check_non_private
= NULL
;
8085 switch (OMP_CLAUSE_CODE (c
))
8087 case OMP_CLAUSE_PRIVATE
:
8088 flags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
8089 if (lang_hooks
.decls
.omp_private_outer_ref (OMP_CLAUSE_DECL (c
)))
8091 flags
|= GOVD_PRIVATE_OUTER_REF
;
8092 OMP_CLAUSE_PRIVATE_OUTER_REF (c
) = 1;
8095 notice_outer
= false;
8097 case OMP_CLAUSE_SHARED
:
8098 flags
= GOVD_SHARED
| GOVD_EXPLICIT
;
8100 case OMP_CLAUSE_FIRSTPRIVATE
:
8101 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
8102 check_non_private
= "firstprivate";
8104 case OMP_CLAUSE_LASTPRIVATE
:
8105 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
))
8108 case OMP_DISTRIBUTE
:
8109 error_at (OMP_CLAUSE_LOCATION (c
),
8110 "conditional %<lastprivate%> clause on "
8111 "%<distribute%> construct");
8112 OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
) = 0;
8115 error_at (OMP_CLAUSE_LOCATION (c
),
8116 "conditional %<lastprivate%> clause on "
8117 "%<taskloop%> construct");
8118 OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
) = 0;
8123 flags
= GOVD_LASTPRIVATE
| GOVD_SEEN
| GOVD_EXPLICIT
;
8124 check_non_private
= "lastprivate";
8125 decl
= OMP_CLAUSE_DECL (c
);
8126 if (error_operand_p (decl
))
8128 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
)
8129 && !lang_hooks
.decls
.omp_scalar_p (decl
))
8131 error_at (OMP_CLAUSE_LOCATION (c
),
8132 "non-scalar variable %qD in conditional "
8133 "%<lastprivate%> clause", decl
);
8134 OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
) = 0;
8136 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
))
8137 sorry_at (OMP_CLAUSE_LOCATION (c
),
8138 "%<conditional%> modifier on %<lastprivate%> clause "
8139 "not supported yet");
8141 && (outer_ctx
->region_type
== ORT_COMBINED_PARALLEL
8142 || ((outer_ctx
->region_type
& ORT_COMBINED_TEAMS
)
8143 == ORT_COMBINED_TEAMS
))
8144 && splay_tree_lookup (outer_ctx
->variables
,
8145 (splay_tree_key
) decl
) == NULL
)
8147 omp_add_variable (outer_ctx
, decl
, GOVD_SHARED
| GOVD_SEEN
);
8148 if (outer_ctx
->outer_context
)
8149 omp_notice_variable (outer_ctx
->outer_context
, decl
, true);
8152 && (outer_ctx
->region_type
& ORT_TASK
) != 0
8153 && outer_ctx
->combined_loop
8154 && splay_tree_lookup (outer_ctx
->variables
,
8155 (splay_tree_key
) decl
) == NULL
)
8157 omp_add_variable (outer_ctx
, decl
, GOVD_LASTPRIVATE
| GOVD_SEEN
);
8158 if (outer_ctx
->outer_context
)
8159 omp_notice_variable (outer_ctx
->outer_context
, decl
, true);
8162 && (outer_ctx
->region_type
== ORT_WORKSHARE
8163 || outer_ctx
->region_type
== ORT_ACC
)
8164 && outer_ctx
->combined_loop
8165 && splay_tree_lookup (outer_ctx
->variables
,
8166 (splay_tree_key
) decl
) == NULL
8167 && !omp_check_private (outer_ctx
, decl
, false))
8169 omp_add_variable (outer_ctx
, decl
, GOVD_LASTPRIVATE
| GOVD_SEEN
);
8170 if (outer_ctx
->outer_context
8171 && (outer_ctx
->outer_context
->region_type
8172 == ORT_COMBINED_PARALLEL
)
8173 && splay_tree_lookup (outer_ctx
->outer_context
->variables
,
8174 (splay_tree_key
) decl
) == NULL
)
8176 struct gimplify_omp_ctx
*octx
= outer_ctx
->outer_context
;
8177 omp_add_variable (octx
, decl
, GOVD_SHARED
| GOVD_SEEN
);
8178 if (octx
->outer_context
)
8180 octx
= octx
->outer_context
;
8181 if (octx
->region_type
== ORT_WORKSHARE
8182 && octx
->combined_loop
8183 && splay_tree_lookup (octx
->variables
,
8184 (splay_tree_key
) decl
) == NULL
8185 && !omp_check_private (octx
, decl
, false))
8187 omp_add_variable (octx
, decl
,
8188 GOVD_LASTPRIVATE
| GOVD_SEEN
);
8189 octx
= octx
->outer_context
;
8191 && ((octx
->region_type
& ORT_COMBINED_TEAMS
)
8192 == ORT_COMBINED_TEAMS
)
8193 && (splay_tree_lookup (octx
->variables
,
8194 (splay_tree_key
) decl
)
8197 omp_add_variable (octx
, decl
,
8198 GOVD_SHARED
| GOVD_SEEN
);
8199 octx
= octx
->outer_context
;
8203 omp_notice_variable (octx
, decl
, true);
8206 else if (outer_ctx
->outer_context
)
8207 omp_notice_variable (outer_ctx
->outer_context
, decl
, true);
8210 case OMP_CLAUSE_REDUCTION
:
8211 if (OMP_CLAUSE_REDUCTION_TASK (c
))
8213 if (region_type
== ORT_WORKSHARE
)
8216 nowait
= omp_find_clause (*list_p
,
8217 OMP_CLAUSE_NOWAIT
) != NULL_TREE
;
8219 && (outer_ctx
== NULL
8220 || outer_ctx
->region_type
!= ORT_COMBINED_PARALLEL
))
8222 error_at (OMP_CLAUSE_LOCATION (c
),
8223 "%<task%> reduction modifier on a construct "
8224 "with a %<nowait%> clause");
8225 OMP_CLAUSE_REDUCTION_TASK (c
) = 0;
8228 else if ((region_type
& ORT_PARALLEL
) != ORT_PARALLEL
)
8230 error_at (OMP_CLAUSE_LOCATION (c
),
8231 "invalid %<task%> reduction modifier on construct "
8232 "other than %<parallel%>, %<for%> or %<sections%>");
8233 OMP_CLAUSE_REDUCTION_TASK (c
) = 0;
8237 case OMP_CLAUSE_IN_REDUCTION
:
8238 case OMP_CLAUSE_TASK_REDUCTION
:
8239 flags
= GOVD_REDUCTION
| GOVD_SEEN
| GOVD_EXPLICIT
;
8240 /* OpenACC permits reductions on private variables. */
8241 if (!(region_type
& ORT_ACC
)
8242 /* taskgroup is actually not a worksharing region. */
8243 && code
!= OMP_TASKGROUP
)
8244 check_non_private
= omp_clause_code_name
[OMP_CLAUSE_CODE (c
)];
8245 decl
= OMP_CLAUSE_DECL (c
);
8246 if (TREE_CODE (decl
) == MEM_REF
)
8248 tree type
= TREE_TYPE (decl
);
8249 if (gimplify_expr (&TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), pre_p
,
8250 NULL
, is_gimple_val
, fb_rvalue
, false)
8256 tree v
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
8259 omp_firstprivatize_variable (ctx
, v
);
8260 omp_notice_variable (ctx
, v
, true);
8262 decl
= TREE_OPERAND (decl
, 0);
8263 if (TREE_CODE (decl
) == POINTER_PLUS_EXPR
)
8265 if (gimplify_expr (&TREE_OPERAND (decl
, 1), pre_p
,
8266 NULL
, is_gimple_val
, fb_rvalue
, false)
8272 v
= TREE_OPERAND (decl
, 1);
8275 omp_firstprivatize_variable (ctx
, v
);
8276 omp_notice_variable (ctx
, v
, true);
8278 decl
= TREE_OPERAND (decl
, 0);
8280 if (TREE_CODE (decl
) == ADDR_EXPR
8281 || TREE_CODE (decl
) == INDIRECT_REF
)
8282 decl
= TREE_OPERAND (decl
, 0);
8285 case OMP_CLAUSE_LINEAR
:
8286 if (gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
), pre_p
, NULL
,
8287 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8294 if (code
== OMP_SIMD
8295 && !OMP_CLAUSE_LINEAR_NO_COPYIN (c
))
8297 struct gimplify_omp_ctx
*octx
= outer_ctx
;
8299 && octx
->region_type
== ORT_WORKSHARE
8300 && octx
->combined_loop
8301 && !octx
->distribute
)
8303 if (octx
->outer_context
8304 && (octx
->outer_context
->region_type
8305 == ORT_COMBINED_PARALLEL
))
8306 octx
= octx
->outer_context
->outer_context
;
8308 octx
= octx
->outer_context
;
8311 && octx
->region_type
== ORT_WORKSHARE
8312 && octx
->combined_loop
8313 && octx
->distribute
)
8315 error_at (OMP_CLAUSE_LOCATION (c
),
8316 "%<linear%> clause for variable other than "
8317 "loop iterator specified on construct "
8318 "combined with %<distribute%>");
8323 /* For combined #pragma omp parallel for simd, need to put
8324 lastprivate and perhaps firstprivate too on the
8325 parallel. Similarly for #pragma omp for simd. */
8326 struct gimplify_omp_ctx
*octx
= outer_ctx
;
8330 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
8331 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
8333 decl
= OMP_CLAUSE_DECL (c
);
8334 if (error_operand_p (decl
))
8340 if (!OMP_CLAUSE_LINEAR_NO_COPYIN (c
))
8341 flags
|= GOVD_FIRSTPRIVATE
;
8342 if (!OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
8343 flags
|= GOVD_LASTPRIVATE
;
8345 && octx
->region_type
== ORT_WORKSHARE
8346 && octx
->combined_loop
)
8348 if (octx
->outer_context
8349 && (octx
->outer_context
->region_type
8350 == ORT_COMBINED_PARALLEL
))
8351 octx
= octx
->outer_context
;
8352 else if (omp_check_private (octx
, decl
, false))
8356 && (octx
->region_type
& ORT_TASK
) != 0
8357 && octx
->combined_loop
)
8360 && octx
->region_type
== ORT_COMBINED_PARALLEL
8361 && ctx
->region_type
== ORT_WORKSHARE
8362 && octx
== outer_ctx
)
8363 flags
= GOVD_SEEN
| GOVD_SHARED
;
8365 && ((octx
->region_type
& ORT_COMBINED_TEAMS
)
8366 == ORT_COMBINED_TEAMS
))
8367 flags
= GOVD_SEEN
| GOVD_SHARED
;
8369 && octx
->region_type
== ORT_COMBINED_TARGET
)
8371 flags
&= ~GOVD_LASTPRIVATE
;
8372 if (flags
== GOVD_SEEN
)
8378 = splay_tree_lookup (octx
->variables
,
8379 (splay_tree_key
) decl
);
8380 if (on
&& (on
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
8385 omp_add_variable (octx
, decl
, flags
);
8386 if (octx
->outer_context
== NULL
)
8388 octx
= octx
->outer_context
;
8393 && (!OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
8394 || !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)))
8395 omp_notice_variable (octx
, decl
, true);
8397 flags
= GOVD_LINEAR
| GOVD_EXPLICIT
;
8398 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
8399 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
8401 notice_outer
= false;
8402 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
8406 case OMP_CLAUSE_MAP
:
8407 decl
= OMP_CLAUSE_DECL (c
);
8408 if (error_operand_p (decl
))
8415 if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
8418 case OMP_TARGET_DATA
:
8419 case OMP_TARGET_ENTER_DATA
:
8420 case OMP_TARGET_EXIT_DATA
:
8421 case OACC_ENTER_DATA
:
8422 case OACC_EXIT_DATA
:
8423 case OACC_HOST_DATA
:
8424 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
8425 || (OMP_CLAUSE_MAP_KIND (c
)
8426 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
8427 /* For target {,enter ,exit }data only the array slice is
8428 mapped, but not the pointer to it. */
8436 if (DECL_P (decl
) && outer_ctx
&& (region_type
& ORT_ACC
))
8438 struct gimplify_omp_ctx
*octx
;
8439 for (octx
= outer_ctx
; octx
; octx
= octx
->outer_context
)
8441 if (octx
->region_type
!= ORT_ACC_HOST_DATA
)
8444 = splay_tree_lookup (octx
->variables
,
8445 (splay_tree_key
) decl
);
8447 error_at (OMP_CLAUSE_LOCATION (c
), "variable %qE "
8448 "declared in enclosing %<host_data%> region",
8452 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
8453 OMP_CLAUSE_SIZE (c
) = DECL_P (decl
) ? DECL_SIZE_UNIT (decl
)
8454 : TYPE_SIZE_UNIT (TREE_TYPE (decl
));
8455 if (gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
8456 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8461 else if ((OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
8462 || (OMP_CLAUSE_MAP_KIND (c
)
8463 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
8464 && TREE_CODE (OMP_CLAUSE_SIZE (c
)) != INTEGER_CST
)
8467 = get_initialized_tmp_var (OMP_CLAUSE_SIZE (c
), pre_p
, NULL
,
8469 omp_add_variable (ctx
, OMP_CLAUSE_SIZE (c
),
8470 GOVD_FIRSTPRIVATE
| GOVD_SEEN
);
8475 if (TREE_CODE (d
) == ARRAY_REF
)
8477 while (TREE_CODE (d
) == ARRAY_REF
)
8478 d
= TREE_OPERAND (d
, 0);
8479 if (TREE_CODE (d
) == COMPONENT_REF
8480 && TREE_CODE (TREE_TYPE (d
)) == ARRAY_TYPE
)
8483 pd
= &OMP_CLAUSE_DECL (c
);
8485 && TREE_CODE (decl
) == INDIRECT_REF
8486 && TREE_CODE (TREE_OPERAND (decl
, 0)) == COMPONENT_REF
8487 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl
, 0)))
8490 pd
= &TREE_OPERAND (decl
, 0);
8491 decl
= TREE_OPERAND (decl
, 0);
8493 if (TREE_CODE (decl
) == COMPONENT_REF
)
8495 while (TREE_CODE (decl
) == COMPONENT_REF
)
8496 decl
= TREE_OPERAND (decl
, 0);
8497 if (TREE_CODE (decl
) == INDIRECT_REF
8498 && DECL_P (TREE_OPERAND (decl
, 0))
8499 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl
, 0)))
8501 decl
= TREE_OPERAND (decl
, 0);
8503 if (gimplify_expr (pd
, pre_p
, NULL
, is_gimple_lvalue
, fb_lvalue
)
8511 if (error_operand_p (decl
))
8517 tree stype
= TREE_TYPE (decl
);
8518 if (TREE_CODE (stype
) == REFERENCE_TYPE
)
8519 stype
= TREE_TYPE (stype
);
8520 if (TYPE_SIZE_UNIT (stype
) == NULL
8521 || TREE_CODE (TYPE_SIZE_UNIT (stype
)) != INTEGER_CST
)
8523 error_at (OMP_CLAUSE_LOCATION (c
),
8524 "mapping field %qE of variable length "
8525 "structure", OMP_CLAUSE_DECL (c
));
8530 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_POINTER
)
8532 /* Error recovery. */
8533 if (prev_list_p
== NULL
)
8538 if (OMP_CLAUSE_CHAIN (*prev_list_p
) != c
)
8540 tree ch
= OMP_CLAUSE_CHAIN (*prev_list_p
);
8541 if (ch
== NULL_TREE
|| OMP_CLAUSE_CHAIN (ch
) != c
)
8550 poly_int64 bitsize
, bitpos
;
8552 int unsignedp
, reversep
, volatilep
= 0;
8553 tree base
= OMP_CLAUSE_DECL (c
);
8554 while (TREE_CODE (base
) == ARRAY_REF
)
8555 base
= TREE_OPERAND (base
, 0);
8556 if (TREE_CODE (base
) == INDIRECT_REF
)
8557 base
= TREE_OPERAND (base
, 0);
8558 base
= get_inner_reference (base
, &bitsize
, &bitpos
, &offset
,
8559 &mode
, &unsignedp
, &reversep
,
8561 tree orig_base
= base
;
8562 if ((TREE_CODE (base
) == INDIRECT_REF
8563 || (TREE_CODE (base
) == MEM_REF
8564 && integer_zerop (TREE_OPERAND (base
, 1))))
8565 && DECL_P (TREE_OPERAND (base
, 0))
8566 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base
, 0)))
8568 base
= TREE_OPERAND (base
, 0);
8569 gcc_assert (base
== decl
8570 && (offset
== NULL_TREE
8571 || poly_int_tree_p (offset
)));
8574 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
8575 bool ptr
= (OMP_CLAUSE_MAP_KIND (c
)
8576 == GOMP_MAP_ALWAYS_POINTER
);
8577 if (n
== NULL
|| (n
->value
& GOVD_MAP
) == 0)
8579 tree l
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8581 OMP_CLAUSE_SET_MAP_KIND (l
, GOMP_MAP_STRUCT
);
8582 if (orig_base
!= base
)
8583 OMP_CLAUSE_DECL (l
) = unshare_expr (orig_base
);
8585 OMP_CLAUSE_DECL (l
) = decl
;
8586 OMP_CLAUSE_SIZE (l
) = size_int (1);
8587 if (struct_map_to_clause
== NULL
)
8588 struct_map_to_clause
= new hash_map
<tree
, tree
>;
8589 struct_map_to_clause
->put (decl
, l
);
8592 enum gomp_map_kind mkind
8593 = code
== OMP_TARGET_EXIT_DATA
8594 ? GOMP_MAP_RELEASE
: GOMP_MAP_ALLOC
;
8595 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8597 OMP_CLAUSE_SET_MAP_KIND (c2
, mkind
);
8598 OMP_CLAUSE_DECL (c2
)
8599 = unshare_expr (OMP_CLAUSE_DECL (c
));
8600 OMP_CLAUSE_CHAIN (c2
) = *prev_list_p
;
8601 OMP_CLAUSE_SIZE (c2
)
8602 = TYPE_SIZE_UNIT (ptr_type_node
);
8603 OMP_CLAUSE_CHAIN (l
) = c2
;
8604 if (OMP_CLAUSE_CHAIN (*prev_list_p
) != c
)
8606 tree c4
= OMP_CLAUSE_CHAIN (*prev_list_p
);
8608 = build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8610 OMP_CLAUSE_SET_MAP_KIND (c3
, mkind
);
8611 OMP_CLAUSE_DECL (c3
)
8612 = unshare_expr (OMP_CLAUSE_DECL (c4
));
8613 OMP_CLAUSE_SIZE (c3
)
8614 = TYPE_SIZE_UNIT (ptr_type_node
);
8615 OMP_CLAUSE_CHAIN (c3
) = *prev_list_p
;
8616 OMP_CLAUSE_CHAIN (c2
) = c3
;
8623 OMP_CLAUSE_CHAIN (l
) = c
;
8625 list_p
= &OMP_CLAUSE_CHAIN (l
);
8627 if (orig_base
!= base
&& code
== OMP_TARGET
)
8629 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8631 enum gomp_map_kind mkind
8632 = GOMP_MAP_FIRSTPRIVATE_REFERENCE
;
8633 OMP_CLAUSE_SET_MAP_KIND (c2
, mkind
);
8634 OMP_CLAUSE_DECL (c2
) = decl
;
8635 OMP_CLAUSE_SIZE (c2
) = size_zero_node
;
8636 OMP_CLAUSE_CHAIN (c2
) = OMP_CLAUSE_CHAIN (l
);
8637 OMP_CLAUSE_CHAIN (l
) = c2
;
8639 flags
= GOVD_MAP
| GOVD_EXPLICIT
;
8640 if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c
)) || ptr
)
8646 tree
*osc
= struct_map_to_clause
->get (decl
);
8647 tree
*sc
= NULL
, *scp
= NULL
;
8648 if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c
)) || ptr
)
8649 n
->value
|= GOVD_SEEN
;
8650 poly_offset_int o1
, o2
;
8652 o1
= wi::to_poly_offset (offset
);
8655 if (maybe_ne (bitpos
, 0))
8656 o1
+= bits_to_bytes_round_down (bitpos
);
8657 sc
= &OMP_CLAUSE_CHAIN (*osc
);
8659 && (OMP_CLAUSE_MAP_KIND (*sc
)
8660 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
8661 sc
= &OMP_CLAUSE_CHAIN (*sc
);
8662 for (; *sc
!= c
; sc
= &OMP_CLAUSE_CHAIN (*sc
))
8663 if (ptr
&& sc
== prev_list_p
)
8665 else if (TREE_CODE (OMP_CLAUSE_DECL (*sc
))
8667 && (TREE_CODE (OMP_CLAUSE_DECL (*sc
))
8669 && (TREE_CODE (OMP_CLAUSE_DECL (*sc
))
8675 poly_int64 bitsize2
, bitpos2
;
8676 base
= OMP_CLAUSE_DECL (*sc
);
8677 if (TREE_CODE (base
) == ARRAY_REF
)
8679 while (TREE_CODE (base
) == ARRAY_REF
)
8680 base
= TREE_OPERAND (base
, 0);
8681 if (TREE_CODE (base
) != COMPONENT_REF
8682 || (TREE_CODE (TREE_TYPE (base
))
8686 else if (TREE_CODE (base
) == INDIRECT_REF
8687 && (TREE_CODE (TREE_OPERAND (base
, 0))
8689 && (TREE_CODE (TREE_TYPE
8690 (TREE_OPERAND (base
, 0)))
8692 base
= TREE_OPERAND (base
, 0);
8693 base
= get_inner_reference (base
, &bitsize2
,
8696 &reversep
, &volatilep
);
8697 if ((TREE_CODE (base
) == INDIRECT_REF
8698 || (TREE_CODE (base
) == MEM_REF
8699 && integer_zerop (TREE_OPERAND (base
,
8701 && DECL_P (TREE_OPERAND (base
, 0))
8702 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base
,
8705 base
= TREE_OPERAND (base
, 0);
8710 gcc_assert (offset
== NULL_TREE
8711 || poly_int_tree_p (offset
));
8712 tree d1
= OMP_CLAUSE_DECL (*sc
);
8713 tree d2
= OMP_CLAUSE_DECL (c
);
8714 while (TREE_CODE (d1
) == ARRAY_REF
)
8715 d1
= TREE_OPERAND (d1
, 0);
8716 while (TREE_CODE (d2
) == ARRAY_REF
)
8717 d2
= TREE_OPERAND (d2
, 0);
8718 if (TREE_CODE (d1
) == INDIRECT_REF
)
8719 d1
= TREE_OPERAND (d1
, 0);
8720 if (TREE_CODE (d2
) == INDIRECT_REF
)
8721 d2
= TREE_OPERAND (d2
, 0);
8722 while (TREE_CODE (d1
) == COMPONENT_REF
)
8723 if (TREE_CODE (d2
) == COMPONENT_REF
8724 && TREE_OPERAND (d1
, 1)
8725 == TREE_OPERAND (d2
, 1))
8727 d1
= TREE_OPERAND (d1
, 0);
8728 d2
= TREE_OPERAND (d2
, 0);
8734 error_at (OMP_CLAUSE_LOCATION (c
),
8735 "%qE appears more than once in map "
8736 "clauses", OMP_CLAUSE_DECL (c
));
8741 o2
= wi::to_poly_offset (offset2
);
8744 o2
+= bits_to_bytes_round_down (bitpos2
);
8745 if (maybe_lt (o1
, o2
)
8746 || (known_eq (o1
, o2
)
8747 && maybe_lt (bitpos
, bitpos2
)))
8757 OMP_CLAUSE_SIZE (*osc
)
8758 = size_binop (PLUS_EXPR
, OMP_CLAUSE_SIZE (*osc
),
8762 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8764 tree cl
= NULL_TREE
;
8765 enum gomp_map_kind mkind
8766 = code
== OMP_TARGET_EXIT_DATA
8767 ? GOMP_MAP_RELEASE
: GOMP_MAP_ALLOC
;
8768 OMP_CLAUSE_SET_MAP_KIND (c2
, mkind
);
8769 OMP_CLAUSE_DECL (c2
)
8770 = unshare_expr (OMP_CLAUSE_DECL (c
));
8771 OMP_CLAUSE_CHAIN (c2
) = scp
? *scp
: *prev_list_p
;
8772 OMP_CLAUSE_SIZE (c2
)
8773 = TYPE_SIZE_UNIT (ptr_type_node
);
8774 cl
= scp
? *prev_list_p
: c2
;
8775 if (OMP_CLAUSE_CHAIN (*prev_list_p
) != c
)
8777 tree c4
= OMP_CLAUSE_CHAIN (*prev_list_p
);
8779 = build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8781 OMP_CLAUSE_SET_MAP_KIND (c3
, mkind
);
8782 OMP_CLAUSE_DECL (c3
)
8783 = unshare_expr (OMP_CLAUSE_DECL (c4
));
8784 OMP_CLAUSE_SIZE (c3
)
8785 = TYPE_SIZE_UNIT (ptr_type_node
);
8786 OMP_CLAUSE_CHAIN (c3
) = *prev_list_p
;
8788 OMP_CLAUSE_CHAIN (c2
) = c3
;
8794 if (sc
== prev_list_p
)
8801 *prev_list_p
= OMP_CLAUSE_CHAIN (c
);
8802 list_p
= prev_list_p
;
8804 OMP_CLAUSE_CHAIN (c
) = *sc
;
8811 *list_p
= OMP_CLAUSE_CHAIN (c
);
8812 OMP_CLAUSE_CHAIN (c
) = *sc
;
8819 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_ALWAYS_POINTER
8820 && OMP_CLAUSE_CHAIN (c
)
8821 && OMP_CLAUSE_CODE (OMP_CLAUSE_CHAIN (c
)) == OMP_CLAUSE_MAP
8822 && (OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (c
))
8823 == GOMP_MAP_ALWAYS_POINTER
))
8824 prev_list_p
= list_p
;
8827 flags
= GOVD_MAP
| GOVD_EXPLICIT
;
8828 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_TO
8829 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_TOFROM
)
8830 flags
|= GOVD_MAP_ALWAYS_TO
;
8833 case OMP_CLAUSE_DEPEND
:
8834 if (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
)
8836 tree deps
= OMP_CLAUSE_DECL (c
);
8837 while (deps
&& TREE_CODE (deps
) == TREE_LIST
)
8839 if (TREE_CODE (TREE_PURPOSE (deps
)) == TRUNC_DIV_EXPR
8840 && DECL_P (TREE_OPERAND (TREE_PURPOSE (deps
), 1)))
8841 gimplify_expr (&TREE_OPERAND (TREE_PURPOSE (deps
), 1),
8842 pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
8843 deps
= TREE_CHAIN (deps
);
8847 else if (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SOURCE
)
8849 if (handled_depend_iterators
== -1)
8850 handled_depend_iterators
= gimplify_omp_depend (list_p
, pre_p
);
8851 if (handled_depend_iterators
)
8853 if (handled_depend_iterators
== 2)
8857 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == COMPOUND_EXPR
)
8859 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0), pre_p
,
8860 NULL
, is_gimple_val
, fb_rvalue
);
8861 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (OMP_CLAUSE_DECL (c
), 1);
8863 if (error_operand_p (OMP_CLAUSE_DECL (c
)))
8868 OMP_CLAUSE_DECL (c
) = build_fold_addr_expr (OMP_CLAUSE_DECL (c
));
8869 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
, NULL
,
8870 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8878 case OMP_CLAUSE_FROM
:
8879 case OMP_CLAUSE__CACHE_
:
8880 decl
= OMP_CLAUSE_DECL (c
);
8881 if (error_operand_p (decl
))
8886 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
8887 OMP_CLAUSE_SIZE (c
) = DECL_P (decl
) ? DECL_SIZE_UNIT (decl
)
8888 : TYPE_SIZE_UNIT (TREE_TYPE (decl
));
8889 if (gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
8890 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8897 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
,
8898 NULL
, is_gimple_lvalue
, fb_lvalue
)
8908 case OMP_CLAUSE_USE_DEVICE_PTR
:
8909 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
8911 case OMP_CLAUSE_IS_DEVICE_PTR
:
8912 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
8916 decl
= OMP_CLAUSE_DECL (c
);
8918 if (error_operand_p (decl
))
8923 if (DECL_NAME (decl
) == NULL_TREE
&& (flags
& GOVD_SHARED
) == 0)
8925 tree t
= omp_member_access_dummy_var (decl
);
8928 tree v
= DECL_VALUE_EXPR (decl
);
8929 DECL_NAME (decl
) = DECL_NAME (TREE_OPERAND (v
, 1));
8931 omp_notice_variable (outer_ctx
, t
, true);
8934 if (code
== OACC_DATA
8935 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
8936 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
)
8937 flags
|= GOVD_MAP_0LEN_ARRAY
;
8938 omp_add_variable (ctx
, decl
, flags
);
8939 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
8940 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IN_REDUCTION
8941 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TASK_REDUCTION
)
8942 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
8944 omp_add_variable (ctx
, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
),
8945 GOVD_LOCAL
| GOVD_SEEN
);
8946 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
)
8947 && walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c
),
8949 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
),
8951 omp_add_variable (ctx
,
8952 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
),
8953 GOVD_LOCAL
| GOVD_SEEN
);
8954 gimplify_omp_ctxp
= ctx
;
8955 push_gimplify_context ();
8957 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
8958 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
8960 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c
),
8961 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
8962 pop_gimplify_context
8963 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
)));
8964 push_gimplify_context ();
8965 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c
),
8966 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
8967 pop_gimplify_context
8968 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
)));
8969 OMP_CLAUSE_REDUCTION_INIT (c
) = NULL_TREE
;
8970 OMP_CLAUSE_REDUCTION_MERGE (c
) = NULL_TREE
;
8972 gimplify_omp_ctxp
= outer_ctx
;
8974 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
8975 && OMP_CLAUSE_LASTPRIVATE_STMT (c
))
8977 gimplify_omp_ctxp
= ctx
;
8978 push_gimplify_context ();
8979 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c
)) != BIND_EXPR
)
8981 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
8983 TREE_SIDE_EFFECTS (bind
) = 1;
8984 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LASTPRIVATE_STMT (c
);
8985 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = bind
;
8987 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c
),
8988 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
8989 pop_gimplify_context
8990 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
)));
8991 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = NULL_TREE
;
8993 gimplify_omp_ctxp
= outer_ctx
;
8995 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
8996 && OMP_CLAUSE_LINEAR_STMT (c
))
8998 gimplify_omp_ctxp
= ctx
;
8999 push_gimplify_context ();
9000 if (TREE_CODE (OMP_CLAUSE_LINEAR_STMT (c
)) != BIND_EXPR
)
9002 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
9004 TREE_SIDE_EFFECTS (bind
) = 1;
9005 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LINEAR_STMT (c
);
9006 OMP_CLAUSE_LINEAR_STMT (c
) = bind
;
9008 gimplify_and_add (OMP_CLAUSE_LINEAR_STMT (c
),
9009 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
));
9010 pop_gimplify_context
9011 (gimple_seq_first_stmt (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
)));
9012 OMP_CLAUSE_LINEAR_STMT (c
) = NULL_TREE
;
9014 gimplify_omp_ctxp
= outer_ctx
;
9020 case OMP_CLAUSE_COPYIN
:
9021 case OMP_CLAUSE_COPYPRIVATE
:
9022 decl
= OMP_CLAUSE_DECL (c
);
9023 if (error_operand_p (decl
))
9028 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_COPYPRIVATE
9030 && !omp_check_private (ctx
, decl
, true))
9033 if (is_global_var (decl
))
9035 if (DECL_THREAD_LOCAL_P (decl
))
9037 else if (DECL_HAS_VALUE_EXPR_P (decl
))
9039 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
9043 && DECL_THREAD_LOCAL_P (value
))
9048 error_at (OMP_CLAUSE_LOCATION (c
),
9049 "copyprivate variable %qE is not threadprivate"
9050 " or private in outer context", DECL_NAME (decl
));
9053 if ((region_type
& ORT_TASKLOOP
) == ORT_TASKLOOP
9055 && outer_ctx
->region_type
== ORT_COMBINED_PARALLEL
9056 && (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
9057 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
9058 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
))
9061 = splay_tree_lookup (outer_ctx
->variables
,
9062 (splay_tree_key
)decl
);
9063 if (on
== NULL
|| (on
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
9065 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
9066 && TREE_CODE (OMP_CLAUSE_DECL (c
)) == MEM_REF
9067 && (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
9068 || (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
9069 && (TREE_CODE (TREE_TYPE (TREE_TYPE (decl
)))
9071 omp_firstprivatize_variable (outer_ctx
, decl
);
9073 omp_add_variable (outer_ctx
, decl
,
9074 GOVD_SEEN
| GOVD_SHARED
);
9075 omp_notice_variable (outer_ctx
, decl
, true);
9079 omp_notice_variable (outer_ctx
, decl
, true);
9080 if (check_non_private
9081 && region_type
== ORT_WORKSHARE
9082 && (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_REDUCTION
9083 || decl
== OMP_CLAUSE_DECL (c
)
9084 || (TREE_CODE (OMP_CLAUSE_DECL (c
)) == MEM_REF
9085 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0))
9087 || (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0))
9088 == POINTER_PLUS_EXPR
9089 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND
9090 (OMP_CLAUSE_DECL (c
), 0), 0))
9092 && omp_check_private (ctx
, decl
, false))
9094 error ("%s variable %qE is private in outer context",
9095 check_non_private
, DECL_NAME (decl
));
9101 if (OMP_CLAUSE_IF_MODIFIER (c
) != ERROR_MARK
9102 && OMP_CLAUSE_IF_MODIFIER (c
) != code
)
9105 for (int i
= 0; i
< 2; i
++)
9106 switch (i
? OMP_CLAUSE_IF_MODIFIER (c
) : code
)
9108 case VOID_CST
: p
[i
] = "cancel"; break;
9109 case OMP_PARALLEL
: p
[i
] = "parallel"; break;
9110 case OMP_SIMD
: p
[i
] = "simd"; break;
9111 case OMP_TASK
: p
[i
] = "task"; break;
9112 case OMP_TASKLOOP
: p
[i
] = "taskloop"; break;
9113 case OMP_TARGET_DATA
: p
[i
] = "target data"; break;
9114 case OMP_TARGET
: p
[i
] = "target"; break;
9115 case OMP_TARGET_UPDATE
: p
[i
] = "target update"; break;
9116 case OMP_TARGET_ENTER_DATA
:
9117 p
[i
] = "target enter data"; break;
9118 case OMP_TARGET_EXIT_DATA
: p
[i
] = "target exit data"; break;
9119 default: gcc_unreachable ();
9121 error_at (OMP_CLAUSE_LOCATION (c
),
9122 "expected %qs %<if%> clause modifier rather than %qs",
9128 case OMP_CLAUSE_FINAL
:
9129 OMP_CLAUSE_OPERAND (c
, 0)
9130 = gimple_boolify (OMP_CLAUSE_OPERAND (c
, 0));
9133 case OMP_CLAUSE_SCHEDULE
:
9134 case OMP_CLAUSE_NUM_THREADS
:
9135 case OMP_CLAUSE_NUM_TEAMS
:
9136 case OMP_CLAUSE_THREAD_LIMIT
:
9137 case OMP_CLAUSE_DIST_SCHEDULE
:
9138 case OMP_CLAUSE_DEVICE
:
9139 case OMP_CLAUSE_PRIORITY
:
9140 case OMP_CLAUSE_GRAINSIZE
:
9141 case OMP_CLAUSE_NUM_TASKS
:
9142 case OMP_CLAUSE_HINT
:
9143 case OMP_CLAUSE_ASYNC
:
9144 case OMP_CLAUSE_WAIT
:
9145 case OMP_CLAUSE_NUM_GANGS
:
9146 case OMP_CLAUSE_NUM_WORKERS
:
9147 case OMP_CLAUSE_VECTOR_LENGTH
:
9148 case OMP_CLAUSE_WORKER
:
9149 case OMP_CLAUSE_VECTOR
:
9150 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
9151 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
9155 case OMP_CLAUSE_GANG
:
9156 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
9157 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
9159 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 1), pre_p
, NULL
,
9160 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
9164 case OMP_CLAUSE_NOWAIT
:
9168 case OMP_CLAUSE_ORDERED
:
9169 case OMP_CLAUSE_UNTIED
:
9170 case OMP_CLAUSE_COLLAPSE
:
9171 case OMP_CLAUSE_TILE
:
9172 case OMP_CLAUSE_AUTO
:
9173 case OMP_CLAUSE_SEQ
:
9174 case OMP_CLAUSE_INDEPENDENT
:
9175 case OMP_CLAUSE_MERGEABLE
:
9176 case OMP_CLAUSE_PROC_BIND
:
9177 case OMP_CLAUSE_SAFELEN
:
9178 case OMP_CLAUSE_SIMDLEN
:
9179 case OMP_CLAUSE_NOGROUP
:
9180 case OMP_CLAUSE_THREADS
:
9181 case OMP_CLAUSE_SIMD
:
9182 case OMP_CLAUSE_IF_PRESENT
:
9183 case OMP_CLAUSE_FINALIZE
:
9186 case OMP_CLAUSE_DEFAULTMAP
:
9187 enum gimplify_defaultmap_kind gdmkmin
, gdmkmax
;
9188 switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (c
))
9190 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED
:
9191 gdmkmin
= GDMK_SCALAR
;
9192 gdmkmax
= GDMK_POINTER
;
9194 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR
:
9195 gdmkmin
= gdmkmax
= GDMK_SCALAR
;
9197 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE
:
9198 gdmkmin
= gdmkmax
= GDMK_AGGREGATE
;
9200 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE
:
9201 gdmkmin
= gdmkmax
= GDMK_ALLOCATABLE
;
9203 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER
:
9204 gdmkmin
= gdmkmax
= GDMK_POINTER
;
9209 for (int gdmk
= gdmkmin
; gdmk
<= gdmkmax
; gdmk
++)
9210 switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (c
))
9212 case OMP_CLAUSE_DEFAULTMAP_ALLOC
:
9213 ctx
->defaultmap
[gdmk
] = GOVD_MAP
| GOVD_MAP_ALLOC_ONLY
;
9215 case OMP_CLAUSE_DEFAULTMAP_TO
:
9216 ctx
->defaultmap
[gdmk
] = GOVD_MAP
| GOVD_MAP_TO_ONLY
;
9218 case OMP_CLAUSE_DEFAULTMAP_FROM
:
9219 ctx
->defaultmap
[gdmk
] = GOVD_MAP
| GOVD_MAP_FROM_ONLY
;
9221 case OMP_CLAUSE_DEFAULTMAP_TOFROM
:
9222 ctx
->defaultmap
[gdmk
] = GOVD_MAP
;
9224 case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE
:
9225 ctx
->defaultmap
[gdmk
] = GOVD_FIRSTPRIVATE
;
9227 case OMP_CLAUSE_DEFAULTMAP_NONE
:
9228 ctx
->defaultmap
[gdmk
] = 0;
9230 case OMP_CLAUSE_DEFAULTMAP_DEFAULT
:
9234 ctx
->defaultmap
[gdmk
] = GOVD_FIRSTPRIVATE
;
9236 case GDMK_AGGREGATE
:
9237 case GDMK_ALLOCATABLE
:
9238 ctx
->defaultmap
[gdmk
] = GOVD_MAP
;
9241 ctx
->defaultmap
[gdmk
] = GOVD_MAP
| GOVD_MAP_0LEN_ARRAY
;
9252 case OMP_CLAUSE_ALIGNED
:
9253 decl
= OMP_CLAUSE_DECL (c
);
9254 if (error_operand_p (decl
))
9259 if (gimplify_expr (&OMP_CLAUSE_ALIGNED_ALIGNMENT (c
), pre_p
, NULL
,
9260 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
9265 if (!is_global_var (decl
)
9266 && TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
9267 omp_add_variable (ctx
, decl
, GOVD_ALIGNED
);
9270 case OMP_CLAUSE_NONTEMPORAL
:
9271 decl
= OMP_CLAUSE_DECL (c
);
9272 if (error_operand_p (decl
))
9277 omp_add_variable (ctx
, decl
, GOVD_NONTEMPORAL
);
9280 case OMP_CLAUSE_DEFAULT
:
9281 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
9288 if (code
== OACC_DATA
9289 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
9290 && (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
9291 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
9294 *list_p
= OMP_CLAUSE_CHAIN (c
);
9296 list_p
= &OMP_CLAUSE_CHAIN (c
);
9299 gimplify_omp_ctxp
= ctx
;
9300 if (struct_map_to_clause
)
9301 delete struct_map_to_clause
;
9304 /* Return true if DECL is a candidate for shared to firstprivate
9305 optimization. We only consider non-addressable scalars, not
9306 too big, and not references. */
9309 omp_shared_to_firstprivate_optimizable_decl_p (tree decl
)
9311 if (TREE_ADDRESSABLE (decl
))
9313 tree type
= TREE_TYPE (decl
);
9314 if (!is_gimple_reg_type (type
)
9315 || TREE_CODE (type
) == REFERENCE_TYPE
9316 || TREE_ADDRESSABLE (type
))
9318 /* Don't optimize too large decls, as each thread/task will have
9320 HOST_WIDE_INT len
= int_size_in_bytes (type
);
9321 if (len
== -1 || len
> 4 * POINTER_SIZE
/ BITS_PER_UNIT
)
9323 if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
9328 /* Helper function of omp_find_stores_op and gimplify_adjust_omp_clauses*.
9329 For omp_shared_to_firstprivate_optimizable_decl_p decl mark it as
9330 GOVD_WRITTEN in outer contexts. */
9333 omp_mark_stores (struct gimplify_omp_ctx
*ctx
, tree decl
)
9335 for (; ctx
; ctx
= ctx
->outer_context
)
9337 splay_tree_node n
= splay_tree_lookup (ctx
->variables
,
9338 (splay_tree_key
) decl
);
9341 else if (n
->value
& GOVD_SHARED
)
9343 n
->value
|= GOVD_WRITTEN
;
9346 else if (n
->value
& GOVD_DATA_SHARE_CLASS
)
9351 /* Helper callback for walk_gimple_seq to discover possible stores
9352 to omp_shared_to_firstprivate_optimizable_decl_p decls and set
9353 GOVD_WRITTEN if they are GOVD_SHARED in some outer context
9357 omp_find_stores_op (tree
*tp
, int *walk_subtrees
, void *data
)
9359 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
9368 if (handled_component_p (op
))
9369 op
= TREE_OPERAND (op
, 0);
9370 else if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
9371 && TREE_CODE (TREE_OPERAND (op
, 0)) == ADDR_EXPR
)
9372 op
= TREE_OPERAND (TREE_OPERAND (op
, 0), 0);
9377 if (!DECL_P (op
) || !omp_shared_to_firstprivate_optimizable_decl_p (op
))
9380 omp_mark_stores (gimplify_omp_ctxp
, op
);
9384 /* Helper callback for walk_gimple_seq to discover possible stores
9385 to omp_shared_to_firstprivate_optimizable_decl_p decls and set
9386 GOVD_WRITTEN if they are GOVD_SHARED in some outer context
9390 omp_find_stores_stmt (gimple_stmt_iterator
*gsi_p
,
9391 bool *handled_ops_p
,
9392 struct walk_stmt_info
*wi
)
9394 gimple
*stmt
= gsi_stmt (*gsi_p
);
9395 switch (gimple_code (stmt
))
9397 /* Don't recurse on OpenMP constructs for which
9398 gimplify_adjust_omp_clauses already handled the bodies,
9399 except handle gimple_omp_for_pre_body. */
9400 case GIMPLE_OMP_FOR
:
9401 *handled_ops_p
= true;
9402 if (gimple_omp_for_pre_body (stmt
))
9403 walk_gimple_seq (gimple_omp_for_pre_body (stmt
),
9404 omp_find_stores_stmt
, omp_find_stores_op
, wi
);
9406 case GIMPLE_OMP_PARALLEL
:
9407 case GIMPLE_OMP_TASK
:
9408 case GIMPLE_OMP_SECTIONS
:
9409 case GIMPLE_OMP_SINGLE
:
9410 case GIMPLE_OMP_TARGET
:
9411 case GIMPLE_OMP_TEAMS
:
9412 case GIMPLE_OMP_CRITICAL
:
9413 *handled_ops_p
= true;
9421 struct gimplify_adjust_omp_clauses_data
9427 /* For all variables that were not actually used within the context,
9428 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
9431 gimplify_adjust_omp_clauses_1 (splay_tree_node n
, void *data
)
9433 tree
*list_p
= ((struct gimplify_adjust_omp_clauses_data
*) data
)->list_p
;
9435 = ((struct gimplify_adjust_omp_clauses_data
*) data
)->pre_p
;
9436 tree decl
= (tree
) n
->key
;
9437 unsigned flags
= n
->value
;
9438 enum omp_clause_code code
;
9442 if (flags
& (GOVD_EXPLICIT
| GOVD_LOCAL
))
9444 if ((flags
& GOVD_SEEN
) == 0)
9446 if (flags
& GOVD_DEBUG_PRIVATE
)
9448 gcc_assert ((flags
& GOVD_DATA_SHARE_CLASS
) == GOVD_SHARED
);
9449 private_debug
= true;
9451 else if (flags
& GOVD_MAP
)
9452 private_debug
= false;
9455 = lang_hooks
.decls
.omp_private_debug_clause (decl
,
9456 !!(flags
& GOVD_SHARED
));
9458 code
= OMP_CLAUSE_PRIVATE
;
9459 else if (flags
& GOVD_MAP
)
9461 code
= OMP_CLAUSE_MAP
;
9462 if ((gimplify_omp_ctxp
->region_type
& ORT_ACC
) == 0
9463 && TYPE_ATOMIC (strip_array_types (TREE_TYPE (decl
))))
9465 error ("%<_Atomic%> %qD in implicit %<map%> clause", decl
);
9469 else if (flags
& GOVD_SHARED
)
9471 if (is_global_var (decl
))
9473 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
9477 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9478 if (on
&& (on
->value
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
9479 | GOVD_PRIVATE
| GOVD_REDUCTION
9480 | GOVD_LINEAR
| GOVD_MAP
)) != 0)
9482 ctx
= ctx
->outer_context
;
9487 code
= OMP_CLAUSE_SHARED
;
9489 else if (flags
& GOVD_PRIVATE
)
9490 code
= OMP_CLAUSE_PRIVATE
;
9491 else if (flags
& GOVD_FIRSTPRIVATE
)
9493 code
= OMP_CLAUSE_FIRSTPRIVATE
;
9494 if ((gimplify_omp_ctxp
->region_type
& ORT_TARGET
)
9495 && (gimplify_omp_ctxp
->region_type
& ORT_ACC
) == 0
9496 && TYPE_ATOMIC (strip_array_types (TREE_TYPE (decl
))))
9498 error ("%<_Atomic%> %qD in implicit %<firstprivate%> clause on "
9499 "%<target%> construct", decl
);
9503 else if (flags
& GOVD_LASTPRIVATE
)
9504 code
= OMP_CLAUSE_LASTPRIVATE
;
9505 else if (flags
& (GOVD_ALIGNED
| GOVD_NONTEMPORAL
))
9510 if (((flags
& GOVD_LASTPRIVATE
)
9511 || (code
== OMP_CLAUSE_SHARED
&& (flags
& GOVD_WRITTEN
)))
9512 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
9513 omp_mark_stores (gimplify_omp_ctxp
->outer_context
, decl
);
9515 tree chain
= *list_p
;
9516 clause
= build_omp_clause (input_location
, code
);
9517 OMP_CLAUSE_DECL (clause
) = decl
;
9518 OMP_CLAUSE_CHAIN (clause
) = chain
;
9520 OMP_CLAUSE_PRIVATE_DEBUG (clause
) = 1;
9521 else if (code
== OMP_CLAUSE_PRIVATE
&& (flags
& GOVD_PRIVATE_OUTER_REF
))
9522 OMP_CLAUSE_PRIVATE_OUTER_REF (clause
) = 1;
9523 else if (code
== OMP_CLAUSE_SHARED
9524 && (flags
& GOVD_WRITTEN
) == 0
9525 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
9526 OMP_CLAUSE_SHARED_READONLY (clause
) = 1;
9527 else if (code
== OMP_CLAUSE_FIRSTPRIVATE
&& (flags
& GOVD_EXPLICIT
) == 0)
9528 OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT (clause
) = 1;
9529 else if (code
== OMP_CLAUSE_MAP
&& (flags
& GOVD_MAP_0LEN_ARRAY
) != 0)
9531 tree nc
= build_omp_clause (input_location
, OMP_CLAUSE_MAP
);
9532 OMP_CLAUSE_DECL (nc
) = decl
;
9533 if (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
9534 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == POINTER_TYPE
)
9535 OMP_CLAUSE_DECL (clause
)
9536 = build_simple_mem_ref_loc (input_location
, decl
);
9537 OMP_CLAUSE_DECL (clause
)
9538 = build2 (MEM_REF
, char_type_node
, OMP_CLAUSE_DECL (clause
),
9539 build_int_cst (build_pointer_type (char_type_node
), 0));
9540 OMP_CLAUSE_SIZE (clause
) = size_zero_node
;
9541 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
9542 OMP_CLAUSE_SET_MAP_KIND (clause
, GOMP_MAP_ALLOC
);
9543 OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (clause
) = 1;
9544 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_FIRSTPRIVATE_POINTER
);
9545 OMP_CLAUSE_CHAIN (nc
) = chain
;
9546 OMP_CLAUSE_CHAIN (clause
) = nc
;
9547 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
9548 gimplify_omp_ctxp
= ctx
->outer_context
;
9549 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (clause
), 0),
9550 pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
9551 gimplify_omp_ctxp
= ctx
;
9553 else if (code
== OMP_CLAUSE_MAP
)
9556 /* Not all combinations of these GOVD_MAP flags are actually valid. */
9557 switch (flags
& (GOVD_MAP_TO_ONLY
9559 | GOVD_MAP_FORCE_PRESENT
9560 | GOVD_MAP_ALLOC_ONLY
9561 | GOVD_MAP_FROM_ONLY
))
9564 kind
= GOMP_MAP_TOFROM
;
9566 case GOVD_MAP_FORCE
:
9567 kind
= GOMP_MAP_TOFROM
| GOMP_MAP_FLAG_FORCE
;
9569 case GOVD_MAP_TO_ONLY
:
9572 case GOVD_MAP_FROM_ONLY
:
9573 kind
= GOMP_MAP_FROM
;
9575 case GOVD_MAP_ALLOC_ONLY
:
9576 kind
= GOMP_MAP_ALLOC
;
9578 case GOVD_MAP_TO_ONLY
| GOVD_MAP_FORCE
:
9579 kind
= GOMP_MAP_TO
| GOMP_MAP_FLAG_FORCE
;
9581 case GOVD_MAP_FORCE_PRESENT
:
9582 kind
= GOMP_MAP_FORCE_PRESENT
;
9587 OMP_CLAUSE_SET_MAP_KIND (clause
, kind
);
9588 if (DECL_SIZE (decl
)
9589 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
9591 tree decl2
= DECL_VALUE_EXPR (decl
);
9592 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
9593 decl2
= TREE_OPERAND (decl2
, 0);
9594 gcc_assert (DECL_P (decl2
));
9595 tree mem
= build_simple_mem_ref (decl2
);
9596 OMP_CLAUSE_DECL (clause
) = mem
;
9597 OMP_CLAUSE_SIZE (clause
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
9598 if (gimplify_omp_ctxp
->outer_context
)
9600 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
9601 omp_notice_variable (ctx
, decl2
, true);
9602 omp_notice_variable (ctx
, OMP_CLAUSE_SIZE (clause
), true);
9604 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
),
9606 OMP_CLAUSE_DECL (nc
) = decl
;
9607 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
9608 if (gimplify_omp_ctxp
->target_firstprivatize_array_bases
)
9609 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_FIRSTPRIVATE_POINTER
);
9611 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_POINTER
);
9612 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (clause
);
9613 OMP_CLAUSE_CHAIN (clause
) = nc
;
9615 else if (gimplify_omp_ctxp
->target_firstprivatize_array_bases
9616 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
9618 OMP_CLAUSE_DECL (clause
) = build_simple_mem_ref (decl
);
9619 OMP_CLAUSE_SIZE (clause
)
9620 = unshare_expr (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
))));
9621 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
9622 gimplify_omp_ctxp
= ctx
->outer_context
;
9623 gimplify_expr (&OMP_CLAUSE_SIZE (clause
),
9624 pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
9625 gimplify_omp_ctxp
= ctx
;
9626 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
),
9628 OMP_CLAUSE_DECL (nc
) = decl
;
9629 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
9630 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_FIRSTPRIVATE_REFERENCE
);
9631 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (clause
);
9632 OMP_CLAUSE_CHAIN (clause
) = nc
;
9635 OMP_CLAUSE_SIZE (clause
) = DECL_SIZE_UNIT (decl
);
9637 if (code
== OMP_CLAUSE_FIRSTPRIVATE
&& (flags
& GOVD_LASTPRIVATE
) != 0)
9639 tree nc
= build_omp_clause (input_location
, OMP_CLAUSE_LASTPRIVATE
);
9640 OMP_CLAUSE_DECL (nc
) = decl
;
9641 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (nc
) = 1;
9642 OMP_CLAUSE_CHAIN (nc
) = chain
;
9643 OMP_CLAUSE_CHAIN (clause
) = nc
;
9644 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
9645 gimplify_omp_ctxp
= ctx
->outer_context
;
9646 lang_hooks
.decls
.omp_finish_clause (nc
, pre_p
);
9647 gimplify_omp_ctxp
= ctx
;
9650 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
9651 gimplify_omp_ctxp
= ctx
->outer_context
;
9652 lang_hooks
.decls
.omp_finish_clause (clause
, pre_p
);
9653 if (gimplify_omp_ctxp
)
9654 for (; clause
!= chain
; clause
= OMP_CLAUSE_CHAIN (clause
))
9655 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
9656 && DECL_P (OMP_CLAUSE_SIZE (clause
)))
9657 omp_notice_variable (gimplify_omp_ctxp
, OMP_CLAUSE_SIZE (clause
),
9659 gimplify_omp_ctxp
= ctx
;
9664 gimplify_adjust_omp_clauses (gimple_seq
*pre_p
, gimple_seq body
, tree
*list_p
,
9665 enum tree_code code
)
9667 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
9672 struct gimplify_omp_ctx
*octx
;
9673 for (octx
= ctx
; octx
; octx
= octx
->outer_context
)
9674 if ((octx
->region_type
& (ORT_PARALLEL
| ORT_TASK
| ORT_TEAMS
)) != 0)
9678 struct walk_stmt_info wi
;
9679 memset (&wi
, 0, sizeof (wi
));
9680 walk_gimple_seq (body
, omp_find_stores_stmt
,
9681 omp_find_stores_op
, &wi
);
9684 while ((c
= *list_p
) != NULL
)
9687 bool remove
= false;
9689 switch (OMP_CLAUSE_CODE (c
))
9691 case OMP_CLAUSE_FIRSTPRIVATE
:
9692 if ((ctx
->region_type
& ORT_TARGET
)
9693 && (ctx
->region_type
& ORT_ACC
) == 0
9694 && TYPE_ATOMIC (strip_array_types
9695 (TREE_TYPE (OMP_CLAUSE_DECL (c
)))))
9697 error_at (OMP_CLAUSE_LOCATION (c
),
9698 "%<_Atomic%> %qD in %<firstprivate%> clause on "
9699 "%<target%> construct", OMP_CLAUSE_DECL (c
));
9704 case OMP_CLAUSE_PRIVATE
:
9705 case OMP_CLAUSE_SHARED
:
9706 case OMP_CLAUSE_LINEAR
:
9707 decl
= OMP_CLAUSE_DECL (c
);
9708 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9709 remove
= !(n
->value
& GOVD_SEEN
);
9712 bool shared
= OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
;
9713 if ((n
->value
& GOVD_DEBUG_PRIVATE
)
9714 || lang_hooks
.decls
.omp_private_debug_clause (decl
, shared
))
9716 gcc_assert ((n
->value
& GOVD_DEBUG_PRIVATE
) == 0
9717 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
9719 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_PRIVATE
);
9720 OMP_CLAUSE_PRIVATE_DEBUG (c
) = 1;
9722 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
9723 && (n
->value
& GOVD_WRITTEN
) == 0
9725 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
9726 OMP_CLAUSE_SHARED_READONLY (c
) = 1;
9727 else if (DECL_P (decl
)
9728 && ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
9729 && (n
->value
& GOVD_WRITTEN
) != 0)
9730 || (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
9731 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)))
9732 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
9733 omp_mark_stores (gimplify_omp_ctxp
->outer_context
, decl
);
9737 case OMP_CLAUSE_LASTPRIVATE
:
9738 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
9739 accurately reflect the presence of a FIRSTPRIVATE clause. */
9740 decl
= OMP_CLAUSE_DECL (c
);
9741 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9742 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
9743 = (n
->value
& GOVD_FIRSTPRIVATE
) != 0;
9744 if (code
== OMP_DISTRIBUTE
9745 && OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
9748 error_at (OMP_CLAUSE_LOCATION (c
),
9749 "same variable used in %<firstprivate%> and "
9750 "%<lastprivate%> clauses on %<distribute%> "
9754 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
9756 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
9757 omp_mark_stores (gimplify_omp_ctxp
->outer_context
, decl
);
9760 case OMP_CLAUSE_ALIGNED
:
9761 decl
= OMP_CLAUSE_DECL (c
);
9762 if (!is_global_var (decl
))
9764 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9765 remove
= n
== NULL
|| !(n
->value
& GOVD_SEEN
);
9766 if (!remove
&& TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
9768 struct gimplify_omp_ctx
*octx
;
9770 && (n
->value
& (GOVD_DATA_SHARE_CLASS
9771 & ~GOVD_FIRSTPRIVATE
)))
9774 for (octx
= ctx
->outer_context
; octx
;
9775 octx
= octx
->outer_context
)
9777 n
= splay_tree_lookup (octx
->variables
,
9778 (splay_tree_key
) decl
);
9781 if (n
->value
& GOVD_LOCAL
)
9783 /* We have to avoid assigning a shared variable
9784 to itself when trying to add
9785 __builtin_assume_aligned. */
9786 if (n
->value
& GOVD_SHARED
)
9794 else if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
9796 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9797 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
9802 case OMP_CLAUSE_NONTEMPORAL
:
9803 decl
= OMP_CLAUSE_DECL (c
);
9804 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9805 remove
= n
== NULL
|| !(n
->value
& GOVD_SEEN
);
9808 case OMP_CLAUSE_MAP
:
9809 if (code
== OMP_TARGET_EXIT_DATA
9810 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_POINTER
)
9815 decl
= OMP_CLAUSE_DECL (c
);
9816 /* Data clauses associated with acc parallel reductions must be
9817 compatible with present_or_copy. Warn and adjust the clause
9818 if that is not the case. */
9819 if (ctx
->region_type
== ORT_ACC_PARALLEL
)
9821 tree t
= DECL_P (decl
) ? decl
: TREE_OPERAND (decl
, 0);
9825 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
9827 if (n
&& (n
->value
& GOVD_REDUCTION
))
9829 enum gomp_map_kind kind
= OMP_CLAUSE_MAP_KIND (c
);
9831 OMP_CLAUSE_MAP_IN_REDUCTION (c
) = 1;
9832 if ((kind
& GOMP_MAP_TOFROM
) != GOMP_MAP_TOFROM
9833 && kind
!= GOMP_MAP_FORCE_PRESENT
9834 && kind
!= GOMP_MAP_POINTER
)
9836 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
9837 "incompatible data clause with reduction "
9838 "on %qE; promoting to present_or_copy",
9840 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_TOFROM
);
9846 if ((ctx
->region_type
& ORT_TARGET
) != 0
9847 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
)
9849 if (TREE_CODE (decl
) == INDIRECT_REF
9850 && TREE_CODE (TREE_OPERAND (decl
, 0)) == COMPONENT_REF
9851 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl
, 0)))
9853 decl
= TREE_OPERAND (decl
, 0);
9854 if (TREE_CODE (decl
) == COMPONENT_REF
)
9856 while (TREE_CODE (decl
) == COMPONENT_REF
)
9857 decl
= TREE_OPERAND (decl
, 0);
9860 n
= splay_tree_lookup (ctx
->variables
,
9861 (splay_tree_key
) decl
);
9862 if (!(n
->value
& GOVD_SEEN
))
9869 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9870 if ((ctx
->region_type
& ORT_TARGET
) != 0
9871 && !(n
->value
& GOVD_SEEN
)
9872 && GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c
)) == 0
9873 && (!is_global_var (decl
)
9874 || !lookup_attribute ("omp declare target link",
9875 DECL_ATTRIBUTES (decl
))))
9878 /* For struct element mapping, if struct is never referenced
9879 in target block and none of the mapping has always modifier,
9880 remove all the struct element mappings, which immediately
9881 follow the GOMP_MAP_STRUCT map clause. */
9882 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_STRUCT
)
9884 HOST_WIDE_INT cnt
= tree_to_shwi (OMP_CLAUSE_SIZE (c
));
9886 OMP_CLAUSE_CHAIN (c
)
9887 = OMP_CLAUSE_CHAIN (OMP_CLAUSE_CHAIN (c
));
9890 else if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_STRUCT
9891 && code
== OMP_TARGET_EXIT_DATA
)
9893 else if (DECL_SIZE (decl
)
9894 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
9895 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_POINTER
9896 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_FIRSTPRIVATE_POINTER
9897 && (OMP_CLAUSE_MAP_KIND (c
)
9898 != GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
9900 /* For GOMP_MAP_FORCE_DEVICEPTR, we'll never enter here, because
9901 for these, TREE_CODE (DECL_SIZE (decl)) will always be
9903 gcc_assert (OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_FORCE_DEVICEPTR
);
9905 tree decl2
= DECL_VALUE_EXPR (decl
);
9906 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
9907 decl2
= TREE_OPERAND (decl2
, 0);
9908 gcc_assert (DECL_P (decl2
));
9909 tree mem
= build_simple_mem_ref (decl2
);
9910 OMP_CLAUSE_DECL (c
) = mem
;
9911 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
9912 if (ctx
->outer_context
)
9914 omp_notice_variable (ctx
->outer_context
, decl2
, true);
9915 omp_notice_variable (ctx
->outer_context
,
9916 OMP_CLAUSE_SIZE (c
), true);
9918 if (((ctx
->region_type
& ORT_TARGET
) != 0
9919 || !ctx
->target_firstprivatize_array_bases
)
9920 && ((n
->value
& GOVD_SEEN
) == 0
9921 || (n
->value
& (GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
)) == 0))
9923 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
9925 OMP_CLAUSE_DECL (nc
) = decl
;
9926 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
9927 if (ctx
->target_firstprivatize_array_bases
)
9928 OMP_CLAUSE_SET_MAP_KIND (nc
,
9929 GOMP_MAP_FIRSTPRIVATE_POINTER
);
9931 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_POINTER
);
9932 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (c
);
9933 OMP_CLAUSE_CHAIN (c
) = nc
;
9939 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
9940 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
9941 gcc_assert ((n
->value
& GOVD_SEEN
) == 0
9942 || ((n
->value
& (GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
))
9948 case OMP_CLAUSE_FROM
:
9949 case OMP_CLAUSE__CACHE_
:
9950 decl
= OMP_CLAUSE_DECL (c
);
9953 if (DECL_SIZE (decl
)
9954 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
9956 tree decl2
= DECL_VALUE_EXPR (decl
);
9957 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
9958 decl2
= TREE_OPERAND (decl2
, 0);
9959 gcc_assert (DECL_P (decl2
));
9960 tree mem
= build_simple_mem_ref (decl2
);
9961 OMP_CLAUSE_DECL (c
) = mem
;
9962 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
9963 if (ctx
->outer_context
)
9965 omp_notice_variable (ctx
->outer_context
, decl2
, true);
9966 omp_notice_variable (ctx
->outer_context
,
9967 OMP_CLAUSE_SIZE (c
), true);
9970 else if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
9971 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
9974 case OMP_CLAUSE_REDUCTION
:
9975 case OMP_CLAUSE_IN_REDUCTION
:
9976 case OMP_CLAUSE_TASK_REDUCTION
:
9977 decl
= OMP_CLAUSE_DECL (c
);
9978 /* OpenACC reductions need a present_or_copy data clause.
9979 Add one if necessary. Emit error when the reduction is private. */
9980 if (ctx
->region_type
== ORT_ACC_PARALLEL
)
9982 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9983 if (n
->value
& (GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
))
9986 error_at (OMP_CLAUSE_LOCATION (c
), "invalid private "
9987 "reduction on %qE", DECL_NAME (decl
));
9989 else if ((n
->value
& GOVD_MAP
) == 0)
9991 tree next
= OMP_CLAUSE_CHAIN (c
);
9992 tree nc
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE_MAP
);
9993 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_TOFROM
);
9994 OMP_CLAUSE_DECL (nc
) = decl
;
9995 OMP_CLAUSE_CHAIN (c
) = nc
;
9996 lang_hooks
.decls
.omp_finish_clause (nc
, pre_p
);
9999 OMP_CLAUSE_MAP_IN_REDUCTION (nc
) = 1;
10000 if (OMP_CLAUSE_CHAIN (nc
) == NULL
)
10002 nc
= OMP_CLAUSE_CHAIN (nc
);
10004 OMP_CLAUSE_CHAIN (nc
) = next
;
10005 n
->value
|= GOVD_MAP
;
10009 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
10010 omp_mark_stores (gimplify_omp_ctxp
->outer_context
, decl
);
10012 case OMP_CLAUSE_COPYIN
:
10013 case OMP_CLAUSE_COPYPRIVATE
:
10014 case OMP_CLAUSE_IF
:
10015 case OMP_CLAUSE_NUM_THREADS
:
10016 case OMP_CLAUSE_NUM_TEAMS
:
10017 case OMP_CLAUSE_THREAD_LIMIT
:
10018 case OMP_CLAUSE_DIST_SCHEDULE
:
10019 case OMP_CLAUSE_DEVICE
:
10020 case OMP_CLAUSE_SCHEDULE
:
10021 case OMP_CLAUSE_NOWAIT
:
10022 case OMP_CLAUSE_ORDERED
:
10023 case OMP_CLAUSE_DEFAULT
:
10024 case OMP_CLAUSE_UNTIED
:
10025 case OMP_CLAUSE_COLLAPSE
:
10026 case OMP_CLAUSE_FINAL
:
10027 case OMP_CLAUSE_MERGEABLE
:
10028 case OMP_CLAUSE_PROC_BIND
:
10029 case OMP_CLAUSE_SAFELEN
:
10030 case OMP_CLAUSE_SIMDLEN
:
10031 case OMP_CLAUSE_DEPEND
:
10032 case OMP_CLAUSE_PRIORITY
:
10033 case OMP_CLAUSE_GRAINSIZE
:
10034 case OMP_CLAUSE_NUM_TASKS
:
10035 case OMP_CLAUSE_NOGROUP
:
10036 case OMP_CLAUSE_THREADS
:
10037 case OMP_CLAUSE_SIMD
:
10038 case OMP_CLAUSE_HINT
:
10039 case OMP_CLAUSE_DEFAULTMAP
:
10040 case OMP_CLAUSE_USE_DEVICE_PTR
:
10041 case OMP_CLAUSE_IS_DEVICE_PTR
:
10042 case OMP_CLAUSE_ASYNC
:
10043 case OMP_CLAUSE_WAIT
:
10044 case OMP_CLAUSE_INDEPENDENT
:
10045 case OMP_CLAUSE_NUM_GANGS
:
10046 case OMP_CLAUSE_NUM_WORKERS
:
10047 case OMP_CLAUSE_VECTOR_LENGTH
:
10048 case OMP_CLAUSE_GANG
:
10049 case OMP_CLAUSE_WORKER
:
10050 case OMP_CLAUSE_VECTOR
:
10051 case OMP_CLAUSE_AUTO
:
10052 case OMP_CLAUSE_SEQ
:
10053 case OMP_CLAUSE_TILE
:
10054 case OMP_CLAUSE_IF_PRESENT
:
10055 case OMP_CLAUSE_FINALIZE
:
10059 gcc_unreachable ();
10063 *list_p
= OMP_CLAUSE_CHAIN (c
);
10065 list_p
= &OMP_CLAUSE_CHAIN (c
);
10068 /* Add in any implicit data sharing. */
10069 struct gimplify_adjust_omp_clauses_data data
;
10070 data
.list_p
= list_p
;
10071 data
.pre_p
= pre_p
;
10072 splay_tree_foreach (ctx
->variables
, gimplify_adjust_omp_clauses_1
, &data
);
10074 gimplify_omp_ctxp
= ctx
->outer_context
;
10075 delete_omp_context (ctx
);
10078 /* Gimplify OACC_CACHE. */
10081 gimplify_oacc_cache (tree
*expr_p
, gimple_seq
*pre_p
)
10083 tree expr
= *expr_p
;
10085 gimplify_scan_omp_clauses (&OACC_CACHE_CLAUSES (expr
), pre_p
, ORT_ACC
,
10087 gimplify_adjust_omp_clauses (pre_p
, NULL
, &OACC_CACHE_CLAUSES (expr
),
10090 /* TODO: Do something sensible with this information. */
10092 *expr_p
= NULL_TREE
;
10095 /* Helper function of gimplify_oacc_declare. The helper's purpose is to,
10096 if required, translate 'kind' in CLAUSE into an 'entry' kind and 'exit'
10097 kind. The entry kind will replace the one in CLAUSE, while the exit
10098 kind will be used in a new omp_clause and returned to the caller. */
10101 gimplify_oacc_declare_1 (tree clause
)
10103 HOST_WIDE_INT kind
, new_op
;
10107 kind
= OMP_CLAUSE_MAP_KIND (clause
);
10111 case GOMP_MAP_ALLOC
:
10112 new_op
= GOMP_MAP_RELEASE
;
10116 case GOMP_MAP_FROM
:
10117 OMP_CLAUSE_SET_MAP_KIND (clause
, GOMP_MAP_FORCE_ALLOC
);
10118 new_op
= GOMP_MAP_FROM
;
10122 case GOMP_MAP_TOFROM
:
10123 OMP_CLAUSE_SET_MAP_KIND (clause
, GOMP_MAP_TO
);
10124 new_op
= GOMP_MAP_FROM
;
10128 case GOMP_MAP_DEVICE_RESIDENT
:
10129 case GOMP_MAP_FORCE_DEVICEPTR
:
10130 case GOMP_MAP_FORCE_PRESENT
:
10131 case GOMP_MAP_LINK
:
10132 case GOMP_MAP_POINTER
:
10137 gcc_unreachable ();
10143 c
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
), OMP_CLAUSE_MAP
);
10144 OMP_CLAUSE_SET_MAP_KIND (c
, new_op
);
10145 OMP_CLAUSE_DECL (c
) = OMP_CLAUSE_DECL (clause
);
10151 /* Gimplify OACC_DECLARE. */
10154 gimplify_oacc_declare (tree
*expr_p
, gimple_seq
*pre_p
)
10156 tree expr
= *expr_p
;
10158 tree clauses
, t
, decl
;
10160 clauses
= OACC_DECLARE_CLAUSES (expr
);
10162 gimplify_scan_omp_clauses (&clauses
, pre_p
, ORT_TARGET_DATA
, OACC_DECLARE
);
10163 gimplify_adjust_omp_clauses (pre_p
, NULL
, &clauses
, OACC_DECLARE
);
10165 for (t
= clauses
; t
; t
= OMP_CLAUSE_CHAIN (t
))
10167 decl
= OMP_CLAUSE_DECL (t
);
10169 if (TREE_CODE (decl
) == MEM_REF
)
10170 decl
= TREE_OPERAND (decl
, 0);
10172 if (VAR_P (decl
) && !is_oacc_declared (decl
))
10174 tree attr
= get_identifier ("oacc declare target");
10175 DECL_ATTRIBUTES (decl
) = tree_cons (attr
, NULL_TREE
,
10176 DECL_ATTRIBUTES (decl
));
10180 && !is_global_var (decl
)
10181 && DECL_CONTEXT (decl
) == current_function_decl
)
10183 tree c
= gimplify_oacc_declare_1 (t
);
10186 if (oacc_declare_returns
== NULL
)
10187 oacc_declare_returns
= new hash_map
<tree
, tree
>;
10189 oacc_declare_returns
->put (decl
, c
);
10193 if (gimplify_omp_ctxp
)
10194 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_SEEN
);
10197 stmt
= gimple_build_omp_target (NULL
, GF_OMP_TARGET_KIND_OACC_DECLARE
,
10200 gimplify_seq_add_stmt (pre_p
, stmt
);
10202 *expr_p
= NULL_TREE
;
10205 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
10206 gimplification of the body, as well as scanning the body for used
10207 variables. We need to do this scan now, because variable-sized
10208 decls will be decomposed during gimplification. */
10211 gimplify_omp_parallel (tree
*expr_p
, gimple_seq
*pre_p
)
10213 tree expr
= *expr_p
;
10215 gimple_seq body
= NULL
;
10217 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
), pre_p
,
10218 OMP_PARALLEL_COMBINED (expr
)
10219 ? ORT_COMBINED_PARALLEL
10220 : ORT_PARALLEL
, OMP_PARALLEL
);
10222 push_gimplify_context ();
10224 g
= gimplify_and_return_first (OMP_PARALLEL_BODY (expr
), &body
);
10225 if (gimple_code (g
) == GIMPLE_BIND
)
10226 pop_gimplify_context (g
);
10228 pop_gimplify_context (NULL
);
10230 gimplify_adjust_omp_clauses (pre_p
, body
, &OMP_PARALLEL_CLAUSES (expr
),
10233 g
= gimple_build_omp_parallel (body
,
10234 OMP_PARALLEL_CLAUSES (expr
),
10235 NULL_TREE
, NULL_TREE
);
10236 if (OMP_PARALLEL_COMBINED (expr
))
10237 gimple_omp_set_subcode (g
, GF_OMP_PARALLEL_COMBINED
);
10238 gimplify_seq_add_stmt (pre_p
, g
);
10239 *expr_p
= NULL_TREE
;
10242 /* Gimplify the contents of an OMP_TASK statement. This involves
10243 gimplification of the body, as well as scanning the body for used
10244 variables. We need to do this scan now, because variable-sized
10245 decls will be decomposed during gimplification. */
10248 gimplify_omp_task (tree
*expr_p
, gimple_seq
*pre_p
)
10250 tree expr
= *expr_p
;
10252 gimple_seq body
= NULL
;
10254 if (OMP_TASK_BODY (expr
) == NULL_TREE
)
10255 for (tree c
= OMP_TASK_CLAUSES (expr
); c
; c
= OMP_CLAUSE_CHAIN (c
))
10256 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
10257 && OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_MUTEXINOUTSET
)
10259 error_at (OMP_CLAUSE_LOCATION (c
),
10260 "%<mutexinoutset%> kind in %<depend%> clause on a "
10261 "%<taskwait%> construct");
10265 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr
), pre_p
,
10266 omp_find_clause (OMP_TASK_CLAUSES (expr
),
10268 ? ORT_UNTIED_TASK
: ORT_TASK
, OMP_TASK
);
10270 if (OMP_TASK_BODY (expr
))
10272 push_gimplify_context ();
10274 g
= gimplify_and_return_first (OMP_TASK_BODY (expr
), &body
);
10275 if (gimple_code (g
) == GIMPLE_BIND
)
10276 pop_gimplify_context (g
);
10278 pop_gimplify_context (NULL
);
10281 gimplify_adjust_omp_clauses (pre_p
, body
, &OMP_TASK_CLAUSES (expr
),
10284 g
= gimple_build_omp_task (body
,
10285 OMP_TASK_CLAUSES (expr
),
10286 NULL_TREE
, NULL_TREE
,
10287 NULL_TREE
, NULL_TREE
, NULL_TREE
);
10288 if (OMP_TASK_BODY (expr
) == NULL_TREE
)
10289 gimple_omp_task_set_taskwait_p (g
, true);
10290 gimplify_seq_add_stmt (pre_p
, g
);
10291 *expr_p
= NULL_TREE
;
10294 /* Helper function of gimplify_omp_for, find OMP_FOR resp. OMP_SIMD
10295 with non-NULL OMP_FOR_INIT. Also, fill in pdata array,
10296 pdata[0] non-NULL if there is anything non-trivial in between, pdata[1]
10297 is address of OMP_PARALLEL in between if any, pdata[2] is address of
10298 OMP_FOR in between if any and pdata[3] is address of the inner
10299 OMP_FOR/OMP_SIMD. */
10302 find_combined_omp_for (tree
*tp
, int *walk_subtrees
, void *data
)
10304 tree
**pdata
= (tree
**) data
;
10305 *walk_subtrees
= 0;
10306 switch (TREE_CODE (*tp
))
10309 if (OMP_FOR_INIT (*tp
) != NULL_TREE
)
10315 *walk_subtrees
= 1;
10318 if (OMP_FOR_INIT (*tp
) != NULL_TREE
)
10325 if (BIND_EXPR_VARS (*tp
)
10326 || (BIND_EXPR_BLOCK (*tp
)
10327 && BLOCK_VARS (BIND_EXPR_BLOCK (*tp
))))
10329 *walk_subtrees
= 1;
10331 case STATEMENT_LIST
:
10332 if (!tsi_one_before_end_p (tsi_start (*tp
)))
10334 *walk_subtrees
= 1;
10336 case TRY_FINALLY_EXPR
:
10338 *walk_subtrees
= 1;
10342 *walk_subtrees
= 1;
10350 /* Gimplify the gross structure of an OMP_FOR statement. */
10352 static enum gimplify_status
10353 gimplify_omp_for (tree
*expr_p
, gimple_seq
*pre_p
)
10355 tree for_stmt
, orig_for_stmt
, inner_for_stmt
= NULL_TREE
, decl
, var
, t
;
10356 enum gimplify_status ret
= GS_ALL_DONE
;
10357 enum gimplify_status tret
;
10359 gimple_seq for_body
, for_pre_body
;
10361 bitmap has_decl_expr
= NULL
;
10362 enum omp_region_type ort
= ORT_WORKSHARE
;
10364 orig_for_stmt
= for_stmt
= *expr_p
;
10366 if (OMP_FOR_INIT (for_stmt
) == NULL_TREE
)
10368 tree
*data
[4] = { NULL
, NULL
, NULL
, NULL
};
10369 gcc_assert (TREE_CODE (for_stmt
) != OACC_LOOP
);
10370 inner_for_stmt
= walk_tree (&OMP_FOR_BODY (for_stmt
),
10371 find_combined_omp_for
, data
, NULL
);
10372 if (inner_for_stmt
== NULL_TREE
)
10374 gcc_assert (seen_error ());
10375 *expr_p
= NULL_TREE
;
10378 if (data
[2] && OMP_FOR_PRE_BODY (*data
[2]))
10380 append_to_statement_list_force (OMP_FOR_PRE_BODY (*data
[2]),
10381 &OMP_FOR_PRE_BODY (for_stmt
));
10382 OMP_FOR_PRE_BODY (*data
[2]) = NULL_TREE
;
10384 if (OMP_FOR_PRE_BODY (inner_for_stmt
))
10386 append_to_statement_list_force (OMP_FOR_PRE_BODY (inner_for_stmt
),
10387 &OMP_FOR_PRE_BODY (for_stmt
));
10388 OMP_FOR_PRE_BODY (inner_for_stmt
) = NULL_TREE
;
10393 /* We have some statements or variable declarations in between
10394 the composite construct directives. Move them around the
10397 for (i
= 0; i
< 3; i
++)
10401 if (i
< 2 && data
[i
+ 1] == &OMP_BODY (t
))
10402 data
[i
+ 1] = data
[i
];
10403 *data
[i
] = OMP_BODY (t
);
10404 tree body
= build3 (BIND_EXPR
, void_type_node
, NULL_TREE
,
10405 NULL_TREE
, make_node (BLOCK
));
10406 OMP_BODY (t
) = body
;
10407 append_to_statement_list_force (inner_for_stmt
,
10408 &BIND_EXPR_BODY (body
));
10410 data
[3] = tsi_stmt_ptr (tsi_start (BIND_EXPR_BODY (body
)));
10411 gcc_assert (*data
[3] == inner_for_stmt
);
10416 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (inner_for_stmt
)); i
++)
10417 if (OMP_FOR_ORIG_DECLS (inner_for_stmt
)
10418 && TREE_CODE (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt
),
10420 && TREE_PURPOSE (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt
),
10423 tree orig
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt
), i
);
10424 /* Class iterators aren't allowed on OMP_SIMD, so the only
10425 case we need to solve is distribute parallel for. */
10426 gcc_assert (TREE_CODE (inner_for_stmt
) == OMP_FOR
10427 && TREE_CODE (for_stmt
) == OMP_DISTRIBUTE
10429 tree orig_decl
= TREE_PURPOSE (orig
);
10430 tree last
= TREE_VALUE (orig
);
10432 for (pc
= &OMP_FOR_CLAUSES (inner_for_stmt
);
10433 *pc
; pc
= &OMP_CLAUSE_CHAIN (*pc
))
10434 if ((OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
10435 || OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LASTPRIVATE
)
10436 && OMP_CLAUSE_DECL (*pc
) == orig_decl
)
10438 if (*pc
== NULL_TREE
)
10440 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
)
10442 /* private clause will appear only on inner_for_stmt.
10443 Change it into firstprivate, and add private clause
10445 tree c
= copy_node (*pc
);
10446 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
10447 OMP_FOR_CLAUSES (for_stmt
) = c
;
10448 OMP_CLAUSE_CODE (*pc
) = OMP_CLAUSE_FIRSTPRIVATE
;
10449 lang_hooks
.decls
.omp_finish_clause (*pc
, pre_p
);
10453 /* lastprivate clause will appear on both inner_for_stmt
10454 and for_stmt. Add firstprivate clause to
10456 tree c
= build_omp_clause (OMP_CLAUSE_LOCATION (*pc
),
10457 OMP_CLAUSE_FIRSTPRIVATE
);
10458 OMP_CLAUSE_DECL (c
) = OMP_CLAUSE_DECL (*pc
);
10459 OMP_CLAUSE_CHAIN (c
) = *pc
;
10461 lang_hooks
.decls
.omp_finish_clause (*pc
, pre_p
);
10463 tree c
= build_omp_clause (UNKNOWN_LOCATION
,
10464 OMP_CLAUSE_FIRSTPRIVATE
);
10465 OMP_CLAUSE_DECL (c
) = last
;
10466 OMP_CLAUSE_CHAIN (c
) = OMP_PARALLEL_CLAUSES (*data
[1]);
10467 OMP_PARALLEL_CLAUSES (*data
[1]) = c
;
10468 c
= build_omp_clause (UNKNOWN_LOCATION
,
10469 *pc
? OMP_CLAUSE_SHARED
10470 : OMP_CLAUSE_FIRSTPRIVATE
);
10471 OMP_CLAUSE_DECL (c
) = orig_decl
;
10472 OMP_CLAUSE_CHAIN (c
) = OMP_PARALLEL_CLAUSES (*data
[1]);
10473 OMP_PARALLEL_CLAUSES (*data
[1]) = c
;
10475 /* Similarly, take care of C++ range for temporaries, those should
10476 be firstprivate on OMP_PARALLEL if any. */
10478 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (inner_for_stmt
)); i
++)
10479 if (OMP_FOR_ORIG_DECLS (inner_for_stmt
)
10480 && TREE_CODE (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt
),
10482 && TREE_CHAIN (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt
),
10486 = TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt
), i
);
10487 tree v
= TREE_CHAIN (orig
);
10488 tree c
= build_omp_clause (UNKNOWN_LOCATION
,
10489 OMP_CLAUSE_FIRSTPRIVATE
);
10490 /* First add firstprivate clause for the __for_end artificial
10492 OMP_CLAUSE_DECL (c
) = TREE_VEC_ELT (v
, 1);
10493 if (TREE_CODE (TREE_TYPE (OMP_CLAUSE_DECL (c
)))
10495 OMP_CLAUSE_FIRSTPRIVATE_NO_REFERENCE (c
) = 1;
10496 OMP_CLAUSE_CHAIN (c
) = OMP_PARALLEL_CLAUSES (*data
[1]);
10497 OMP_PARALLEL_CLAUSES (*data
[1]) = c
;
10498 if (TREE_VEC_ELT (v
, 0))
10500 /* And now the same for __for_range artificial decl if it
10502 c
= build_omp_clause (UNKNOWN_LOCATION
,
10503 OMP_CLAUSE_FIRSTPRIVATE
);
10504 OMP_CLAUSE_DECL (c
) = TREE_VEC_ELT (v
, 0);
10505 if (TREE_CODE (TREE_TYPE (OMP_CLAUSE_DECL (c
)))
10507 OMP_CLAUSE_FIRSTPRIVATE_NO_REFERENCE (c
) = 1;
10508 OMP_CLAUSE_CHAIN (c
) = OMP_PARALLEL_CLAUSES (*data
[1]);
10509 OMP_PARALLEL_CLAUSES (*data
[1]) = c
;
10514 switch (TREE_CODE (for_stmt
))
10517 case OMP_DISTRIBUTE
:
10523 if (omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_UNTIED
))
10524 ort
= ORT_UNTIED_TASKLOOP
;
10526 ort
= ORT_TASKLOOP
;
10532 gcc_unreachable ();
10535 /* Set OMP_CLAUSE_LINEAR_NO_COPYIN flag on explicit linear
10536 clause for the IV. */
10537 if (ort
== ORT_SIMD
&& TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
10539 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), 0);
10540 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
10541 decl
= TREE_OPERAND (t
, 0);
10542 for (tree c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
10543 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
10544 && OMP_CLAUSE_DECL (c
) == decl
)
10546 OMP_CLAUSE_LINEAR_NO_COPYIN (c
) = 1;
10551 if (TREE_CODE (for_stmt
) != OMP_TASKLOOP
)
10552 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
), pre_p
, ort
,
10553 TREE_CODE (for_stmt
));
10555 if (TREE_CODE (for_stmt
) == OMP_DISTRIBUTE
)
10556 gimplify_omp_ctxp
->distribute
= true;
10558 /* Handle OMP_FOR_INIT. */
10559 for_pre_body
= NULL
;
10560 if ((ort
== ORT_SIMD
10561 || (inner_for_stmt
&& TREE_CODE (inner_for_stmt
) == OMP_SIMD
))
10562 && OMP_FOR_PRE_BODY (for_stmt
))
10564 has_decl_expr
= BITMAP_ALLOC (NULL
);
10565 if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == DECL_EXPR
10566 && TREE_CODE (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt
)))
10569 t
= OMP_FOR_PRE_BODY (for_stmt
);
10570 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
10572 else if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == STATEMENT_LIST
)
10574 tree_stmt_iterator si
;
10575 for (si
= tsi_start (OMP_FOR_PRE_BODY (for_stmt
)); !tsi_end_p (si
);
10579 if (TREE_CODE (t
) == DECL_EXPR
10580 && TREE_CODE (DECL_EXPR_DECL (t
)) == VAR_DECL
)
10581 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
10585 if (OMP_FOR_PRE_BODY (for_stmt
))
10587 if (TREE_CODE (for_stmt
) != OMP_TASKLOOP
|| gimplify_omp_ctxp
)
10588 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
10591 struct gimplify_omp_ctx ctx
;
10592 memset (&ctx
, 0, sizeof (ctx
));
10593 ctx
.region_type
= ORT_NONE
;
10594 gimplify_omp_ctxp
= &ctx
;
10595 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
10596 gimplify_omp_ctxp
= NULL
;
10599 OMP_FOR_PRE_BODY (for_stmt
) = NULL_TREE
;
10601 if (OMP_FOR_INIT (for_stmt
) == NULL_TREE
)
10602 for_stmt
= inner_for_stmt
;
10604 /* For taskloop, need to gimplify the start, end and step before the
10605 taskloop, outside of the taskloop omp context. */
10606 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
10608 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
10610 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
10611 if (!is_gimple_constant (TREE_OPERAND (t
, 1)))
10613 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
10614 TREE_OPERAND (t
, 1)
10615 = get_initialized_tmp_var (TREE_OPERAND (t
, 1),
10616 gimple_seq_empty_p (for_pre_body
)
10617 ? pre_p
: &for_pre_body
, NULL
,
10619 /* Reference to pointer conversion is considered useless,
10620 but is significant for firstprivate clause. Force it
10622 if (TREE_CODE (type
) == POINTER_TYPE
10623 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 1)))
10624 == REFERENCE_TYPE
))
10626 tree v
= create_tmp_var (TYPE_MAIN_VARIANT (type
));
10627 tree m
= build2 (INIT_EXPR
, TREE_TYPE (v
), v
,
10628 TREE_OPERAND (t
, 1));
10629 gimplify_and_add (m
, gimple_seq_empty_p (for_pre_body
)
10630 ? pre_p
: &for_pre_body
);
10631 TREE_OPERAND (t
, 1) = v
;
10633 tree c
= build_omp_clause (input_location
,
10634 OMP_CLAUSE_FIRSTPRIVATE
);
10635 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (t
, 1);
10636 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (orig_for_stmt
);
10637 OMP_FOR_CLAUSES (orig_for_stmt
) = c
;
10640 /* Handle OMP_FOR_COND. */
10641 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
10642 if (!is_gimple_constant (TREE_OPERAND (t
, 1)))
10644 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
10645 TREE_OPERAND (t
, 1)
10646 = get_initialized_tmp_var (TREE_OPERAND (t
, 1),
10647 gimple_seq_empty_p (for_pre_body
)
10648 ? pre_p
: &for_pre_body
, NULL
,
10650 /* Reference to pointer conversion is considered useless,
10651 but is significant for firstprivate clause. Force it
10653 if (TREE_CODE (type
) == POINTER_TYPE
10654 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 1)))
10655 == REFERENCE_TYPE
))
10657 tree v
= create_tmp_var (TYPE_MAIN_VARIANT (type
));
10658 tree m
= build2 (INIT_EXPR
, TREE_TYPE (v
), v
,
10659 TREE_OPERAND (t
, 1));
10660 gimplify_and_add (m
, gimple_seq_empty_p (for_pre_body
)
10661 ? pre_p
: &for_pre_body
);
10662 TREE_OPERAND (t
, 1) = v
;
10664 tree c
= build_omp_clause (input_location
,
10665 OMP_CLAUSE_FIRSTPRIVATE
);
10666 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (t
, 1);
10667 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (orig_for_stmt
);
10668 OMP_FOR_CLAUSES (orig_for_stmt
) = c
;
10671 /* Handle OMP_FOR_INCR. */
10672 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
10673 if (TREE_CODE (t
) == MODIFY_EXPR
)
10675 decl
= TREE_OPERAND (t
, 0);
10676 t
= TREE_OPERAND (t
, 1);
10677 tree
*tp
= &TREE_OPERAND (t
, 1);
10678 if (TREE_CODE (t
) == PLUS_EXPR
&& *tp
== decl
)
10679 tp
= &TREE_OPERAND (t
, 0);
10681 if (!is_gimple_constant (*tp
))
10683 gimple_seq
*seq
= gimple_seq_empty_p (for_pre_body
)
10684 ? pre_p
: &for_pre_body
;
10685 *tp
= get_initialized_tmp_var (*tp
, seq
, NULL
, false);
10686 tree c
= build_omp_clause (input_location
,
10687 OMP_CLAUSE_FIRSTPRIVATE
);
10688 OMP_CLAUSE_DECL (c
) = *tp
;
10689 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (orig_for_stmt
);
10690 OMP_FOR_CLAUSES (orig_for_stmt
) = c
;
10695 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (orig_for_stmt
), pre_p
, ort
,
10699 if (orig_for_stmt
!= for_stmt
)
10700 gimplify_omp_ctxp
->combined_loop
= true;
10703 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
10704 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt
)));
10705 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
10706 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt
)));
10708 tree c
= omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_ORDERED
);
10709 bool is_doacross
= false;
10710 if (c
&& OMP_CLAUSE_ORDERED_EXPR (c
))
10712 is_doacross
= true;
10713 gimplify_omp_ctxp
->loop_iter_var
.create (TREE_VEC_LENGTH
10714 (OMP_FOR_INIT (for_stmt
))
10717 int collapse
= 1, tile
= 0;
10718 c
= omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_COLLAPSE
);
10720 collapse
= tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (c
));
10721 c
= omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_TILE
);
10723 tile
= list_length (OMP_CLAUSE_TILE_LIST (c
));
10724 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
10726 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
10727 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
10728 decl
= TREE_OPERAND (t
, 0);
10729 gcc_assert (DECL_P (decl
));
10730 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl
))
10731 || POINTER_TYPE_P (TREE_TYPE (decl
)));
10734 if (TREE_CODE (for_stmt
) == OMP_FOR
&& OMP_FOR_ORIG_DECLS (for_stmt
))
10736 tree orig_decl
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt
), i
);
10737 if (TREE_CODE (orig_decl
) == TREE_LIST
)
10739 orig_decl
= TREE_PURPOSE (orig_decl
);
10743 gimplify_omp_ctxp
->loop_iter_var
.quick_push (orig_decl
);
10746 gimplify_omp_ctxp
->loop_iter_var
.quick_push (decl
);
10747 gimplify_omp_ctxp
->loop_iter_var
.quick_push (decl
);
10750 /* Make sure the iteration variable is private. */
10751 tree c
= NULL_TREE
;
10752 tree c2
= NULL_TREE
;
10753 if (orig_for_stmt
!= for_stmt
)
10755 /* Preserve this information until we gimplify the inner simd. */
10757 && bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)))
10758 TREE_PRIVATE (t
) = 1;
10760 else if (ort
== ORT_SIMD
)
10762 splay_tree_node n
= splay_tree_lookup (gimplify_omp_ctxp
->variables
,
10763 (splay_tree_key
) decl
);
10764 omp_is_private (gimplify_omp_ctxp
, decl
,
10765 1 + (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
10767 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
10768 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
10769 else if (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
10771 c
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
10772 OMP_CLAUSE_LINEAR_NO_COPYIN (c
) = 1;
10773 unsigned int flags
= GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
;
10775 && bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)))
10776 || TREE_PRIVATE (t
))
10778 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
10779 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
10781 struct gimplify_omp_ctx
*outer
10782 = gimplify_omp_ctxp
->outer_context
;
10783 if (outer
&& !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
10785 if (outer
->region_type
== ORT_WORKSHARE
10786 && outer
->combined_loop
)
10788 n
= splay_tree_lookup (outer
->variables
,
10789 (splay_tree_key
)decl
);
10790 if (n
!= NULL
&& (n
->value
& GOVD_LOCAL
) != 0)
10792 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
10793 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
10797 struct gimplify_omp_ctx
*octx
= outer
->outer_context
;
10799 && octx
->region_type
== ORT_COMBINED_PARALLEL
10800 && octx
->outer_context
10801 && (octx
->outer_context
->region_type
10803 && octx
->outer_context
->combined_loop
)
10805 octx
= octx
->outer_context
;
10806 n
= splay_tree_lookup (octx
->variables
,
10807 (splay_tree_key
)decl
);
10808 if (n
!= NULL
&& (n
->value
& GOVD_LOCAL
) != 0)
10810 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
10811 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
10818 OMP_CLAUSE_DECL (c
) = decl
;
10819 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
10820 OMP_FOR_CLAUSES (for_stmt
) = c
;
10821 omp_add_variable (gimplify_omp_ctxp
, decl
, flags
);
10822 if (outer
&& !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
10824 if (outer
->region_type
== ORT_WORKSHARE
10825 && outer
->combined_loop
)
10827 if (outer
->outer_context
10828 && (outer
->outer_context
->region_type
10829 == ORT_COMBINED_PARALLEL
))
10830 outer
= outer
->outer_context
;
10831 else if (omp_check_private (outer
, decl
, false))
10834 else if (((outer
->region_type
& ORT_TASKLOOP
)
10836 && outer
->combined_loop
10837 && !omp_check_private (gimplify_omp_ctxp
,
10840 else if (outer
->region_type
!= ORT_COMBINED_PARALLEL
)
10842 omp_notice_variable (outer
, decl
, true);
10847 n
= splay_tree_lookup (outer
->variables
,
10848 (splay_tree_key
)decl
);
10849 if (n
== NULL
|| (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
10851 omp_add_variable (outer
, decl
,
10852 GOVD_LASTPRIVATE
| GOVD_SEEN
);
10853 if (outer
->region_type
== ORT_COMBINED_PARALLEL
10854 && outer
->outer_context
10855 && (outer
->outer_context
->region_type
10857 && outer
->outer_context
->combined_loop
)
10859 outer
= outer
->outer_context
;
10860 n
= splay_tree_lookup (outer
->variables
,
10861 (splay_tree_key
)decl
);
10862 if (omp_check_private (outer
, decl
, false))
10865 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
10867 omp_add_variable (outer
, decl
,
10873 if (outer
&& outer
->outer_context
10874 && ((outer
->outer_context
->region_type
10875 & ORT_COMBINED_TEAMS
) == ORT_COMBINED_TEAMS
10876 || (((outer
->region_type
& ORT_TASKLOOP
)
10878 && (outer
->outer_context
->region_type
10879 == ORT_COMBINED_PARALLEL
))))
10881 outer
= outer
->outer_context
;
10882 n
= splay_tree_lookup (outer
->variables
,
10883 (splay_tree_key
)decl
);
10885 || (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
10886 omp_add_variable (outer
, decl
,
10887 GOVD_SHARED
| GOVD_SEEN
);
10891 if (outer
&& outer
->outer_context
)
10892 omp_notice_variable (outer
->outer_context
, decl
,
10902 || !bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)));
10903 if (TREE_PRIVATE (t
))
10904 lastprivate
= false;
10905 struct gimplify_omp_ctx
*outer
10906 = gimplify_omp_ctxp
->outer_context
;
10907 if (outer
&& lastprivate
)
10909 if (outer
->region_type
== ORT_WORKSHARE
10910 && outer
->combined_loop
)
10912 n
= splay_tree_lookup (outer
->variables
,
10913 (splay_tree_key
)decl
);
10914 if (n
!= NULL
&& (n
->value
& GOVD_LOCAL
) != 0)
10916 lastprivate
= false;
10919 else if (outer
->outer_context
10920 && (outer
->outer_context
->region_type
10921 == ORT_COMBINED_PARALLEL
))
10922 outer
= outer
->outer_context
;
10923 else if (omp_check_private (outer
, decl
, false))
10926 else if (((outer
->region_type
& ORT_TASKLOOP
)
10928 && outer
->combined_loop
10929 && !omp_check_private (gimplify_omp_ctxp
,
10932 else if (outer
->region_type
!= ORT_COMBINED_PARALLEL
)
10934 omp_notice_variable (outer
, decl
, true);
10939 n
= splay_tree_lookup (outer
->variables
,
10940 (splay_tree_key
)decl
);
10941 if (n
== NULL
|| (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
10943 omp_add_variable (outer
, decl
,
10944 GOVD_LASTPRIVATE
| GOVD_SEEN
);
10945 if (outer
->region_type
== ORT_COMBINED_PARALLEL
10946 && outer
->outer_context
10947 && (outer
->outer_context
->region_type
10949 && outer
->outer_context
->combined_loop
)
10951 outer
= outer
->outer_context
;
10952 n
= splay_tree_lookup (outer
->variables
,
10953 (splay_tree_key
)decl
);
10954 if (omp_check_private (outer
, decl
, false))
10957 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
10959 omp_add_variable (outer
, decl
,
10965 if (outer
&& outer
->outer_context
10966 && ((outer
->outer_context
->region_type
10967 & ORT_COMBINED_TEAMS
) == ORT_COMBINED_TEAMS
10968 || (((outer
->region_type
& ORT_TASKLOOP
)
10970 && (outer
->outer_context
->region_type
10971 == ORT_COMBINED_PARALLEL
))))
10973 outer
= outer
->outer_context
;
10974 n
= splay_tree_lookup (outer
->variables
,
10975 (splay_tree_key
)decl
);
10977 || (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
10978 omp_add_variable (outer
, decl
,
10979 GOVD_SHARED
| GOVD_SEEN
);
10983 if (outer
&& outer
->outer_context
)
10984 omp_notice_variable (outer
->outer_context
, decl
,
10990 c
= build_omp_clause (input_location
,
10991 lastprivate
? OMP_CLAUSE_LASTPRIVATE
10992 : OMP_CLAUSE_PRIVATE
);
10993 OMP_CLAUSE_DECL (c
) = decl
;
10994 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
10995 OMP_FOR_CLAUSES (for_stmt
) = c
;
10996 omp_add_variable (gimplify_omp_ctxp
, decl
,
10997 (lastprivate
? GOVD_LASTPRIVATE
: GOVD_PRIVATE
)
10998 | GOVD_EXPLICIT
| GOVD_SEEN
);
11002 else if (omp_is_private (gimplify_omp_ctxp
, decl
, 0))
11003 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
11005 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_PRIVATE
| GOVD_SEEN
);
11007 /* If DECL is not a gimple register, create a temporary variable to act
11008 as an iteration counter. This is valid, since DECL cannot be
11009 modified in the body of the loop. Similarly for any iteration vars
11010 in simd with collapse > 1 where the iterator vars must be
11012 if (orig_for_stmt
!= for_stmt
)
11014 else if (!is_gimple_reg (decl
)
11015 || (ort
== ORT_SIMD
11016 && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1))
11018 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
11019 /* Make sure omp_add_variable is not called on it prematurely.
11020 We call it ourselves a few lines later. */
11021 gimplify_omp_ctxp
= NULL
;
11022 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
11023 gimplify_omp_ctxp
= ctx
;
11024 TREE_OPERAND (t
, 0) = var
;
11026 gimplify_seq_add_stmt (&for_body
, gimple_build_assign (decl
, var
));
11028 if (ort
== ORT_SIMD
11029 && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
11031 c2
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
11032 OMP_CLAUSE_LINEAR_NO_COPYIN (c2
) = 1;
11033 OMP_CLAUSE_LINEAR_NO_COPYOUT (c2
) = 1;
11034 OMP_CLAUSE_DECL (c2
) = var
;
11035 OMP_CLAUSE_CHAIN (c2
) = OMP_FOR_CLAUSES (for_stmt
);
11036 OMP_FOR_CLAUSES (for_stmt
) = c2
;
11037 omp_add_variable (gimplify_omp_ctxp
, var
,
11038 GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
);
11039 if (c
== NULL_TREE
)
11046 omp_add_variable (gimplify_omp_ctxp
, var
,
11047 GOVD_PRIVATE
| GOVD_SEEN
);
11052 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
11053 is_gimple_val
, fb_rvalue
, false);
11054 ret
= MIN (ret
, tret
);
11055 if (ret
== GS_ERROR
)
11058 /* Handle OMP_FOR_COND. */
11059 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
11060 gcc_assert (COMPARISON_CLASS_P (t
));
11061 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
11063 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
11064 is_gimple_val
, fb_rvalue
, false);
11065 ret
= MIN (ret
, tret
);
11067 /* Handle OMP_FOR_INCR. */
11068 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
11069 switch (TREE_CODE (t
))
11071 case PREINCREMENT_EXPR
:
11072 case POSTINCREMENT_EXPR
:
11074 tree decl
= TREE_OPERAND (t
, 0);
11075 /* c_omp_for_incr_canonicalize_ptr() should have been
11076 called to massage things appropriately. */
11077 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl
)));
11079 if (orig_for_stmt
!= for_stmt
)
11081 t
= build_int_cst (TREE_TYPE (decl
), 1);
11083 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
11084 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
11085 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
11086 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
11090 case PREDECREMENT_EXPR
:
11091 case POSTDECREMENT_EXPR
:
11092 /* c_omp_for_incr_canonicalize_ptr() should have been
11093 called to massage things appropriately. */
11094 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl
)));
11095 if (orig_for_stmt
!= for_stmt
)
11097 t
= build_int_cst (TREE_TYPE (decl
), -1);
11099 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
11100 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
11101 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
11102 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
11106 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
11107 TREE_OPERAND (t
, 0) = var
;
11109 t
= TREE_OPERAND (t
, 1);
11110 switch (TREE_CODE (t
))
11113 if (TREE_OPERAND (t
, 1) == decl
)
11115 TREE_OPERAND (t
, 1) = TREE_OPERAND (t
, 0);
11116 TREE_OPERAND (t
, 0) = var
;
11122 case POINTER_PLUS_EXPR
:
11123 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
11124 TREE_OPERAND (t
, 0) = var
;
11127 gcc_unreachable ();
11130 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
11131 is_gimple_val
, fb_rvalue
, false);
11132 ret
= MIN (ret
, tret
);
11135 tree step
= TREE_OPERAND (t
, 1);
11136 tree stept
= TREE_TYPE (decl
);
11137 if (POINTER_TYPE_P (stept
))
11139 step
= fold_convert (stept
, step
);
11140 if (TREE_CODE (t
) == MINUS_EXPR
)
11141 step
= fold_build1 (NEGATE_EXPR
, stept
, step
);
11142 OMP_CLAUSE_LINEAR_STEP (c
) = step
;
11143 if (step
!= TREE_OPERAND (t
, 1))
11145 tret
= gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
),
11146 &for_pre_body
, NULL
,
11147 is_gimple_val
, fb_rvalue
, false);
11148 ret
= MIN (ret
, tret
);
11154 gcc_unreachable ();
11160 OMP_CLAUSE_LINEAR_STEP (c2
) = OMP_CLAUSE_LINEAR_STEP (c
);
11163 if ((var
!= decl
|| collapse
> 1 || tile
) && orig_for_stmt
== for_stmt
)
11165 for (c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
11166 if (((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
11167 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) == NULL
)
11168 || (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
11169 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)
11170 && OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
) == NULL
))
11171 && OMP_CLAUSE_DECL (c
) == decl
)
11173 if (is_doacross
&& (collapse
== 1 || i
>= collapse
))
11177 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
11178 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
11179 gcc_assert (TREE_OPERAND (t
, 0) == var
);
11180 t
= TREE_OPERAND (t
, 1);
11181 gcc_assert (TREE_CODE (t
) == PLUS_EXPR
11182 || TREE_CODE (t
) == MINUS_EXPR
11183 || TREE_CODE (t
) == POINTER_PLUS_EXPR
);
11184 gcc_assert (TREE_OPERAND (t
, 0) == var
);
11185 t
= build2 (TREE_CODE (t
), TREE_TYPE (decl
),
11186 is_doacross
? var
: decl
,
11187 TREE_OPERAND (t
, 1));
11190 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
11191 seq
= &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
);
11193 seq
= &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
);
11194 push_gimplify_context ();
11195 gimplify_assign (decl
, t
, seq
);
11196 gimple
*bind
= NULL
;
11197 if (gimplify_ctxp
->temps
)
11199 bind
= gimple_build_bind (NULL_TREE
, *seq
, NULL_TREE
);
11201 gimplify_seq_add_stmt (seq
, bind
);
11203 pop_gimplify_context (bind
);
11208 BITMAP_FREE (has_decl_expr
);
11210 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
11212 push_gimplify_context ();
11213 if (TREE_CODE (OMP_FOR_BODY (orig_for_stmt
)) != BIND_EXPR
)
11215 OMP_FOR_BODY (orig_for_stmt
)
11216 = build3 (BIND_EXPR
, void_type_node
, NULL
,
11217 OMP_FOR_BODY (orig_for_stmt
), NULL
);
11218 TREE_SIDE_EFFECTS (OMP_FOR_BODY (orig_for_stmt
)) = 1;
11222 gimple
*g
= gimplify_and_return_first (OMP_FOR_BODY (orig_for_stmt
),
11225 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
11227 if (gimple_code (g
) == GIMPLE_BIND
)
11228 pop_gimplify_context (g
);
11230 pop_gimplify_context (NULL
);
11233 if (orig_for_stmt
!= for_stmt
)
11234 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
11236 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
11237 decl
= TREE_OPERAND (t
, 0);
11238 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
11239 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
11240 gimplify_omp_ctxp
= ctx
->outer_context
;
11241 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
11242 gimplify_omp_ctxp
= ctx
;
11243 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
11244 TREE_OPERAND (t
, 0) = var
;
11245 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
11246 TREE_OPERAND (t
, 1) = copy_node (TREE_OPERAND (t
, 1));
11247 TREE_OPERAND (TREE_OPERAND (t
, 1), 0) = var
;
11250 gimplify_adjust_omp_clauses (pre_p
, for_body
,
11251 &OMP_FOR_CLAUSES (orig_for_stmt
),
11252 TREE_CODE (orig_for_stmt
));
11255 switch (TREE_CODE (orig_for_stmt
))
11257 case OMP_FOR
: kind
= GF_OMP_FOR_KIND_FOR
; break;
11258 case OMP_SIMD
: kind
= GF_OMP_FOR_KIND_SIMD
; break;
11259 case OMP_DISTRIBUTE
: kind
= GF_OMP_FOR_KIND_DISTRIBUTE
; break;
11260 case OMP_TASKLOOP
: kind
= GF_OMP_FOR_KIND_TASKLOOP
; break;
11261 case OACC_LOOP
: kind
= GF_OMP_FOR_KIND_OACC_LOOP
; break;
11263 gcc_unreachable ();
11265 gfor
= gimple_build_omp_for (for_body
, kind
, OMP_FOR_CLAUSES (orig_for_stmt
),
11266 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)),
11268 if (orig_for_stmt
!= for_stmt
)
11269 gimple_omp_for_set_combined_p (gfor
, true);
11270 if (gimplify_omp_ctxp
11271 && (gimplify_omp_ctxp
->combined_loop
11272 || (gimplify_omp_ctxp
->region_type
== ORT_COMBINED_PARALLEL
11273 && gimplify_omp_ctxp
->outer_context
11274 && gimplify_omp_ctxp
->outer_context
->combined_loop
)))
11276 gimple_omp_for_set_combined_into_p (gfor
, true);
11277 if (gimplify_omp_ctxp
->combined_loop
)
11278 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_SIMD
);
11280 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_FOR
);
11283 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
11285 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
11286 gimple_omp_for_set_index (gfor
, i
, TREE_OPERAND (t
, 0));
11287 gimple_omp_for_set_initial (gfor
, i
, TREE_OPERAND (t
, 1));
11288 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
11289 gimple_omp_for_set_cond (gfor
, i
, TREE_CODE (t
));
11290 gimple_omp_for_set_final (gfor
, i
, TREE_OPERAND (t
, 1));
11291 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
11292 gimple_omp_for_set_incr (gfor
, i
, TREE_OPERAND (t
, 1));
11295 /* OMP_TASKLOOP is gimplified as two GIMPLE_OMP_FOR taskloop
11296 constructs with GIMPLE_OMP_TASK sandwiched in between them.
11297 The outer taskloop stands for computing the number of iterations,
11298 counts for collapsed loops and holding taskloop specific clauses.
11299 The task construct stands for the effect of data sharing on the
11300 explicit task it creates and the inner taskloop stands for expansion
11301 of the static loop inside of the explicit task construct. */
11302 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
11304 tree
*gfor_clauses_ptr
= gimple_omp_for_clauses_ptr (gfor
);
11305 tree task_clauses
= NULL_TREE
;
11306 tree c
= *gfor_clauses_ptr
;
11307 tree
*gtask_clauses_ptr
= &task_clauses
;
11308 tree outer_for_clauses
= NULL_TREE
;
11309 tree
*gforo_clauses_ptr
= &outer_for_clauses
;
11310 for (; c
; c
= OMP_CLAUSE_CHAIN (c
))
11311 switch (OMP_CLAUSE_CODE (c
))
11313 /* These clauses are allowed on task, move them there. */
11314 case OMP_CLAUSE_SHARED
:
11315 case OMP_CLAUSE_FIRSTPRIVATE
:
11316 case OMP_CLAUSE_DEFAULT
:
11317 case OMP_CLAUSE_IF
:
11318 case OMP_CLAUSE_UNTIED
:
11319 case OMP_CLAUSE_FINAL
:
11320 case OMP_CLAUSE_MERGEABLE
:
11321 case OMP_CLAUSE_PRIORITY
:
11322 case OMP_CLAUSE_REDUCTION
:
11323 case OMP_CLAUSE_IN_REDUCTION
:
11324 *gtask_clauses_ptr
= c
;
11325 gtask_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
11327 case OMP_CLAUSE_PRIVATE
:
11328 if (OMP_CLAUSE_PRIVATE_TASKLOOP_IV (c
))
11330 /* We want private on outer for and firstprivate
11333 = build_omp_clause (OMP_CLAUSE_LOCATION (c
),
11334 OMP_CLAUSE_FIRSTPRIVATE
);
11335 OMP_CLAUSE_DECL (*gtask_clauses_ptr
) = OMP_CLAUSE_DECL (c
);
11336 lang_hooks
.decls
.omp_finish_clause (*gtask_clauses_ptr
, NULL
);
11337 gtask_clauses_ptr
= &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr
);
11338 *gforo_clauses_ptr
= c
;
11339 gforo_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
11343 *gtask_clauses_ptr
= c
;
11344 gtask_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
11347 /* These clauses go into outer taskloop clauses. */
11348 case OMP_CLAUSE_GRAINSIZE
:
11349 case OMP_CLAUSE_NUM_TASKS
:
11350 case OMP_CLAUSE_NOGROUP
:
11351 *gforo_clauses_ptr
= c
;
11352 gforo_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
11354 /* Taskloop clause we duplicate on both taskloops. */
11355 case OMP_CLAUSE_COLLAPSE
:
11356 *gfor_clauses_ptr
= c
;
11357 gfor_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
11358 *gforo_clauses_ptr
= copy_node (c
);
11359 gforo_clauses_ptr
= &OMP_CLAUSE_CHAIN (*gforo_clauses_ptr
);
11361 /* For lastprivate, keep the clause on inner taskloop, and add
11362 a shared clause on task. If the same decl is also firstprivate,
11363 add also firstprivate clause on the inner taskloop. */
11364 case OMP_CLAUSE_LASTPRIVATE
:
11365 if (OMP_CLAUSE_LASTPRIVATE_TASKLOOP_IV (c
))
11367 /* For taskloop C++ lastprivate IVs, we want:
11368 1) private on outer taskloop
11369 2) firstprivate and shared on task
11370 3) lastprivate on inner taskloop */
11372 = build_omp_clause (OMP_CLAUSE_LOCATION (c
),
11373 OMP_CLAUSE_FIRSTPRIVATE
);
11374 OMP_CLAUSE_DECL (*gtask_clauses_ptr
) = OMP_CLAUSE_DECL (c
);
11375 lang_hooks
.decls
.omp_finish_clause (*gtask_clauses_ptr
, NULL
);
11376 gtask_clauses_ptr
= &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr
);
11377 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
) = 1;
11378 *gforo_clauses_ptr
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
11379 OMP_CLAUSE_PRIVATE
);
11380 OMP_CLAUSE_DECL (*gforo_clauses_ptr
) = OMP_CLAUSE_DECL (c
);
11381 OMP_CLAUSE_PRIVATE_TASKLOOP_IV (*gforo_clauses_ptr
) = 1;
11382 TREE_TYPE (*gforo_clauses_ptr
) = TREE_TYPE (c
);
11383 gforo_clauses_ptr
= &OMP_CLAUSE_CHAIN (*gforo_clauses_ptr
);
11385 *gfor_clauses_ptr
= c
;
11386 gfor_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
11388 = build_omp_clause (OMP_CLAUSE_LOCATION (c
), OMP_CLAUSE_SHARED
);
11389 OMP_CLAUSE_DECL (*gtask_clauses_ptr
) = OMP_CLAUSE_DECL (c
);
11390 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
11391 OMP_CLAUSE_SHARED_FIRSTPRIVATE (*gtask_clauses_ptr
) = 1;
11393 = &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr
);
11396 gcc_unreachable ();
11398 *gfor_clauses_ptr
= NULL_TREE
;
11399 *gtask_clauses_ptr
= NULL_TREE
;
11400 *gforo_clauses_ptr
= NULL_TREE
;
11401 g
= gimple_build_bind (NULL_TREE
, gfor
, NULL_TREE
);
11402 g
= gimple_build_omp_task (g
, task_clauses
, NULL_TREE
, NULL_TREE
,
11403 NULL_TREE
, NULL_TREE
, NULL_TREE
);
11404 gimple_omp_task_set_taskloop_p (g
, true);
11405 g
= gimple_build_bind (NULL_TREE
, g
, NULL_TREE
);
11407 = gimple_build_omp_for (g
, GF_OMP_FOR_KIND_TASKLOOP
, outer_for_clauses
,
11408 gimple_omp_for_collapse (gfor
),
11409 gimple_omp_for_pre_body (gfor
));
11410 gimple_omp_for_set_pre_body (gfor
, NULL
);
11411 gimple_omp_for_set_combined_p (gforo
, true);
11412 gimple_omp_for_set_combined_into_p (gfor
, true);
11413 for (i
= 0; i
< (int) gimple_omp_for_collapse (gfor
); i
++)
11415 tree type
= TREE_TYPE (gimple_omp_for_index (gfor
, i
));
11416 tree v
= create_tmp_var (type
);
11417 gimple_omp_for_set_index (gforo
, i
, v
);
11418 t
= unshare_expr (gimple_omp_for_initial (gfor
, i
));
11419 gimple_omp_for_set_initial (gforo
, i
, t
);
11420 gimple_omp_for_set_cond (gforo
, i
,
11421 gimple_omp_for_cond (gfor
, i
));
11422 t
= unshare_expr (gimple_omp_for_final (gfor
, i
));
11423 gimple_omp_for_set_final (gforo
, i
, t
);
11424 t
= unshare_expr (gimple_omp_for_incr (gfor
, i
));
11425 gcc_assert (TREE_OPERAND (t
, 0) == gimple_omp_for_index (gfor
, i
));
11426 TREE_OPERAND (t
, 0) = v
;
11427 gimple_omp_for_set_incr (gforo
, i
, t
);
11428 t
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
11429 OMP_CLAUSE_DECL (t
) = v
;
11430 OMP_CLAUSE_CHAIN (t
) = gimple_omp_for_clauses (gforo
);
11431 gimple_omp_for_set_clauses (gforo
, t
);
11433 gimplify_seq_add_stmt (pre_p
, gforo
);
11436 gimplify_seq_add_stmt (pre_p
, gfor
);
11437 if (ret
!= GS_ALL_DONE
)
11439 *expr_p
= NULL_TREE
;
11440 return GS_ALL_DONE
;
11443 /* Helper function of optimize_target_teams, find OMP_TEAMS inside
11444 of OMP_TARGET's body. */
11447 find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
11449 *walk_subtrees
= 0;
11450 switch (TREE_CODE (*tp
))
11455 case STATEMENT_LIST
:
11456 *walk_subtrees
= 1;
11464 /* Helper function of optimize_target_teams, determine if the expression
11465 can be computed safely before the target construct on the host. */
11468 computable_teams_clause (tree
*tp
, int *walk_subtrees
, void *)
11474 *walk_subtrees
= 0;
11477 switch (TREE_CODE (*tp
))
11482 *walk_subtrees
= 0;
11483 if (error_operand_p (*tp
)
11484 || !INTEGRAL_TYPE_P (TREE_TYPE (*tp
))
11485 || DECL_HAS_VALUE_EXPR_P (*tp
)
11486 || DECL_THREAD_LOCAL_P (*tp
)
11487 || TREE_SIDE_EFFECTS (*tp
)
11488 || TREE_THIS_VOLATILE (*tp
))
11490 if (is_global_var (*tp
)
11491 && (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (*tp
))
11492 || lookup_attribute ("omp declare target link",
11493 DECL_ATTRIBUTES (*tp
))))
11496 && !DECL_SEEN_IN_BIND_EXPR_P (*tp
)
11497 && !is_global_var (*tp
)
11498 && decl_function_context (*tp
) == current_function_decl
)
11500 n
= splay_tree_lookup (gimplify_omp_ctxp
->variables
,
11501 (splay_tree_key
) *tp
);
11504 if (gimplify_omp_ctxp
->defaultmap
[GDMK_SCALAR
] & GOVD_FIRSTPRIVATE
)
11508 else if (n
->value
& GOVD_LOCAL
)
11510 else if (n
->value
& GOVD_FIRSTPRIVATE
)
11512 else if ((n
->value
& (GOVD_MAP
| GOVD_MAP_ALWAYS_TO
))
11513 == (GOVD_MAP
| GOVD_MAP_ALWAYS_TO
))
11517 if (!INTEGRAL_TYPE_P (TREE_TYPE (*tp
)))
11521 if (TARGET_EXPR_INITIAL (*tp
)
11522 || TREE_CODE (TARGET_EXPR_SLOT (*tp
)) != VAR_DECL
)
11524 return computable_teams_clause (&TARGET_EXPR_SLOT (*tp
),
11525 walk_subtrees
, NULL
);
11526 /* Allow some reasonable subset of integral arithmetics. */
11530 case TRUNC_DIV_EXPR
:
11531 case CEIL_DIV_EXPR
:
11532 case FLOOR_DIV_EXPR
:
11533 case ROUND_DIV_EXPR
:
11534 case TRUNC_MOD_EXPR
:
11535 case CEIL_MOD_EXPR
:
11536 case FLOOR_MOD_EXPR
:
11537 case ROUND_MOD_EXPR
:
11539 case EXACT_DIV_EXPR
:
11550 case NON_LVALUE_EXPR
:
11552 if (!INTEGRAL_TYPE_P (TREE_TYPE (*tp
)))
11555 /* And disallow anything else, except for comparisons. */
11557 if (COMPARISON_CLASS_P (*tp
))
11563 /* Try to determine if the num_teams and/or thread_limit expressions
11564 can have their values determined already before entering the
11566 INTEGER_CSTs trivially are,
11567 integral decls that are firstprivate (explicitly or implicitly)
11568 or explicitly map(always, to:) or map(always, tofrom:) on the target
11569 region too, and expressions involving simple arithmetics on those
11570 too, function calls are not ok, dereferencing something neither etc.
11571 Add NUM_TEAMS and THREAD_LIMIT clauses to the OMP_CLAUSES of
11572 EXPR based on what we find:
11573 0 stands for clause not specified at all, use implementation default
11574 -1 stands for value that can't be determined easily before entering
11575 the target construct.
11576 If teams construct is not present at all, use 1 for num_teams
11577 and 0 for thread_limit (only one team is involved, and the thread
11578 limit is implementation defined. */
11581 optimize_target_teams (tree target
, gimple_seq
*pre_p
)
11583 tree body
= OMP_BODY (target
);
11584 tree teams
= walk_tree (&body
, find_omp_teams
, NULL
, NULL
);
11585 tree num_teams
= integer_zero_node
;
11586 tree thread_limit
= integer_zero_node
;
11587 location_t num_teams_loc
= EXPR_LOCATION (target
);
11588 location_t thread_limit_loc
= EXPR_LOCATION (target
);
11590 struct gimplify_omp_ctx
*target_ctx
= gimplify_omp_ctxp
;
11592 if (teams
== NULL_TREE
)
11593 num_teams
= integer_one_node
;
11595 for (c
= OMP_TEAMS_CLAUSES (teams
); c
; c
= OMP_CLAUSE_CHAIN (c
))
11597 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
)
11600 num_teams_loc
= OMP_CLAUSE_LOCATION (c
);
11602 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
11605 thread_limit_loc
= OMP_CLAUSE_LOCATION (c
);
11609 expr
= OMP_CLAUSE_OPERAND (c
, 0);
11610 if (TREE_CODE (expr
) == INTEGER_CST
)
11615 if (walk_tree (&expr
, computable_teams_clause
, NULL
, NULL
))
11617 *p
= integer_minus_one_node
;
11621 gimplify_omp_ctxp
= gimplify_omp_ctxp
->outer_context
;
11622 if (gimplify_expr (p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
, false)
11625 gimplify_omp_ctxp
= target_ctx
;
11626 *p
= integer_minus_one_node
;
11629 gimplify_omp_ctxp
= target_ctx
;
11630 if (!DECL_P (expr
) && TREE_CODE (expr
) != TARGET_EXPR
)
11631 OMP_CLAUSE_OPERAND (c
, 0) = *p
;
11633 c
= build_omp_clause (thread_limit_loc
, OMP_CLAUSE_THREAD_LIMIT
);
11634 OMP_CLAUSE_THREAD_LIMIT_EXPR (c
) = thread_limit
;
11635 OMP_CLAUSE_CHAIN (c
) = OMP_TARGET_CLAUSES (target
);
11636 OMP_TARGET_CLAUSES (target
) = c
;
11637 c
= build_omp_clause (num_teams_loc
, OMP_CLAUSE_NUM_TEAMS
);
11638 OMP_CLAUSE_NUM_TEAMS_EXPR (c
) = num_teams
;
11639 OMP_CLAUSE_CHAIN (c
) = OMP_TARGET_CLAUSES (target
);
11640 OMP_TARGET_CLAUSES (target
) = c
;
11643 /* Gimplify the gross structure of several OMP constructs. */
11646 gimplify_omp_workshare (tree
*expr_p
, gimple_seq
*pre_p
)
11648 tree expr
= *expr_p
;
11650 gimple_seq body
= NULL
;
11651 enum omp_region_type ort
;
11653 switch (TREE_CODE (expr
))
11657 ort
= ORT_WORKSHARE
;
11660 ort
= OMP_TARGET_COMBINED (expr
) ? ORT_COMBINED_TARGET
: ORT_TARGET
;
11663 ort
= ORT_ACC_KERNELS
;
11665 case OACC_PARALLEL
:
11666 ort
= ORT_ACC_PARALLEL
;
11669 ort
= ORT_ACC_DATA
;
11671 case OMP_TARGET_DATA
:
11672 ort
= ORT_TARGET_DATA
;
11675 ort
= OMP_TEAMS_COMBINED (expr
) ? ORT_COMBINED_TEAMS
: ORT_TEAMS
;
11676 if (gimplify_omp_ctxp
== NULL
11677 || (gimplify_omp_ctxp
->region_type
== ORT_TARGET
11678 && gimplify_omp_ctxp
->outer_context
== NULL
11679 && lookup_attribute ("omp declare target",
11680 DECL_ATTRIBUTES (current_function_decl
))))
11681 ort
= (enum omp_region_type
) (ort
| ORT_HOST_TEAMS
);
11683 case OACC_HOST_DATA
:
11684 ort
= ORT_ACC_HOST_DATA
;
11687 gcc_unreachable ();
11689 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr
), pre_p
, ort
,
11691 if (TREE_CODE (expr
) == OMP_TARGET
)
11692 optimize_target_teams (expr
, pre_p
);
11693 if ((ort
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0
11694 || (ort
& ORT_HOST_TEAMS
) == ORT_HOST_TEAMS
)
11696 push_gimplify_context ();
11697 gimple
*g
= gimplify_and_return_first (OMP_BODY (expr
), &body
);
11698 if (gimple_code (g
) == GIMPLE_BIND
)
11699 pop_gimplify_context (g
);
11701 pop_gimplify_context (NULL
);
11702 if ((ort
& ORT_TARGET_DATA
) != 0)
11704 enum built_in_function end_ix
;
11705 switch (TREE_CODE (expr
))
11708 case OACC_HOST_DATA
:
11709 end_ix
= BUILT_IN_GOACC_DATA_END
;
11711 case OMP_TARGET_DATA
:
11712 end_ix
= BUILT_IN_GOMP_TARGET_END_DATA
;
11715 gcc_unreachable ();
11717 tree fn
= builtin_decl_explicit (end_ix
);
11718 g
= gimple_build_call (fn
, 0);
11719 gimple_seq cleanup
= NULL
;
11720 gimple_seq_add_stmt (&cleanup
, g
);
11721 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
11723 gimple_seq_add_stmt (&body
, g
);
11727 gimplify_and_add (OMP_BODY (expr
), &body
);
11728 gimplify_adjust_omp_clauses (pre_p
, body
, &OMP_CLAUSES (expr
),
11731 switch (TREE_CODE (expr
))
11734 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_DATA
,
11735 OMP_CLAUSES (expr
));
11738 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_KERNELS
,
11739 OMP_CLAUSES (expr
));
11741 case OACC_HOST_DATA
:
11742 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_HOST_DATA
,
11743 OMP_CLAUSES (expr
));
11745 case OACC_PARALLEL
:
11746 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_PARALLEL
,
11747 OMP_CLAUSES (expr
));
11750 stmt
= gimple_build_omp_sections (body
, OMP_CLAUSES (expr
));
11753 stmt
= gimple_build_omp_single (body
, OMP_CLAUSES (expr
));
11756 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_REGION
,
11757 OMP_CLAUSES (expr
));
11759 case OMP_TARGET_DATA
:
11760 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_DATA
,
11761 OMP_CLAUSES (expr
));
11764 stmt
= gimple_build_omp_teams (body
, OMP_CLAUSES (expr
));
11765 if ((ort
& ORT_HOST_TEAMS
) == ORT_HOST_TEAMS
)
11766 gimple_omp_teams_set_host (as_a
<gomp_teams
*> (stmt
), true);
11769 gcc_unreachable ();
11772 gimplify_seq_add_stmt (pre_p
, stmt
);
11773 *expr_p
= NULL_TREE
;
11776 /* Gimplify the gross structure of OpenACC enter/exit data, update, and OpenMP
11777 target update constructs. */
11780 gimplify_omp_target_update (tree
*expr_p
, gimple_seq
*pre_p
)
11782 tree expr
= *expr_p
;
11785 enum omp_region_type ort
= ORT_WORKSHARE
;
11787 switch (TREE_CODE (expr
))
11789 case OACC_ENTER_DATA
:
11790 case OACC_EXIT_DATA
:
11791 kind
= GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
;
11795 kind
= GF_OMP_TARGET_KIND_OACC_UPDATE
;
11798 case OMP_TARGET_UPDATE
:
11799 kind
= GF_OMP_TARGET_KIND_UPDATE
;
11801 case OMP_TARGET_ENTER_DATA
:
11802 kind
= GF_OMP_TARGET_KIND_ENTER_DATA
;
11804 case OMP_TARGET_EXIT_DATA
:
11805 kind
= GF_OMP_TARGET_KIND_EXIT_DATA
;
11808 gcc_unreachable ();
11810 gimplify_scan_omp_clauses (&OMP_STANDALONE_CLAUSES (expr
), pre_p
,
11811 ort
, TREE_CODE (expr
));
11812 gimplify_adjust_omp_clauses (pre_p
, NULL
, &OMP_STANDALONE_CLAUSES (expr
),
11814 if (TREE_CODE (expr
) == OACC_UPDATE
11815 && omp_find_clause (OMP_STANDALONE_CLAUSES (expr
),
11816 OMP_CLAUSE_IF_PRESENT
))
11818 /* The runtime uses GOMP_MAP_{TO,FROM} to denote the if_present
11820 for (tree c
= OMP_STANDALONE_CLAUSES (expr
); c
; c
= OMP_CLAUSE_CHAIN (c
))
11821 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
)
11822 switch (OMP_CLAUSE_MAP_KIND (c
))
11824 case GOMP_MAP_FORCE_TO
:
11825 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_TO
);
11827 case GOMP_MAP_FORCE_FROM
:
11828 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_FROM
);
11834 else if (TREE_CODE (expr
) == OACC_EXIT_DATA
11835 && omp_find_clause (OMP_STANDALONE_CLAUSES (expr
),
11836 OMP_CLAUSE_FINALIZE
))
11838 /* Use GOMP_MAP_DELETE/GOMP_MAP_FORCE_FROM to denote that "finalize"
11839 semantics apply to all mappings of this OpenACC directive. */
11840 bool finalize_marked
= false;
11841 for (tree c
= OMP_STANDALONE_CLAUSES (expr
); c
; c
= OMP_CLAUSE_CHAIN (c
))
11842 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
)
11843 switch (OMP_CLAUSE_MAP_KIND (c
))
11845 case GOMP_MAP_FROM
:
11846 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_FORCE_FROM
);
11847 finalize_marked
= true;
11849 case GOMP_MAP_RELEASE
:
11850 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_DELETE
);
11851 finalize_marked
= true;
11854 /* Check consistency: libgomp relies on the very first data
11855 mapping clause being marked, so make sure we did that before
11856 any other mapping clauses. */
11857 gcc_assert (finalize_marked
);
11861 stmt
= gimple_build_omp_target (NULL
, kind
, OMP_STANDALONE_CLAUSES (expr
));
11863 gimplify_seq_add_stmt (pre_p
, stmt
);
11864 *expr_p
= NULL_TREE
;
11867 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
11868 stabilized the lhs of the atomic operation as *ADDR. Return true if
11869 EXPR is this stabilized form. */
11872 goa_lhs_expr_p (tree expr
, tree addr
)
11874 /* Also include casts to other type variants. The C front end is fond
11875 of adding these for e.g. volatile variables. This is like
11876 STRIP_TYPE_NOPS but includes the main variant lookup. */
11877 STRIP_USELESS_TYPE_CONVERSION (expr
);
11879 if (TREE_CODE (expr
) == INDIRECT_REF
)
11881 expr
= TREE_OPERAND (expr
, 0);
11882 while (expr
!= addr
11883 && (CONVERT_EXPR_P (expr
)
11884 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
11885 && TREE_CODE (expr
) == TREE_CODE (addr
)
11886 && types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (addr
)))
11888 expr
= TREE_OPERAND (expr
, 0);
11889 addr
= TREE_OPERAND (addr
, 0);
11893 return (TREE_CODE (addr
) == ADDR_EXPR
11894 && TREE_CODE (expr
) == ADDR_EXPR
11895 && TREE_OPERAND (addr
, 0) == TREE_OPERAND (expr
, 0));
11897 if (TREE_CODE (addr
) == ADDR_EXPR
&& expr
== TREE_OPERAND (addr
, 0))
11902 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
11903 expression does not involve the lhs, evaluate it into a temporary.
11904 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
11905 or -1 if an error was encountered. */
11908 goa_stabilize_expr (tree
*expr_p
, gimple_seq
*pre_p
, tree lhs_addr
,
11911 tree expr
= *expr_p
;
11914 if (goa_lhs_expr_p (expr
, lhs_addr
))
11919 if (is_gimple_val (expr
))
11923 switch (TREE_CODE_CLASS (TREE_CODE (expr
)))
11926 case tcc_comparison
:
11927 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
, lhs_addr
,
11931 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
, lhs_addr
,
11934 case tcc_expression
:
11935 switch (TREE_CODE (expr
))
11937 case TRUTH_ANDIF_EXPR
:
11938 case TRUTH_ORIF_EXPR
:
11939 case TRUTH_AND_EXPR
:
11940 case TRUTH_OR_EXPR
:
11941 case TRUTH_XOR_EXPR
:
11942 case BIT_INSERT_EXPR
:
11943 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
,
11944 lhs_addr
, lhs_var
);
11946 case TRUTH_NOT_EXPR
:
11947 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
11948 lhs_addr
, lhs_var
);
11950 case COMPOUND_EXPR
:
11951 /* Break out any preevaluations from cp_build_modify_expr. */
11952 for (; TREE_CODE (expr
) == COMPOUND_EXPR
;
11953 expr
= TREE_OPERAND (expr
, 1))
11954 gimplify_stmt (&TREE_OPERAND (expr
, 0), pre_p
);
11956 return goa_stabilize_expr (expr_p
, pre_p
, lhs_addr
, lhs_var
);
11961 case tcc_reference
:
11962 if (TREE_CODE (expr
) == BIT_FIELD_REF
)
11963 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
11964 lhs_addr
, lhs_var
);
11972 enum gimplify_status gs
;
11973 gs
= gimplify_expr (expr_p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
11974 if (gs
!= GS_ALL_DONE
)
11981 /* Gimplify an OMP_ATOMIC statement. */
11983 static enum gimplify_status
11984 gimplify_omp_atomic (tree
*expr_p
, gimple_seq
*pre_p
)
11986 tree addr
= TREE_OPERAND (*expr_p
, 0);
11987 tree rhs
= TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
11988 ? NULL
: TREE_OPERAND (*expr_p
, 1);
11989 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
11991 gomp_atomic_load
*loadstmt
;
11992 gomp_atomic_store
*storestmt
;
11994 tmp_load
= create_tmp_reg (type
);
11995 if (rhs
&& goa_stabilize_expr (&rhs
, pre_p
, addr
, tmp_load
) < 0)
11998 if (gimplify_expr (&addr
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
12002 loadstmt
= gimple_build_omp_atomic_load (tmp_load
, addr
,
12003 OMP_ATOMIC_MEMORY_ORDER (*expr_p
));
12004 gimplify_seq_add_stmt (pre_p
, loadstmt
);
12007 /* BIT_INSERT_EXPR is not valid for non-integral bitfield
12008 representatives. Use BIT_FIELD_REF on the lhs instead. */
12009 if (TREE_CODE (rhs
) == BIT_INSERT_EXPR
12010 && !INTEGRAL_TYPE_P (TREE_TYPE (tmp_load
)))
12012 tree bitpos
= TREE_OPERAND (rhs
, 2);
12013 tree op1
= TREE_OPERAND (rhs
, 1);
12015 tree tmp_store
= tmp_load
;
12016 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_CAPTURE_OLD
)
12017 tmp_store
= get_initialized_tmp_var (tmp_load
, pre_p
, NULL
);
12018 if (INTEGRAL_TYPE_P (TREE_TYPE (op1
)))
12019 bitsize
= bitsize_int (TYPE_PRECISION (TREE_TYPE (op1
)));
12021 bitsize
= TYPE_SIZE (TREE_TYPE (op1
));
12022 gcc_assert (TREE_OPERAND (rhs
, 0) == tmp_load
);
12023 tree t
= build2_loc (EXPR_LOCATION (rhs
),
12024 MODIFY_EXPR
, void_type_node
,
12025 build3_loc (EXPR_LOCATION (rhs
), BIT_FIELD_REF
,
12026 TREE_TYPE (op1
), tmp_store
, bitsize
,
12028 gimplify_and_add (t
, pre_p
);
12031 if (gimplify_expr (&rhs
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
12036 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
)
12039 = gimple_build_omp_atomic_store (rhs
, OMP_ATOMIC_MEMORY_ORDER (*expr_p
));
12040 gimplify_seq_add_stmt (pre_p
, storestmt
);
12041 switch (TREE_CODE (*expr_p
))
12043 case OMP_ATOMIC_READ
:
12044 case OMP_ATOMIC_CAPTURE_OLD
:
12045 *expr_p
= tmp_load
;
12046 gimple_omp_atomic_set_need_value (loadstmt
);
12048 case OMP_ATOMIC_CAPTURE_NEW
:
12050 gimple_omp_atomic_set_need_value (storestmt
);
12057 return GS_ALL_DONE
;
12060 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
12061 body, and adding some EH bits. */
12063 static enum gimplify_status
12064 gimplify_transaction (tree
*expr_p
, gimple_seq
*pre_p
)
12066 tree expr
= *expr_p
, temp
, tbody
= TRANSACTION_EXPR_BODY (expr
);
12068 gtransaction
*trans_stmt
;
12069 gimple_seq body
= NULL
;
12072 /* Wrap the transaction body in a BIND_EXPR so we have a context
12073 where to put decls for OMP. */
12074 if (TREE_CODE (tbody
) != BIND_EXPR
)
12076 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, tbody
, NULL
);
12077 TREE_SIDE_EFFECTS (bind
) = 1;
12078 SET_EXPR_LOCATION (bind
, EXPR_LOCATION (tbody
));
12079 TRANSACTION_EXPR_BODY (expr
) = bind
;
12082 push_gimplify_context ();
12083 temp
= voidify_wrapper_expr (*expr_p
, NULL
);
12085 body_stmt
= gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr
), &body
);
12086 pop_gimplify_context (body_stmt
);
12088 trans_stmt
= gimple_build_transaction (body
);
12089 if (TRANSACTION_EXPR_OUTER (expr
))
12090 subcode
= GTMA_IS_OUTER
;
12091 else if (TRANSACTION_EXPR_RELAXED (expr
))
12092 subcode
= GTMA_IS_RELAXED
;
12093 gimple_transaction_set_subcode (trans_stmt
, subcode
);
12095 gimplify_seq_add_stmt (pre_p
, trans_stmt
);
12103 *expr_p
= NULL_TREE
;
12104 return GS_ALL_DONE
;
12107 /* Gimplify an OMP_ORDERED construct. EXPR is the tree version. BODY
12108 is the OMP_BODY of the original EXPR (which has already been
12109 gimplified so it's not present in the EXPR).
12111 Return the gimplified GIMPLE_OMP_ORDERED tuple. */
12114 gimplify_omp_ordered (tree expr
, gimple_seq body
)
12119 tree source_c
= NULL_TREE
;
12120 tree sink_c
= NULL_TREE
;
12122 if (gimplify_omp_ctxp
)
12124 for (c
= OMP_ORDERED_CLAUSES (expr
); c
; c
= OMP_CLAUSE_CHAIN (c
))
12125 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
12126 && gimplify_omp_ctxp
->loop_iter_var
.is_empty ()
12127 && (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
12128 || OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SOURCE
))
12130 error_at (OMP_CLAUSE_LOCATION (c
),
12131 "%<ordered%> construct with %<depend%> clause must be "
12132 "closely nested inside a loop with %<ordered%> clause "
12133 "with a parameter");
12136 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
12137 && OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
)
12140 for (decls
= OMP_CLAUSE_DECL (c
), i
= 0;
12141 decls
&& TREE_CODE (decls
) == TREE_LIST
;
12142 decls
= TREE_CHAIN (decls
), ++i
)
12143 if (i
>= gimplify_omp_ctxp
->loop_iter_var
.length () / 2)
12145 else if (TREE_VALUE (decls
)
12146 != gimplify_omp_ctxp
->loop_iter_var
[2 * i
])
12148 error_at (OMP_CLAUSE_LOCATION (c
),
12149 "variable %qE is not an iteration "
12150 "of outermost loop %d, expected %qE",
12151 TREE_VALUE (decls
), i
+ 1,
12152 gimplify_omp_ctxp
->loop_iter_var
[2 * i
]);
12158 = gimplify_omp_ctxp
->loop_iter_var
[2 * i
+ 1];
12159 if (!fail
&& i
!= gimplify_omp_ctxp
->loop_iter_var
.length () / 2)
12161 error_at (OMP_CLAUSE_LOCATION (c
),
12162 "number of variables in %<depend%> clause with "
12163 "%<sink%> modifier does not match number of "
12164 "iteration variables");
12169 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
12170 && OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SOURCE
)
12174 error_at (OMP_CLAUSE_LOCATION (c
),
12175 "more than one %<depend%> clause with %<source%> "
12176 "modifier on an %<ordered%> construct");
12183 if (source_c
&& sink_c
)
12185 error_at (OMP_CLAUSE_LOCATION (source_c
),
12186 "%<depend%> clause with %<source%> modifier specified "
12187 "together with %<depend%> clauses with %<sink%> modifier "
12188 "on the same construct");
12193 return gimple_build_nop ();
12194 return gimple_build_omp_ordered (body
, OMP_ORDERED_CLAUSES (expr
));
12197 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
12198 expression produces a value to be used as an operand inside a GIMPLE
12199 statement, the value will be stored back in *EXPR_P. This value will
12200 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
12201 an SSA_NAME. The corresponding sequence of GIMPLE statements is
12202 emitted in PRE_P and POST_P.
12204 Additionally, this process may overwrite parts of the input
12205 expression during gimplification. Ideally, it should be
12206 possible to do non-destructive gimplification.
12208 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
12209 the expression needs to evaluate to a value to be used as
12210 an operand in a GIMPLE statement, this value will be stored in
12211 *EXPR_P on exit. This happens when the caller specifies one
12212 of fb_lvalue or fb_rvalue fallback flags.
12214 PRE_P will contain the sequence of GIMPLE statements corresponding
12215 to the evaluation of EXPR and all the side-effects that must
12216 be executed before the main expression. On exit, the last
12217 statement of PRE_P is the core statement being gimplified. For
12218 instance, when gimplifying 'if (++a)' the last statement in
12219 PRE_P will be 'if (t.1)' where t.1 is the result of
12220 pre-incrementing 'a'.
12222 POST_P will contain the sequence of GIMPLE statements corresponding
12223 to the evaluation of all the side-effects that must be executed
12224 after the main expression. If this is NULL, the post
12225 side-effects are stored at the end of PRE_P.
12227 The reason why the output is split in two is to handle post
12228 side-effects explicitly. In some cases, an expression may have
12229 inner and outer post side-effects which need to be emitted in
12230 an order different from the one given by the recursive
12231 traversal. For instance, for the expression (*p--)++ the post
12232 side-effects of '--' must actually occur *after* the post
12233 side-effects of '++'. However, gimplification will first visit
12234 the inner expression, so if a separate POST sequence was not
12235 used, the resulting sequence would be:
12242 However, the post-decrement operation in line #2 must not be
12243 evaluated until after the store to *p at line #4, so the
12244 correct sequence should be:
12251 So, by specifying a separate post queue, it is possible
12252 to emit the post side-effects in the correct order.
12253 If POST_P is NULL, an internal queue will be used. Before
12254 returning to the caller, the sequence POST_P is appended to
12255 the main output sequence PRE_P.
12257 GIMPLE_TEST_F points to a function that takes a tree T and
12258 returns nonzero if T is in the GIMPLE form requested by the
12259 caller. The GIMPLE predicates are in gimple.c.
12261 FALLBACK tells the function what sort of a temporary we want if
12262 gimplification cannot produce an expression that complies with
12265 fb_none means that no temporary should be generated
12266 fb_rvalue means that an rvalue is OK to generate
12267 fb_lvalue means that an lvalue is OK to generate
12268 fb_either means that either is OK, but an lvalue is preferable.
12269 fb_mayfail means that gimplification may fail (in which case
12270 GS_ERROR will be returned)
12272 The return value is either GS_ERROR or GS_ALL_DONE, since this
12273 function iterates until EXPR is completely gimplified or an error
12276 enum gimplify_status
12277 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
12278 bool (*gimple_test_f
) (tree
), fallback_t fallback
)
12281 gimple_seq internal_pre
= NULL
;
12282 gimple_seq internal_post
= NULL
;
12285 location_t saved_location
;
12286 enum gimplify_status ret
;
12287 gimple_stmt_iterator pre_last_gsi
, post_last_gsi
;
12290 save_expr
= *expr_p
;
12291 if (save_expr
== NULL_TREE
)
12292 return GS_ALL_DONE
;
12294 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
12295 is_statement
= gimple_test_f
== is_gimple_stmt
;
12297 gcc_assert (pre_p
);
12299 /* Consistency checks. */
12300 if (gimple_test_f
== is_gimple_reg
)
12301 gcc_assert (fallback
& (fb_rvalue
| fb_lvalue
));
12302 else if (gimple_test_f
== is_gimple_val
12303 || gimple_test_f
== is_gimple_call_addr
12304 || gimple_test_f
== is_gimple_condexpr
12305 || gimple_test_f
== is_gimple_mem_rhs
12306 || gimple_test_f
== is_gimple_mem_rhs_or_call
12307 || gimple_test_f
== is_gimple_reg_rhs
12308 || gimple_test_f
== is_gimple_reg_rhs_or_call
12309 || gimple_test_f
== is_gimple_asm_val
12310 || gimple_test_f
== is_gimple_mem_ref_addr
)
12311 gcc_assert (fallback
& fb_rvalue
);
12312 else if (gimple_test_f
== is_gimple_min_lval
12313 || gimple_test_f
== is_gimple_lvalue
)
12314 gcc_assert (fallback
& fb_lvalue
);
12315 else if (gimple_test_f
== is_gimple_addressable
)
12316 gcc_assert (fallback
& fb_either
);
12317 else if (gimple_test_f
== is_gimple_stmt
)
12318 gcc_assert (fallback
== fb_none
);
12321 /* We should have recognized the GIMPLE_TEST_F predicate to
12322 know what kind of fallback to use in case a temporary is
12323 needed to hold the value or address of *EXPR_P. */
12324 gcc_unreachable ();
12327 /* We used to check the predicate here and return immediately if it
12328 succeeds. This is wrong; the design is for gimplification to be
12329 idempotent, and for the predicates to only test for valid forms, not
12330 whether they are fully simplified. */
12332 pre_p
= &internal_pre
;
12334 if (post_p
== NULL
)
12335 post_p
= &internal_post
;
12337 /* Remember the last statements added to PRE_P and POST_P. Every
12338 new statement added by the gimplification helpers needs to be
12339 annotated with location information. To centralize the
12340 responsibility, we remember the last statement that had been
12341 added to both queues before gimplifying *EXPR_P. If
12342 gimplification produces new statements in PRE_P and POST_P, those
12343 statements will be annotated with the same location information
12345 pre_last_gsi
= gsi_last (*pre_p
);
12346 post_last_gsi
= gsi_last (*post_p
);
12348 saved_location
= input_location
;
12349 if (save_expr
!= error_mark_node
12350 && EXPR_HAS_LOCATION (*expr_p
))
12351 input_location
= EXPR_LOCATION (*expr_p
);
12353 /* Loop over the specific gimplifiers until the toplevel node
12354 remains the same. */
12357 /* Strip away as many useless type conversions as possible
12358 at the toplevel. */
12359 STRIP_USELESS_TYPE_CONVERSION (*expr_p
);
12361 /* Remember the expr. */
12362 save_expr
= *expr_p
;
12364 /* Die, die, die, my darling. */
12365 if (error_operand_p (save_expr
))
12371 /* Do any language-specific gimplification. */
12372 ret
= ((enum gimplify_status
)
12373 lang_hooks
.gimplify_expr (expr_p
, pre_p
, post_p
));
12376 if (*expr_p
== NULL_TREE
)
12378 if (*expr_p
!= save_expr
)
12381 else if (ret
!= GS_UNHANDLED
)
12384 /* Make sure that all the cases set 'ret' appropriately. */
12385 ret
= GS_UNHANDLED
;
12386 switch (TREE_CODE (*expr_p
))
12388 /* First deal with the special cases. */
12390 case POSTINCREMENT_EXPR
:
12391 case POSTDECREMENT_EXPR
:
12392 case PREINCREMENT_EXPR
:
12393 case PREDECREMENT_EXPR
:
12394 ret
= gimplify_self_mod_expr (expr_p
, pre_p
, post_p
,
12395 fallback
!= fb_none
,
12396 TREE_TYPE (*expr_p
));
12399 case VIEW_CONVERT_EXPR
:
12400 if ((fallback
& fb_rvalue
)
12401 && is_gimple_reg_type (TREE_TYPE (*expr_p
))
12402 && is_gimple_reg_type (TREE_TYPE (TREE_OPERAND (*expr_p
, 0))))
12404 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
12405 post_p
, is_gimple_val
, fb_rvalue
);
12406 recalculate_side_effects (*expr_p
);
12412 case ARRAY_RANGE_REF
:
12413 case REALPART_EXPR
:
12414 case IMAGPART_EXPR
:
12415 case COMPONENT_REF
:
12416 ret
= gimplify_compound_lval (expr_p
, pre_p
, post_p
,
12417 fallback
? fallback
: fb_rvalue
);
12421 ret
= gimplify_cond_expr (expr_p
, pre_p
, fallback
);
12423 /* C99 code may assign to an array in a structure value of a
12424 conditional expression, and this has undefined behavior
12425 only on execution, so create a temporary if an lvalue is
12427 if (fallback
== fb_lvalue
)
12429 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
, false);
12430 mark_addressable (*expr_p
);
12436 ret
= gimplify_call_expr (expr_p
, pre_p
, fallback
!= fb_none
);
12438 /* C99 code may assign to an array in a structure returned
12439 from a function, and this has undefined behavior only on
12440 execution, so create a temporary if an lvalue is
12442 if (fallback
== fb_lvalue
)
12444 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
, false);
12445 mark_addressable (*expr_p
);
12451 gcc_unreachable ();
12453 case COMPOUND_EXPR
:
12454 ret
= gimplify_compound_expr (expr_p
, pre_p
, fallback
!= fb_none
);
12457 case COMPOUND_LITERAL_EXPR
:
12458 ret
= gimplify_compound_literal_expr (expr_p
, pre_p
,
12459 gimple_test_f
, fallback
);
12464 ret
= gimplify_modify_expr (expr_p
, pre_p
, post_p
,
12465 fallback
!= fb_none
);
12468 case TRUTH_ANDIF_EXPR
:
12469 case TRUTH_ORIF_EXPR
:
12471 /* Preserve the original type of the expression and the
12472 source location of the outer expression. */
12473 tree org_type
= TREE_TYPE (*expr_p
);
12474 *expr_p
= gimple_boolify (*expr_p
);
12475 *expr_p
= build3_loc (input_location
, COND_EXPR
,
12479 org_type
, boolean_true_node
),
12482 org_type
, boolean_false_node
));
12487 case TRUTH_NOT_EXPR
:
12489 tree type
= TREE_TYPE (*expr_p
);
12490 /* The parsers are careful to generate TRUTH_NOT_EXPR
12491 only with operands that are always zero or one.
12492 We do not fold here but handle the only interesting case
12493 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
12494 *expr_p
= gimple_boolify (*expr_p
);
12495 if (TYPE_PRECISION (TREE_TYPE (*expr_p
)) == 1)
12496 *expr_p
= build1_loc (input_location
, BIT_NOT_EXPR
,
12497 TREE_TYPE (*expr_p
),
12498 TREE_OPERAND (*expr_p
, 0));
12500 *expr_p
= build2_loc (input_location
, BIT_XOR_EXPR
,
12501 TREE_TYPE (*expr_p
),
12502 TREE_OPERAND (*expr_p
, 0),
12503 build_int_cst (TREE_TYPE (*expr_p
), 1));
12504 if (!useless_type_conversion_p (type
, TREE_TYPE (*expr_p
)))
12505 *expr_p
= fold_convert_loc (input_location
, type
, *expr_p
);
12511 ret
= gimplify_addr_expr (expr_p
, pre_p
, post_p
);
12514 case ANNOTATE_EXPR
:
12516 tree cond
= TREE_OPERAND (*expr_p
, 0);
12517 tree kind
= TREE_OPERAND (*expr_p
, 1);
12518 tree data
= TREE_OPERAND (*expr_p
, 2);
12519 tree type
= TREE_TYPE (cond
);
12520 if (!INTEGRAL_TYPE_P (type
))
12526 tree tmp
= create_tmp_var (type
);
12527 gimplify_arg (&cond
, pre_p
, EXPR_LOCATION (*expr_p
));
12529 = gimple_build_call_internal (IFN_ANNOTATE
, 3, cond
, kind
, data
);
12530 gimple_call_set_lhs (call
, tmp
);
12531 gimplify_seq_add_stmt (pre_p
, call
);
12538 ret
= gimplify_va_arg_expr (expr_p
, pre_p
, post_p
);
12542 if (IS_EMPTY_STMT (*expr_p
))
12548 if (VOID_TYPE_P (TREE_TYPE (*expr_p
))
12549 || fallback
== fb_none
)
12551 /* Just strip a conversion to void (or in void context) and
12553 *expr_p
= TREE_OPERAND (*expr_p
, 0);
12558 ret
= gimplify_conversion (expr_p
);
12559 if (ret
== GS_ERROR
)
12561 if (*expr_p
!= save_expr
)
12565 case FIX_TRUNC_EXPR
:
12566 /* unary_expr: ... | '(' cast ')' val | ... */
12567 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
12568 is_gimple_val
, fb_rvalue
);
12569 recalculate_side_effects (*expr_p
);
12574 bool volatilep
= TREE_THIS_VOLATILE (*expr_p
);
12575 bool notrap
= TREE_THIS_NOTRAP (*expr_p
);
12576 tree saved_ptr_type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 0));
12578 *expr_p
= fold_indirect_ref_loc (input_location
, *expr_p
);
12579 if (*expr_p
!= save_expr
)
12585 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
12586 is_gimple_reg
, fb_rvalue
);
12587 if (ret
== GS_ERROR
)
12590 recalculate_side_effects (*expr_p
);
12591 *expr_p
= fold_build2_loc (input_location
, MEM_REF
,
12592 TREE_TYPE (*expr_p
),
12593 TREE_OPERAND (*expr_p
, 0),
12594 build_int_cst (saved_ptr_type
, 0));
12595 TREE_THIS_VOLATILE (*expr_p
) = volatilep
;
12596 TREE_THIS_NOTRAP (*expr_p
) = notrap
;
12601 /* We arrive here through the various re-gimplifcation paths. */
12603 /* First try re-folding the whole thing. */
12604 tmp
= fold_binary (MEM_REF
, TREE_TYPE (*expr_p
),
12605 TREE_OPERAND (*expr_p
, 0),
12606 TREE_OPERAND (*expr_p
, 1));
12609 REF_REVERSE_STORAGE_ORDER (tmp
)
12610 = REF_REVERSE_STORAGE_ORDER (*expr_p
);
12612 recalculate_side_effects (*expr_p
);
12616 /* Avoid re-gimplifying the address operand if it is already
12617 in suitable form. Re-gimplifying would mark the address
12618 operand addressable. Always gimplify when not in SSA form
12619 as we still may have to gimplify decls with value-exprs. */
12620 if (!gimplify_ctxp
|| !gimple_in_ssa_p (cfun
)
12621 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p
, 0)))
12623 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
12624 is_gimple_mem_ref_addr
, fb_rvalue
);
12625 if (ret
== GS_ERROR
)
12628 recalculate_side_effects (*expr_p
);
12632 /* Constants need not be gimplified. */
12639 /* Drop the overflow flag on constants, we do not want
12640 that in the GIMPLE IL. */
12641 if (TREE_OVERFLOW_P (*expr_p
))
12642 *expr_p
= drop_tree_overflow (*expr_p
);
12647 /* If we require an lvalue, such as for ADDR_EXPR, retain the
12648 CONST_DECL node. Otherwise the decl is replaceable by its
12650 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
12651 if (fallback
& fb_lvalue
)
12655 *expr_p
= DECL_INITIAL (*expr_p
);
12661 ret
= gimplify_decl_expr (expr_p
, pre_p
);
12665 ret
= gimplify_bind_expr (expr_p
, pre_p
);
12669 ret
= gimplify_loop_expr (expr_p
, pre_p
);
12673 ret
= gimplify_switch_expr (expr_p
, pre_p
);
12677 ret
= gimplify_exit_expr (expr_p
);
12681 /* If the target is not LABEL, then it is a computed jump
12682 and the target needs to be gimplified. */
12683 if (TREE_CODE (GOTO_DESTINATION (*expr_p
)) != LABEL_DECL
)
12685 ret
= gimplify_expr (&GOTO_DESTINATION (*expr_p
), pre_p
,
12686 NULL
, is_gimple_val
, fb_rvalue
);
12687 if (ret
== GS_ERROR
)
12690 gimplify_seq_add_stmt (pre_p
,
12691 gimple_build_goto (GOTO_DESTINATION (*expr_p
)));
12696 gimplify_seq_add_stmt (pre_p
,
12697 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p
),
12698 PREDICT_EXPR_OUTCOME (*expr_p
)));
12703 ret
= gimplify_label_expr (expr_p
, pre_p
);
12704 label
= LABEL_EXPR_LABEL (*expr_p
);
12705 gcc_assert (decl_function_context (label
) == current_function_decl
);
12707 /* If the label is used in a goto statement, or address of the label
12708 is taken, we need to unpoison all variables that were seen so far.
12709 Doing so would prevent us from reporting a false positives. */
12710 if (asan_poisoned_variables
12711 && asan_used_labels
!= NULL
12712 && asan_used_labels
->contains (label
))
12713 asan_poison_variables (asan_poisoned_variables
, false, pre_p
);
12716 case CASE_LABEL_EXPR
:
12717 ret
= gimplify_case_label_expr (expr_p
, pre_p
);
12719 if (gimplify_ctxp
->live_switch_vars
)
12720 asan_poison_variables (gimplify_ctxp
->live_switch_vars
, false,
12725 ret
= gimplify_return_expr (*expr_p
, pre_p
);
12729 /* Don't reduce this in place; let gimplify_init_constructor work its
12730 magic. Buf if we're just elaborating this for side effects, just
12731 gimplify any element that has side-effects. */
12732 if (fallback
== fb_none
)
12734 unsigned HOST_WIDE_INT ix
;
12736 tree temp
= NULL_TREE
;
12737 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p
), ix
, val
)
12738 if (TREE_SIDE_EFFECTS (val
))
12739 append_to_statement_list (val
, &temp
);
12742 ret
= temp
? GS_OK
: GS_ALL_DONE
;
12744 /* C99 code may assign to an array in a constructed
12745 structure or union, and this has undefined behavior only
12746 on execution, so create a temporary if an lvalue is
12748 else if (fallback
== fb_lvalue
)
12750 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
, false);
12751 mark_addressable (*expr_p
);
12758 /* The following are special cases that are not handled by the
12759 original GIMPLE grammar. */
12761 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
12764 ret
= gimplify_save_expr (expr_p
, pre_p
, post_p
);
12767 case BIT_FIELD_REF
:
12768 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
12769 post_p
, is_gimple_lvalue
, fb_either
);
12770 recalculate_side_effects (*expr_p
);
12773 case TARGET_MEM_REF
:
12775 enum gimplify_status r0
= GS_ALL_DONE
, r1
= GS_ALL_DONE
;
12777 if (TMR_BASE (*expr_p
))
12778 r0
= gimplify_expr (&TMR_BASE (*expr_p
), pre_p
,
12779 post_p
, is_gimple_mem_ref_addr
, fb_either
);
12780 if (TMR_INDEX (*expr_p
))
12781 r1
= gimplify_expr (&TMR_INDEX (*expr_p
), pre_p
,
12782 post_p
, is_gimple_val
, fb_rvalue
);
12783 if (TMR_INDEX2 (*expr_p
))
12784 r1
= gimplify_expr (&TMR_INDEX2 (*expr_p
), pre_p
,
12785 post_p
, is_gimple_val
, fb_rvalue
);
12786 /* TMR_STEP and TMR_OFFSET are always integer constants. */
12787 ret
= MIN (r0
, r1
);
12791 case NON_LVALUE_EXPR
:
12792 /* This should have been stripped above. */
12793 gcc_unreachable ();
12796 ret
= gimplify_asm_expr (expr_p
, pre_p
, post_p
);
12799 case TRY_FINALLY_EXPR
:
12800 case TRY_CATCH_EXPR
:
12802 gimple_seq eval
, cleanup
;
12805 /* Calls to destructors are generated automatically in FINALLY/CATCH
12806 block. They should have location as UNKNOWN_LOCATION. However,
12807 gimplify_call_expr will reset these call stmts to input_location
12808 if it finds stmt's location is unknown. To prevent resetting for
12809 destructors, we set the input_location to unknown.
12810 Note that this only affects the destructor calls in FINALLY/CATCH
12811 block, and will automatically reset to its original value by the
12812 end of gimplify_expr. */
12813 input_location
= UNKNOWN_LOCATION
;
12814 eval
= cleanup
= NULL
;
12815 gimplify_and_add (TREE_OPERAND (*expr_p
, 0), &eval
);
12816 gimplify_and_add (TREE_OPERAND (*expr_p
, 1), &cleanup
);
12817 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
12818 if (gimple_seq_empty_p (cleanup
))
12820 gimple_seq_add_seq (pre_p
, eval
);
12824 try_
= gimple_build_try (eval
, cleanup
,
12825 TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
12826 ? GIMPLE_TRY_FINALLY
12827 : GIMPLE_TRY_CATCH
);
12828 if (EXPR_HAS_LOCATION (save_expr
))
12829 gimple_set_location (try_
, EXPR_LOCATION (save_expr
));
12830 else if (LOCATION_LOCUS (saved_location
) != UNKNOWN_LOCATION
)
12831 gimple_set_location (try_
, saved_location
);
12832 if (TREE_CODE (*expr_p
) == TRY_CATCH_EXPR
)
12833 gimple_try_set_catch_is_cleanup (try_
,
12834 TRY_CATCH_IS_CLEANUP (*expr_p
));
12835 gimplify_seq_add_stmt (pre_p
, try_
);
12840 case CLEANUP_POINT_EXPR
:
12841 ret
= gimplify_cleanup_point_expr (expr_p
, pre_p
);
12845 ret
= gimplify_target_expr (expr_p
, pre_p
, post_p
);
12851 gimple_seq handler
= NULL
;
12852 gimplify_and_add (CATCH_BODY (*expr_p
), &handler
);
12853 c
= gimple_build_catch (CATCH_TYPES (*expr_p
), handler
);
12854 gimplify_seq_add_stmt (pre_p
, c
);
12859 case EH_FILTER_EXPR
:
12862 gimple_seq failure
= NULL
;
12864 gimplify_and_add (EH_FILTER_FAILURE (*expr_p
), &failure
);
12865 ehf
= gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p
), failure
);
12866 gimple_set_no_warning (ehf
, TREE_NO_WARNING (*expr_p
));
12867 gimplify_seq_add_stmt (pre_p
, ehf
);
12874 enum gimplify_status r0
, r1
;
12875 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
,
12876 post_p
, is_gimple_val
, fb_rvalue
);
12877 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
,
12878 post_p
, is_gimple_val
, fb_rvalue
);
12879 TREE_SIDE_EFFECTS (*expr_p
) = 0;
12880 ret
= MIN (r0
, r1
);
12885 /* We get here when taking the address of a label. We mark
12886 the label as "forced"; meaning it can never be removed and
12887 it is a potential target for any computed goto. */
12888 FORCED_LABEL (*expr_p
) = 1;
12892 case STATEMENT_LIST
:
12893 ret
= gimplify_statement_list (expr_p
, pre_p
);
12896 case WITH_SIZE_EXPR
:
12898 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
12899 post_p
== &internal_post
? NULL
: post_p
,
12900 gimple_test_f
, fallback
);
12901 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
12902 is_gimple_val
, fb_rvalue
);
12909 ret
= gimplify_var_or_parm_decl (expr_p
);
12913 /* When within an OMP context, notice uses of variables. */
12914 if (gimplify_omp_ctxp
)
12915 omp_notice_variable (gimplify_omp_ctxp
, *expr_p
, true);
12919 case DEBUG_EXPR_DECL
:
12920 gcc_unreachable ();
12922 case DEBUG_BEGIN_STMT
:
12923 gimplify_seq_add_stmt (pre_p
,
12924 gimple_build_debug_begin_stmt
12925 (TREE_BLOCK (*expr_p
),
12926 EXPR_LOCATION (*expr_p
)));
12932 /* Allow callbacks into the gimplifier during optimization. */
12937 gimplify_omp_parallel (expr_p
, pre_p
);
12942 gimplify_omp_task (expr_p
, pre_p
);
12948 case OMP_DISTRIBUTE
:
12951 ret
= gimplify_omp_for (expr_p
, pre_p
);
12955 gimplify_oacc_cache (expr_p
, pre_p
);
12960 gimplify_oacc_declare (expr_p
, pre_p
);
12964 case OACC_HOST_DATA
:
12967 case OACC_PARALLEL
:
12971 case OMP_TARGET_DATA
:
12973 gimplify_omp_workshare (expr_p
, pre_p
);
12977 case OACC_ENTER_DATA
:
12978 case OACC_EXIT_DATA
:
12980 case OMP_TARGET_UPDATE
:
12981 case OMP_TARGET_ENTER_DATA
:
12982 case OMP_TARGET_EXIT_DATA
:
12983 gimplify_omp_target_update (expr_p
, pre_p
);
12992 gimple_seq body
= NULL
;
12995 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
12996 switch (TREE_CODE (*expr_p
))
12999 g
= gimple_build_omp_section (body
);
13002 g
= gimple_build_omp_master (body
);
13005 g
= gimplify_omp_ordered (*expr_p
, body
);
13008 gimplify_scan_omp_clauses (&OMP_CRITICAL_CLAUSES (*expr_p
),
13009 pre_p
, ORT_WORKSHARE
, OMP_CRITICAL
);
13010 gimplify_adjust_omp_clauses (pre_p
, body
,
13011 &OMP_CRITICAL_CLAUSES (*expr_p
),
13013 g
= gimple_build_omp_critical (body
,
13014 OMP_CRITICAL_NAME (*expr_p
),
13015 OMP_CRITICAL_CLAUSES (*expr_p
));
13018 gcc_unreachable ();
13020 gimplify_seq_add_stmt (pre_p
, g
);
13025 case OMP_TASKGROUP
:
13027 gimple_seq body
= NULL
;
13029 tree
*pclauses
= &OMP_TASKGROUP_CLAUSES (*expr_p
);
13030 gimplify_scan_omp_clauses (pclauses
, pre_p
, ORT_TASKGROUP
,
13032 gimplify_adjust_omp_clauses (pre_p
, NULL
, pclauses
, OMP_TASKGROUP
);
13033 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
13034 gimple_seq cleanup
= NULL
;
13035 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKGROUP_END
);
13036 gimple
*g
= gimple_build_call (fn
, 0);
13037 gimple_seq_add_stmt (&cleanup
, g
);
13038 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
13040 gimple_seq_add_stmt (&body
, g
);
13041 g
= gimple_build_omp_taskgroup (body
, *pclauses
);
13042 gimplify_seq_add_stmt (pre_p
, g
);
13048 case OMP_ATOMIC_READ
:
13049 case OMP_ATOMIC_CAPTURE_OLD
:
13050 case OMP_ATOMIC_CAPTURE_NEW
:
13051 ret
= gimplify_omp_atomic (expr_p
, pre_p
);
13054 case TRANSACTION_EXPR
:
13055 ret
= gimplify_transaction (expr_p
, pre_p
);
13058 case TRUTH_AND_EXPR
:
13059 case TRUTH_OR_EXPR
:
13060 case TRUTH_XOR_EXPR
:
13062 tree orig_type
= TREE_TYPE (*expr_p
);
13063 tree new_type
, xop0
, xop1
;
13064 *expr_p
= gimple_boolify (*expr_p
);
13065 new_type
= TREE_TYPE (*expr_p
);
13066 if (!useless_type_conversion_p (orig_type
, new_type
))
13068 *expr_p
= fold_convert_loc (input_location
, orig_type
, *expr_p
);
13073 /* Boolified binary truth expressions are semantically equivalent
13074 to bitwise binary expressions. Canonicalize them to the
13075 bitwise variant. */
13076 switch (TREE_CODE (*expr_p
))
13078 case TRUTH_AND_EXPR
:
13079 TREE_SET_CODE (*expr_p
, BIT_AND_EXPR
);
13081 case TRUTH_OR_EXPR
:
13082 TREE_SET_CODE (*expr_p
, BIT_IOR_EXPR
);
13084 case TRUTH_XOR_EXPR
:
13085 TREE_SET_CODE (*expr_p
, BIT_XOR_EXPR
);
13090 /* Now make sure that operands have compatible type to
13091 expression's new_type. */
13092 xop0
= TREE_OPERAND (*expr_p
, 0);
13093 xop1
= TREE_OPERAND (*expr_p
, 1);
13094 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop0
)))
13095 TREE_OPERAND (*expr_p
, 0) = fold_convert_loc (input_location
,
13098 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop1
)))
13099 TREE_OPERAND (*expr_p
, 1) = fold_convert_loc (input_location
,
13102 /* Continue classified as tcc_binary. */
13106 case VEC_COND_EXPR
:
13108 enum gimplify_status r0
, r1
, r2
;
13110 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
13111 post_p
, is_gimple_condexpr
, fb_rvalue
);
13112 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
13113 post_p
, is_gimple_val
, fb_rvalue
);
13114 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
13115 post_p
, is_gimple_val
, fb_rvalue
);
13117 ret
= MIN (MIN (r0
, r1
), r2
);
13118 recalculate_side_effects (*expr_p
);
13122 case VEC_PERM_EXPR
:
13123 /* Classified as tcc_expression. */
13126 case BIT_INSERT_EXPR
:
13127 /* Argument 3 is a constant. */
13130 case POINTER_PLUS_EXPR
:
13132 enum gimplify_status r0
, r1
;
13133 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
13134 post_p
, is_gimple_val
, fb_rvalue
);
13135 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
13136 post_p
, is_gimple_val
, fb_rvalue
);
13137 recalculate_side_effects (*expr_p
);
13138 ret
= MIN (r0
, r1
);
13143 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p
)))
13145 case tcc_comparison
:
13146 /* Handle comparison of objects of non scalar mode aggregates
13147 with a call to memcmp. It would be nice to only have to do
13148 this for variable-sized objects, but then we'd have to allow
13149 the same nest of reference nodes we allow for MODIFY_EXPR and
13150 that's too complex.
13152 Compare scalar mode aggregates as scalar mode values. Using
13153 memcmp for them would be very inefficient at best, and is
13154 plain wrong if bitfields are involved. */
13156 tree type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 1));
13158 /* Vector comparisons need no boolification. */
13159 if (TREE_CODE (type
) == VECTOR_TYPE
)
13161 else if (!AGGREGATE_TYPE_P (type
))
13163 tree org_type
= TREE_TYPE (*expr_p
);
13164 *expr_p
= gimple_boolify (*expr_p
);
13165 if (!useless_type_conversion_p (org_type
,
13166 TREE_TYPE (*expr_p
)))
13168 *expr_p
= fold_convert_loc (input_location
,
13169 org_type
, *expr_p
);
13175 else if (TYPE_MODE (type
) != BLKmode
)
13176 ret
= gimplify_scalar_mode_aggregate_compare (expr_p
);
13178 ret
= gimplify_variable_sized_compare (expr_p
);
13183 /* If *EXPR_P does not need to be special-cased, handle it
13184 according to its class. */
13186 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
13187 post_p
, is_gimple_val
, fb_rvalue
);
13193 enum gimplify_status r0
, r1
;
13195 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
13196 post_p
, is_gimple_val
, fb_rvalue
);
13197 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
13198 post_p
, is_gimple_val
, fb_rvalue
);
13200 ret
= MIN (r0
, r1
);
13206 enum gimplify_status r0
, r1
, r2
;
13208 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
13209 post_p
, is_gimple_val
, fb_rvalue
);
13210 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
13211 post_p
, is_gimple_val
, fb_rvalue
);
13212 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
13213 post_p
, is_gimple_val
, fb_rvalue
);
13215 ret
= MIN (MIN (r0
, r1
), r2
);
13219 case tcc_declaration
:
13222 goto dont_recalculate
;
13225 gcc_unreachable ();
13228 recalculate_side_effects (*expr_p
);
13234 gcc_assert (*expr_p
|| ret
!= GS_OK
);
13236 while (ret
== GS_OK
);
13238 /* If we encountered an error_mark somewhere nested inside, either
13239 stub out the statement or propagate the error back out. */
13240 if (ret
== GS_ERROR
)
13247 /* This was only valid as a return value from the langhook, which
13248 we handled. Make sure it doesn't escape from any other context. */
13249 gcc_assert (ret
!= GS_UNHANDLED
);
13251 if (fallback
== fb_none
&& *expr_p
&& !is_gimple_stmt (*expr_p
))
13253 /* We aren't looking for a value, and we don't have a valid
13254 statement. If it doesn't have side-effects, throw it away.
13255 We can also get here with code such as "*&&L;", where L is
13256 a LABEL_DECL that is marked as FORCED_LABEL. */
13257 if (TREE_CODE (*expr_p
) == LABEL_DECL
13258 || !TREE_SIDE_EFFECTS (*expr_p
))
13260 else if (!TREE_THIS_VOLATILE (*expr_p
))
13262 /* This is probably a _REF that contains something nested that
13263 has side effects. Recurse through the operands to find it. */
13264 enum tree_code code
= TREE_CODE (*expr_p
);
13268 case COMPONENT_REF
:
13269 case REALPART_EXPR
:
13270 case IMAGPART_EXPR
:
13271 case VIEW_CONVERT_EXPR
:
13272 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
13273 gimple_test_f
, fallback
);
13277 case ARRAY_RANGE_REF
:
13278 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
13279 gimple_test_f
, fallback
);
13280 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
13281 gimple_test_f
, fallback
);
13285 /* Anything else with side-effects must be converted to
13286 a valid statement before we get here. */
13287 gcc_unreachable ();
13292 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p
))
13293 && TYPE_MODE (TREE_TYPE (*expr_p
)) != BLKmode
)
13295 /* Historically, the compiler has treated a bare reference
13296 to a non-BLKmode volatile lvalue as forcing a load. */
13297 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p
));
13299 /* Normally, we do not want to create a temporary for a
13300 TREE_ADDRESSABLE type because such a type should not be
13301 copied by bitwise-assignment. However, we make an
13302 exception here, as all we are doing here is ensuring that
13303 we read the bytes that make up the type. We use
13304 create_tmp_var_raw because create_tmp_var will abort when
13305 given a TREE_ADDRESSABLE type. */
13306 tree tmp
= create_tmp_var_raw (type
, "vol");
13307 gimple_add_tmp_var (tmp
);
13308 gimplify_assign (tmp
, *expr_p
, pre_p
);
13312 /* We can't do anything useful with a volatile reference to
13313 an incomplete type, so just throw it away. Likewise for
13314 a BLKmode type, since any implicit inner load should
13315 already have been turned into an explicit one by the
13316 gimplification process. */
13320 /* If we are gimplifying at the statement level, we're done. Tack
13321 everything together and return. */
13322 if (fallback
== fb_none
|| is_statement
)
13324 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
13325 it out for GC to reclaim it. */
13326 *expr_p
= NULL_TREE
;
13328 if (!gimple_seq_empty_p (internal_pre
)
13329 || !gimple_seq_empty_p (internal_post
))
13331 gimplify_seq_add_seq (&internal_pre
, internal_post
);
13332 gimplify_seq_add_seq (pre_p
, internal_pre
);
13335 /* The result of gimplifying *EXPR_P is going to be the last few
13336 statements in *PRE_P and *POST_P. Add location information
13337 to all the statements that were added by the gimplification
13339 if (!gimple_seq_empty_p (*pre_p
))
13340 annotate_all_with_location_after (*pre_p
, pre_last_gsi
, input_location
);
13342 if (!gimple_seq_empty_p (*post_p
))
13343 annotate_all_with_location_after (*post_p
, post_last_gsi
,
13349 #ifdef ENABLE_GIMPLE_CHECKING
13352 enum tree_code code
= TREE_CODE (*expr_p
);
13353 /* These expressions should already be in gimple IR form. */
13354 gcc_assert (code
!= MODIFY_EXPR
13355 && code
!= ASM_EXPR
13356 && code
!= BIND_EXPR
13357 && code
!= CATCH_EXPR
13358 && (code
!= COND_EXPR
|| gimplify_ctxp
->allow_rhs_cond_expr
)
13359 && code
!= EH_FILTER_EXPR
13360 && code
!= GOTO_EXPR
13361 && code
!= LABEL_EXPR
13362 && code
!= LOOP_EXPR
13363 && code
!= SWITCH_EXPR
13364 && code
!= TRY_FINALLY_EXPR
13365 && code
!= OACC_PARALLEL
13366 && code
!= OACC_KERNELS
13367 && code
!= OACC_DATA
13368 && code
!= OACC_HOST_DATA
13369 && code
!= OACC_DECLARE
13370 && code
!= OACC_UPDATE
13371 && code
!= OACC_ENTER_DATA
13372 && code
!= OACC_EXIT_DATA
13373 && code
!= OACC_CACHE
13374 && code
!= OMP_CRITICAL
13376 && code
!= OACC_LOOP
13377 && code
!= OMP_MASTER
13378 && code
!= OMP_TASKGROUP
13379 && code
!= OMP_ORDERED
13380 && code
!= OMP_PARALLEL
13381 && code
!= OMP_SECTIONS
13382 && code
!= OMP_SECTION
13383 && code
!= OMP_SINGLE
);
13387 /* Otherwise we're gimplifying a subexpression, so the resulting
13388 value is interesting. If it's a valid operand that matches
13389 GIMPLE_TEST_F, we're done. Unless we are handling some
13390 post-effects internally; if that's the case, we need to copy into
13391 a temporary before adding the post-effects to POST_P. */
13392 if (gimple_seq_empty_p (internal_post
) && (*gimple_test_f
) (*expr_p
))
13395 /* Otherwise, we need to create a new temporary for the gimplified
13398 /* We can't return an lvalue if we have an internal postqueue. The
13399 object the lvalue refers to would (probably) be modified by the
13400 postqueue; we need to copy the value out first, which means an
13402 if ((fallback
& fb_lvalue
)
13403 && gimple_seq_empty_p (internal_post
)
13404 && is_gimple_addressable (*expr_p
))
13406 /* An lvalue will do. Take the address of the expression, store it
13407 in a temporary, and replace the expression with an INDIRECT_REF of
13409 tree ref_alias_type
= reference_alias_ptr_type (*expr_p
);
13410 unsigned int ref_align
= get_object_alignment (*expr_p
);
13411 tree ref_type
= TREE_TYPE (*expr_p
);
13412 tmp
= build_fold_addr_expr_loc (input_location
, *expr_p
);
13413 gimplify_expr (&tmp
, pre_p
, post_p
, is_gimple_reg
, fb_rvalue
);
13414 if (TYPE_ALIGN (ref_type
) != ref_align
)
13415 ref_type
= build_aligned_type (ref_type
, ref_align
);
13416 *expr_p
= build2 (MEM_REF
, ref_type
,
13417 tmp
, build_zero_cst (ref_alias_type
));
13419 else if ((fallback
& fb_rvalue
) && is_gimple_reg_rhs_or_call (*expr_p
))
13421 /* An rvalue will do. Assign the gimplified expression into a
13422 new temporary TMP and replace the original expression with
13423 TMP. First, make sure that the expression has a type so that
13424 it can be assigned into a temporary. */
13425 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p
)));
13426 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
13430 #ifdef ENABLE_GIMPLE_CHECKING
13431 if (!(fallback
& fb_mayfail
))
13433 fprintf (stderr
, "gimplification failed:\n");
13434 print_generic_expr (stderr
, *expr_p
);
13435 debug_tree (*expr_p
);
13436 internal_error ("gimplification failed");
13439 gcc_assert (fallback
& fb_mayfail
);
13441 /* If this is an asm statement, and the user asked for the
13442 impossible, don't die. Fail and let gimplify_asm_expr
13448 /* Make sure the temporary matches our predicate. */
13449 gcc_assert ((*gimple_test_f
) (*expr_p
));
13451 if (!gimple_seq_empty_p (internal_post
))
13453 annotate_all_with_location (internal_post
, input_location
);
13454 gimplify_seq_add_seq (pre_p
, internal_post
);
13458 input_location
= saved_location
;
13462 /* Like gimplify_expr but make sure the gimplified result is not itself
13463 a SSA name (but a decl if it were). Temporaries required by
13464 evaluating *EXPR_P may be still SSA names. */
13466 static enum gimplify_status
13467 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
13468 bool (*gimple_test_f
) (tree
), fallback_t fallback
,
13471 bool was_ssa_name_p
= TREE_CODE (*expr_p
) == SSA_NAME
;
13472 enum gimplify_status ret
= gimplify_expr (expr_p
, pre_p
, post_p
,
13473 gimple_test_f
, fallback
);
13475 && TREE_CODE (*expr_p
) == SSA_NAME
)
13477 tree name
= *expr_p
;
13478 if (was_ssa_name_p
)
13479 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, NULL
, false);
13482 /* Avoid the extra copy if possible. */
13483 *expr_p
= create_tmp_reg (TREE_TYPE (name
));
13484 gimple_set_lhs (SSA_NAME_DEF_STMT (name
), *expr_p
);
13485 release_ssa_name (name
);
13491 /* Look through TYPE for variable-sized objects and gimplify each such
13492 size that we find. Add to LIST_P any statements generated. */
13495 gimplify_type_sizes (tree type
, gimple_seq
*list_p
)
13499 if (type
== NULL
|| type
== error_mark_node
)
13502 /* We first do the main variant, then copy into any other variants. */
13503 type
= TYPE_MAIN_VARIANT (type
);
13505 /* Avoid infinite recursion. */
13506 if (TYPE_SIZES_GIMPLIFIED (type
))
13509 TYPE_SIZES_GIMPLIFIED (type
) = 1;
13511 switch (TREE_CODE (type
))
13514 case ENUMERAL_TYPE
:
13517 case FIXED_POINT_TYPE
:
13518 gimplify_one_sizepos (&TYPE_MIN_VALUE (type
), list_p
);
13519 gimplify_one_sizepos (&TYPE_MAX_VALUE (type
), list_p
);
13521 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
13523 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (type
);
13524 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (type
);
13529 /* These types may not have declarations, so handle them here. */
13530 gimplify_type_sizes (TREE_TYPE (type
), list_p
);
13531 gimplify_type_sizes (TYPE_DOMAIN (type
), list_p
);
13532 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
13533 with assigned stack slots, for -O1+ -g they should be tracked
13535 if (!(TYPE_NAME (type
)
13536 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
13537 && DECL_IGNORED_P (TYPE_NAME (type
)))
13538 && TYPE_DOMAIN (type
)
13539 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type
)))
13541 t
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
13542 if (t
&& VAR_P (t
) && DECL_ARTIFICIAL (t
))
13543 DECL_IGNORED_P (t
) = 0;
13544 t
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
13545 if (t
&& VAR_P (t
) && DECL_ARTIFICIAL (t
))
13546 DECL_IGNORED_P (t
) = 0;
13552 case QUAL_UNION_TYPE
:
13553 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
13554 if (TREE_CODE (field
) == FIELD_DECL
)
13556 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field
), list_p
);
13557 gimplify_one_sizepos (&DECL_SIZE (field
), list_p
);
13558 gimplify_one_sizepos (&DECL_SIZE_UNIT (field
), list_p
);
13559 gimplify_type_sizes (TREE_TYPE (field
), list_p
);
13564 case REFERENCE_TYPE
:
13565 /* We used to recurse on the pointed-to type here, which turned out to
13566 be incorrect because its definition might refer to variables not
13567 yet initialized at this point if a forward declaration is involved.
13569 It was actually useful for anonymous pointed-to types to ensure
13570 that the sizes evaluation dominates every possible later use of the
13571 values. Restricting to such types here would be safe since there
13572 is no possible forward declaration around, but would introduce an
13573 undesirable middle-end semantic to anonymity. We then defer to
13574 front-ends the responsibility of ensuring that the sizes are
13575 evaluated both early and late enough, e.g. by attaching artificial
13576 type declarations to the tree. */
13583 gimplify_one_sizepos (&TYPE_SIZE (type
), list_p
);
13584 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type
), list_p
);
13586 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
13588 TYPE_SIZE (t
) = TYPE_SIZE (type
);
13589 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (type
);
13590 TYPE_SIZES_GIMPLIFIED (t
) = 1;
13594 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
13595 a size or position, has had all of its SAVE_EXPRs evaluated.
13596 We add any required statements to *STMT_P. */
13599 gimplify_one_sizepos (tree
*expr_p
, gimple_seq
*stmt_p
)
13601 tree expr
= *expr_p
;
13603 /* We don't do anything if the value isn't there, is constant, or contains
13604 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
13605 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
13606 will want to replace it with a new variable, but that will cause problems
13607 if this type is from outside the function. It's OK to have that here. */
13608 if (expr
== NULL_TREE
13609 || is_gimple_constant (expr
)
13610 || TREE_CODE (expr
) == VAR_DECL
13611 || CONTAINS_PLACEHOLDER_P (expr
))
13614 *expr_p
= unshare_expr (expr
);
13616 /* SSA names in decl/type fields are a bad idea - they'll get reclaimed
13617 if the def vanishes. */
13618 gimplify_expr (expr_p
, stmt_p
, NULL
, is_gimple_val
, fb_rvalue
, false);
13620 /* If expr wasn't already is_gimple_sizepos or is_gimple_constant from the
13621 FE, ensure that it is a VAR_DECL, otherwise we might handle some decls
13622 as gimplify_vla_decl even when they would have all sizes INTEGER_CSTs. */
13623 if (is_gimple_constant (*expr_p
))
13624 *expr_p
= get_initialized_tmp_var (*expr_p
, stmt_p
, NULL
, false);
13627 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
13628 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
13629 is true, also gimplify the parameters. */
13632 gimplify_body (tree fndecl
, bool do_parms
)
13634 location_t saved_location
= input_location
;
13635 gimple_seq parm_stmts
, parm_cleanup
= NULL
, seq
;
13636 gimple
*outer_stmt
;
13639 timevar_push (TV_TREE_GIMPLIFY
);
13641 init_tree_ssa (cfun
);
13643 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
13645 default_rtl_profile ();
13647 gcc_assert (gimplify_ctxp
== NULL
);
13648 push_gimplify_context (true);
13650 if (flag_openacc
|| flag_openmp
)
13652 gcc_assert (gimplify_omp_ctxp
== NULL
);
13653 if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (fndecl
)))
13654 gimplify_omp_ctxp
= new_omp_context (ORT_TARGET
);
13657 /* Unshare most shared trees in the body and in that of any nested functions.
13658 It would seem we don't have to do this for nested functions because
13659 they are supposed to be output and then the outer function gimplified
13660 first, but the g++ front end doesn't always do it that way. */
13661 unshare_body (fndecl
);
13662 unvisit_body (fndecl
);
13664 /* Make sure input_location isn't set to something weird. */
13665 input_location
= DECL_SOURCE_LOCATION (fndecl
);
13667 /* Resolve callee-copies. This has to be done before processing
13668 the body so that DECL_VALUE_EXPR gets processed correctly. */
13669 parm_stmts
= do_parms
? gimplify_parameters (&parm_cleanup
) : NULL
;
13671 /* Gimplify the function's body. */
13673 gimplify_stmt (&DECL_SAVED_TREE (fndecl
), &seq
);
13674 outer_stmt
= gimple_seq_first_stmt (seq
);
13677 outer_stmt
= gimple_build_nop ();
13678 gimplify_seq_add_stmt (&seq
, outer_stmt
);
13681 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
13682 not the case, wrap everything in a GIMPLE_BIND to make it so. */
13683 if (gimple_code (outer_stmt
) == GIMPLE_BIND
13684 && gimple_seq_first (seq
) == gimple_seq_last (seq
))
13685 outer_bind
= as_a
<gbind
*> (outer_stmt
);
13687 outer_bind
= gimple_build_bind (NULL_TREE
, seq
, NULL
);
13689 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
13691 /* If we had callee-copies statements, insert them at the beginning
13692 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
13693 if (!gimple_seq_empty_p (parm_stmts
))
13697 gimplify_seq_add_seq (&parm_stmts
, gimple_bind_body (outer_bind
));
13700 gtry
*g
= gimple_build_try (parm_stmts
, parm_cleanup
,
13701 GIMPLE_TRY_FINALLY
);
13703 gimple_seq_add_stmt (&parm_stmts
, g
);
13705 gimple_bind_set_body (outer_bind
, parm_stmts
);
13707 for (parm
= DECL_ARGUMENTS (current_function_decl
);
13708 parm
; parm
= DECL_CHAIN (parm
))
13709 if (DECL_HAS_VALUE_EXPR_P (parm
))
13711 DECL_HAS_VALUE_EXPR_P (parm
) = 0;
13712 DECL_IGNORED_P (parm
) = 0;
13716 if ((flag_openacc
|| flag_openmp
|| flag_openmp_simd
)
13717 && gimplify_omp_ctxp
)
13719 delete_omp_context (gimplify_omp_ctxp
);
13720 gimplify_omp_ctxp
= NULL
;
13723 pop_gimplify_context (outer_bind
);
13724 gcc_assert (gimplify_ctxp
== NULL
);
13726 if (flag_checking
&& !seen_error ())
13727 verify_gimple_in_seq (gimple_bind_body (outer_bind
));
13729 timevar_pop (TV_TREE_GIMPLIFY
);
13730 input_location
= saved_location
;
13735 typedef char *char_p
; /* For DEF_VEC_P. */
13737 /* Return whether we should exclude FNDECL from instrumentation. */
13740 flag_instrument_functions_exclude_p (tree fndecl
)
13744 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_functions
;
13745 if (v
&& v
->length () > 0)
13751 name
= lang_hooks
.decl_printable_name (fndecl
, 0);
13752 FOR_EACH_VEC_ELT (*v
, i
, s
)
13753 if (strstr (name
, s
) != NULL
)
13757 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_files
;
13758 if (v
&& v
->length () > 0)
13764 name
= DECL_SOURCE_FILE (fndecl
);
13765 FOR_EACH_VEC_ELT (*v
, i
, s
)
13766 if (strstr (name
, s
) != NULL
)
13773 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
13774 node for the function we want to gimplify.
13776 Return the sequence of GIMPLE statements corresponding to the body
13780 gimplify_function_tree (tree fndecl
)
13786 gcc_assert (!gimple_body (fndecl
));
13788 if (DECL_STRUCT_FUNCTION (fndecl
))
13789 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
13791 push_struct_function (fndecl
);
13793 /* Tentatively set PROP_gimple_lva here, and reset it in gimplify_va_arg_expr
13795 cfun
->curr_properties
|= PROP_gimple_lva
;
13797 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
13799 /* Preliminarily mark non-addressed complex variables as eligible
13800 for promotion to gimple registers. We'll transform their uses
13801 as we find them. */
13802 if ((TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
13803 || TREE_CODE (TREE_TYPE (parm
)) == VECTOR_TYPE
)
13804 && !TREE_THIS_VOLATILE (parm
)
13805 && !needs_to_live_in_memory (parm
))
13806 DECL_GIMPLE_REG_P (parm
) = 1;
13809 ret
= DECL_RESULT (fndecl
);
13810 if ((TREE_CODE (TREE_TYPE (ret
)) == COMPLEX_TYPE
13811 || TREE_CODE (TREE_TYPE (ret
)) == VECTOR_TYPE
)
13812 && !needs_to_live_in_memory (ret
))
13813 DECL_GIMPLE_REG_P (ret
) = 1;
13815 if (asan_sanitize_use_after_scope () && sanitize_flags_p (SANITIZE_ADDRESS
))
13816 asan_poisoned_variables
= new hash_set
<tree
> ();
13817 bind
= gimplify_body (fndecl
, true);
13818 if (asan_poisoned_variables
)
13820 delete asan_poisoned_variables
;
13821 asan_poisoned_variables
= NULL
;
13824 /* The tree body of the function is no longer needed, replace it
13825 with the new GIMPLE body. */
13827 gimple_seq_add_stmt (&seq
, bind
);
13828 gimple_set_body (fndecl
, seq
);
13830 /* If we're instrumenting function entry/exit, then prepend the call to
13831 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
13832 catch the exit hook. */
13833 /* ??? Add some way to ignore exceptions for this TFE. */
13834 if (flag_instrument_function_entry_exit
13835 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
)
13836 /* Do not instrument extern inline functions. */
13837 && !(DECL_DECLARED_INLINE_P (fndecl
)
13838 && DECL_EXTERNAL (fndecl
)
13839 && DECL_DISREGARD_INLINE_LIMITS (fndecl
))
13840 && !flag_instrument_functions_exclude_p (fndecl
))
13845 gimple_seq cleanup
= NULL
, body
= NULL
;
13846 tree tmp_var
, this_fn_addr
;
13849 /* The instrumentation hooks aren't going to call the instrumented
13850 function and the address they receive is expected to be matchable
13851 against symbol addresses. Make sure we don't create a trampoline,
13852 in case the current function is nested. */
13853 this_fn_addr
= build_fold_addr_expr (current_function_decl
);
13854 TREE_NO_TRAMPOLINE (this_fn_addr
) = 1;
13856 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
13857 call
= gimple_build_call (x
, 1, integer_zero_node
);
13858 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
13859 gimple_call_set_lhs (call
, tmp_var
);
13860 gimplify_seq_add_stmt (&cleanup
, call
);
13861 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT
);
13862 call
= gimple_build_call (x
, 2, this_fn_addr
, tmp_var
);
13863 gimplify_seq_add_stmt (&cleanup
, call
);
13864 tf
= gimple_build_try (seq
, cleanup
, GIMPLE_TRY_FINALLY
);
13866 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
13867 call
= gimple_build_call (x
, 1, integer_zero_node
);
13868 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
13869 gimple_call_set_lhs (call
, tmp_var
);
13870 gimplify_seq_add_stmt (&body
, call
);
13871 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER
);
13872 call
= gimple_build_call (x
, 2, this_fn_addr
, tmp_var
);
13873 gimplify_seq_add_stmt (&body
, call
);
13874 gimplify_seq_add_stmt (&body
, tf
);
13875 new_bind
= gimple_build_bind (NULL
, body
, NULL
);
13877 /* Replace the current function body with the body
13878 wrapped in the try/finally TF. */
13880 gimple_seq_add_stmt (&seq
, new_bind
);
13881 gimple_set_body (fndecl
, seq
);
13885 if (sanitize_flags_p (SANITIZE_THREAD
))
13887 gcall
*call
= gimple_build_call_internal (IFN_TSAN_FUNC_EXIT
, 0);
13888 gimple
*tf
= gimple_build_try (seq
, call
, GIMPLE_TRY_FINALLY
);
13889 gbind
*new_bind
= gimple_build_bind (NULL
, tf
, NULL
);
13890 /* Replace the current function body with the body
13891 wrapped in the try/finally TF. */
13893 gimple_seq_add_stmt (&seq
, new_bind
);
13894 gimple_set_body (fndecl
, seq
);
13897 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
13898 cfun
->curr_properties
|= PROP_gimple_any
;
13902 dump_function (TDI_gimple
, fndecl
);
13905 /* Return a dummy expression of type TYPE in order to keep going after an
13909 dummy_object (tree type
)
13911 tree t
= build_int_cst (build_pointer_type (type
), 0);
13912 return build2 (MEM_REF
, type
, t
, t
);
13915 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
13916 builtin function, but a very special sort of operator. */
13918 enum gimplify_status
13919 gimplify_va_arg_expr (tree
*expr_p
, gimple_seq
*pre_p
,
13920 gimple_seq
*post_p ATTRIBUTE_UNUSED
)
13922 tree promoted_type
, have_va_type
;
13923 tree valist
= TREE_OPERAND (*expr_p
, 0);
13924 tree type
= TREE_TYPE (*expr_p
);
13925 tree t
, tag
, aptag
;
13926 location_t loc
= EXPR_LOCATION (*expr_p
);
13928 /* Verify that valist is of the proper type. */
13929 have_va_type
= TREE_TYPE (valist
);
13930 if (have_va_type
== error_mark_node
)
13932 have_va_type
= targetm
.canonical_va_list_type (have_va_type
);
13933 if (have_va_type
== NULL_TREE
13934 && POINTER_TYPE_P (TREE_TYPE (valist
)))
13935 /* Handle 'Case 1: Not an array type' from c-common.c/build_va_arg. */
13937 = targetm
.canonical_va_list_type (TREE_TYPE (TREE_TYPE (valist
)));
13938 gcc_assert (have_va_type
!= NULL_TREE
);
13940 /* Generate a diagnostic for requesting data of a type that cannot
13941 be passed through `...' due to type promotion at the call site. */
13942 if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
13945 static bool gave_help
;
13947 /* Use the expansion point to handle cases such as passing bool (defined
13948 in a system header) through `...'. */
13950 = expansion_point_location_if_in_system_header (loc
);
13952 /* Unfortunately, this is merely undefined, rather than a constraint
13953 violation, so we cannot make this an error. If this call is never
13954 executed, the program is still strictly conforming. */
13955 auto_diagnostic_group d
;
13956 warned
= warning_at (xloc
, 0,
13957 "%qT is promoted to %qT when passed through %<...%>",
13958 type
, promoted_type
);
13959 if (!gave_help
&& warned
)
13962 inform (xloc
, "(so you should pass %qT not %qT to %<va_arg%>)",
13963 promoted_type
, type
);
13966 /* We can, however, treat "undefined" any way we please.
13967 Call abort to encourage the user to fix the program. */
13969 inform (xloc
, "if this code is reached, the program will abort");
13970 /* Before the abort, allow the evaluation of the va_list
13971 expression to exit or longjmp. */
13972 gimplify_and_add (valist
, pre_p
);
13973 t
= build_call_expr_loc (loc
,
13974 builtin_decl_implicit (BUILT_IN_TRAP
), 0);
13975 gimplify_and_add (t
, pre_p
);
13977 /* This is dead code, but go ahead and finish so that the
13978 mode of the result comes out right. */
13979 *expr_p
= dummy_object (type
);
13980 return GS_ALL_DONE
;
13983 tag
= build_int_cst (build_pointer_type (type
), 0);
13984 aptag
= build_int_cst (TREE_TYPE (valist
), 0);
13986 *expr_p
= build_call_expr_internal_loc (loc
, IFN_VA_ARG
, type
, 3,
13987 valist
, tag
, aptag
);
13989 /* Clear the tentatively set PROP_gimple_lva, to indicate that IFN_VA_ARG
13990 needs to be expanded. */
13991 cfun
->curr_properties
&= ~PROP_gimple_lva
;
13996 /* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
13998 DST/SRC are the destination and source respectively. You can pass
13999 ungimplified trees in DST or SRC, in which case they will be
14000 converted to a gimple operand if necessary.
14002 This function returns the newly created GIMPLE_ASSIGN tuple. */
14005 gimplify_assign (tree dst
, tree src
, gimple_seq
*seq_p
)
14007 tree t
= build2 (MODIFY_EXPR
, TREE_TYPE (dst
), dst
, src
);
14008 gimplify_and_add (t
, seq_p
);
14010 return gimple_seq_last_stmt (*seq_p
);
14014 gimplify_hasher::hash (const elt_t
*p
)
14017 return iterative_hash_expr (t
, 0);
14021 gimplify_hasher::equal (const elt_t
*p1
, const elt_t
*p2
)
14025 enum tree_code code
= TREE_CODE (t1
);
14027 if (TREE_CODE (t2
) != code
14028 || TREE_TYPE (t1
) != TREE_TYPE (t2
))
14031 if (!operand_equal_p (t1
, t2
, 0))
14034 /* Only allow them to compare equal if they also hash equal; otherwise
14035 results are nondeterminate, and we fail bootstrap comparison. */
14036 gcc_checking_assert (hash (p1
) == hash (p2
));