1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002-2020 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"
68 #include "omp-offload.h"
71 /* Hash set of poisoned variables in a bind expr. */
72 static hash_set
<tree
> *asan_poisoned_variables
= NULL
;
74 enum gimplify_omp_var_data
77 GOVD_EXPLICIT
= 0x000002,
78 GOVD_SHARED
= 0x000004,
79 GOVD_PRIVATE
= 0x000008,
80 GOVD_FIRSTPRIVATE
= 0x000010,
81 GOVD_LASTPRIVATE
= 0x000020,
82 GOVD_REDUCTION
= 0x000040,
85 GOVD_DEBUG_PRIVATE
= 0x000200,
86 GOVD_PRIVATE_OUTER_REF
= 0x000400,
87 GOVD_LINEAR
= 0x000800,
88 GOVD_ALIGNED
= 0x001000,
90 /* Flag for GOVD_MAP: don't copy back. */
91 GOVD_MAP_TO_ONLY
= 0x002000,
93 /* Flag for GOVD_LINEAR or GOVD_LASTPRIVATE: no outer reference. */
94 GOVD_LINEAR_LASTPRIVATE_NO_OUTER
= 0x004000,
96 GOVD_MAP_0LEN_ARRAY
= 0x008000,
98 /* Flag for GOVD_MAP, if it is always, to or always, tofrom mapping. */
99 GOVD_MAP_ALWAYS_TO
= 0x010000,
101 /* Flag for shared vars that are or might be stored to in the region. */
102 GOVD_WRITTEN
= 0x020000,
104 /* Flag for GOVD_MAP, if it is a forced mapping. */
105 GOVD_MAP_FORCE
= 0x040000,
107 /* Flag for GOVD_MAP: must be present already. */
108 GOVD_MAP_FORCE_PRESENT
= 0x080000,
110 /* Flag for GOVD_MAP: only allocate. */
111 GOVD_MAP_ALLOC_ONLY
= 0x100000,
113 /* Flag for GOVD_MAP: only copy back. */
114 GOVD_MAP_FROM_ONLY
= 0x200000,
116 GOVD_NONTEMPORAL
= 0x400000,
118 /* Flag for GOVD_LASTPRIVATE: conditional modifier. */
119 GOVD_LASTPRIVATE_CONDITIONAL
= 0x800000,
121 GOVD_CONDTEMP
= 0x1000000,
123 /* Flag for GOVD_REDUCTION: inscan seen in {in,ex}clusive clause. */
124 GOVD_REDUCTION_INSCAN
= 0x2000000,
126 /* Flag for GOVD_MAP: (struct) vars that have pointer attachments for
128 GOVD_MAP_HAS_ATTACHMENTS
= 8388608,
130 GOVD_DATA_SHARE_CLASS
= (GOVD_SHARED
| GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
131 | GOVD_LASTPRIVATE
| GOVD_REDUCTION
| GOVD_LINEAR
138 ORT_WORKSHARE
= 0x00,
139 ORT_TASKGROUP
= 0x01,
143 ORT_COMBINED_PARALLEL
= ORT_PARALLEL
| 1,
146 ORT_UNTIED_TASK
= ORT_TASK
| 1,
147 ORT_TASKLOOP
= ORT_TASK
| 2,
148 ORT_UNTIED_TASKLOOP
= ORT_UNTIED_TASK
| 2,
151 ORT_COMBINED_TEAMS
= ORT_TEAMS
| 1,
152 ORT_HOST_TEAMS
= ORT_TEAMS
| 2,
153 ORT_COMBINED_HOST_TEAMS
= ORT_COMBINED_TEAMS
| 2,
156 ORT_TARGET_DATA
= 0x40,
158 /* Data region with offloading. */
160 ORT_COMBINED_TARGET
= ORT_TARGET
| 1,
161 ORT_IMPLICIT_TARGET
= ORT_TARGET
| 2,
163 /* OpenACC variants. */
164 ORT_ACC
= 0x100, /* A generic OpenACC region. */
165 ORT_ACC_DATA
= ORT_ACC
| ORT_TARGET_DATA
, /* Data construct. */
166 ORT_ACC_PARALLEL
= ORT_ACC
| ORT_TARGET
, /* Parallel construct */
167 ORT_ACC_KERNELS
= ORT_ACC
| ORT_TARGET
| 2, /* Kernels construct. */
168 ORT_ACC_SERIAL
= ORT_ACC
| ORT_TARGET
| 4, /* Serial construct. */
169 ORT_ACC_HOST_DATA
= ORT_ACC
| ORT_TARGET_DATA
| 2, /* Host data. */
171 /* Dummy OpenMP region, used to disable expansion of
172 DECL_VALUE_EXPRs in taskloop pre body. */
176 /* Gimplify hashtable helper. */
178 struct gimplify_hasher
: free_ptr_hash
<elt_t
>
180 static inline hashval_t
hash (const elt_t
*);
181 static inline bool equal (const elt_t
*, const elt_t
*);
186 struct gimplify_ctx
*prev_context
;
188 vec
<gbind
*> bind_expr_stack
;
190 gimple_seq conditional_cleanups
;
194 vec
<tree
> case_labels
;
195 hash_set
<tree
> *live_switch_vars
;
196 /* The formal temporary table. Should this be persistent? */
197 hash_table
<gimplify_hasher
> *temp_htab
;
200 unsigned into_ssa
: 1;
201 unsigned allow_rhs_cond_expr
: 1;
202 unsigned in_cleanup_point_expr
: 1;
203 unsigned keep_stack
: 1;
204 unsigned save_stack
: 1;
205 unsigned in_switch_expr
: 1;
208 enum gimplify_defaultmap_kind
216 struct gimplify_omp_ctx
218 struct gimplify_omp_ctx
*outer_context
;
219 splay_tree variables
;
220 hash_set
<tree
> *privatized_types
;
222 /* Iteration variables in an OMP_FOR. */
223 vec
<tree
> loop_iter_var
;
225 enum omp_clause_default_kind default_kind
;
226 enum omp_region_type region_type
;
230 bool target_firstprivatize_array_bases
;
232 bool order_concurrent
;
236 static struct gimplify_ctx
*gimplify_ctxp
;
237 static struct gimplify_omp_ctx
*gimplify_omp_ctxp
;
238 static bool in_omp_construct
;
240 /* Forward declaration. */
241 static enum gimplify_status
gimplify_compound_expr (tree
*, gimple_seq
*, bool);
242 static hash_map
<tree
, tree
> *oacc_declare_returns
;
243 static enum gimplify_status
gimplify_expr (tree
*, gimple_seq
*, gimple_seq
*,
244 bool (*) (tree
), fallback_t
, bool);
246 /* Shorter alias name for the above function for use in gimplify.c
250 gimplify_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
252 gimple_seq_add_stmt_without_update (seq_p
, gs
);
255 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
256 NULL, a new sequence is allocated. This function is
257 similar to gimple_seq_add_seq, but does not scan the operands.
258 During gimplification, we need to manipulate statement sequences
259 before the def/use vectors have been constructed. */
262 gimplify_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
264 gimple_stmt_iterator si
;
269 si
= gsi_last (*dst_p
);
270 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
274 /* Pointer to a list of allocated gimplify_ctx structs to be used for pushing
275 and popping gimplify contexts. */
277 static struct gimplify_ctx
*ctx_pool
= NULL
;
279 /* Return a gimplify context struct from the pool. */
281 static inline struct gimplify_ctx
*
284 struct gimplify_ctx
* c
= ctx_pool
;
287 ctx_pool
= c
->prev_context
;
289 c
= XNEW (struct gimplify_ctx
);
291 memset (c
, '\0', sizeof (*c
));
295 /* Put gimplify context C back into the pool. */
298 ctx_free (struct gimplify_ctx
*c
)
300 c
->prev_context
= ctx_pool
;
304 /* Free allocated ctx stack memory. */
307 free_gimplify_stack (void)
309 struct gimplify_ctx
*c
;
311 while ((c
= ctx_pool
))
313 ctx_pool
= c
->prev_context
;
319 /* Set up a context for the gimplifier. */
322 push_gimplify_context (bool in_ssa
, bool rhs_cond_ok
)
324 struct gimplify_ctx
*c
= ctx_alloc ();
326 c
->prev_context
= gimplify_ctxp
;
328 gimplify_ctxp
->into_ssa
= in_ssa
;
329 gimplify_ctxp
->allow_rhs_cond_expr
= rhs_cond_ok
;
332 /* Tear down a context for the gimplifier. If BODY is non-null, then
333 put the temporaries into the outer BIND_EXPR. Otherwise, put them
336 BODY is not a sequence, but the first tuple in a sequence. */
339 pop_gimplify_context (gimple
*body
)
341 struct gimplify_ctx
*c
= gimplify_ctxp
;
344 && (!c
->bind_expr_stack
.exists ()
345 || c
->bind_expr_stack
.is_empty ()));
346 c
->bind_expr_stack
.release ();
347 gimplify_ctxp
= c
->prev_context
;
350 declare_vars (c
->temps
, body
, false);
352 record_vars (c
->temps
);
359 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
362 gimple_push_bind_expr (gbind
*bind_stmt
)
364 gimplify_ctxp
->bind_expr_stack
.reserve (8);
365 gimplify_ctxp
->bind_expr_stack
.safe_push (bind_stmt
);
368 /* Pop the first element off the stack of bindings. */
371 gimple_pop_bind_expr (void)
373 gimplify_ctxp
->bind_expr_stack
.pop ();
376 /* Return the first element of the stack of bindings. */
379 gimple_current_bind_expr (void)
381 return gimplify_ctxp
->bind_expr_stack
.last ();
384 /* Return the stack of bindings created during gimplification. */
387 gimple_bind_expr_stack (void)
389 return gimplify_ctxp
->bind_expr_stack
;
392 /* Return true iff there is a COND_EXPR between us and the innermost
393 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
396 gimple_conditional_context (void)
398 return gimplify_ctxp
->conditions
> 0;
401 /* Note that we've entered a COND_EXPR. */
404 gimple_push_condition (void)
406 #ifdef ENABLE_GIMPLE_CHECKING
407 if (gimplify_ctxp
->conditions
== 0)
408 gcc_assert (gimple_seq_empty_p (gimplify_ctxp
->conditional_cleanups
));
410 ++(gimplify_ctxp
->conditions
);
413 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
414 now, add any conditional cleanups we've seen to the prequeue. */
417 gimple_pop_condition (gimple_seq
*pre_p
)
419 int conds
= --(gimplify_ctxp
->conditions
);
421 gcc_assert (conds
>= 0);
424 gimplify_seq_add_seq (pre_p
, gimplify_ctxp
->conditional_cleanups
);
425 gimplify_ctxp
->conditional_cleanups
= NULL
;
429 /* A stable comparison routine for use with splay trees and DECLs. */
432 splay_tree_compare_decl_uid (splay_tree_key xa
, splay_tree_key xb
)
437 return DECL_UID (a
) - DECL_UID (b
);
440 /* Create a new omp construct that deals with variable remapping. */
442 static struct gimplify_omp_ctx
*
443 new_omp_context (enum omp_region_type region_type
)
445 struct gimplify_omp_ctx
*c
;
447 c
= XCNEW (struct gimplify_omp_ctx
);
448 c
->outer_context
= gimplify_omp_ctxp
;
449 c
->variables
= splay_tree_new (splay_tree_compare_decl_uid
, 0, 0);
450 c
->privatized_types
= new hash_set
<tree
>;
451 c
->location
= input_location
;
452 c
->region_type
= region_type
;
453 if ((region_type
& ORT_TASK
) == 0)
454 c
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
456 c
->default_kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
457 c
->defaultmap
[GDMK_SCALAR
] = GOVD_MAP
;
458 c
->defaultmap
[GDMK_AGGREGATE
] = GOVD_MAP
;
459 c
->defaultmap
[GDMK_ALLOCATABLE
] = GOVD_MAP
;
460 c
->defaultmap
[GDMK_POINTER
] = GOVD_MAP
;
465 /* Destroy an omp construct that deals with variable remapping. */
468 delete_omp_context (struct gimplify_omp_ctx
*c
)
470 splay_tree_delete (c
->variables
);
471 delete c
->privatized_types
;
472 c
->loop_iter_var
.release ();
476 static void omp_add_variable (struct gimplify_omp_ctx
*, tree
, unsigned int);
477 static bool omp_notice_variable (struct gimplify_omp_ctx
*, tree
, bool);
479 /* Both gimplify the statement T and append it to *SEQ_P. This function
480 behaves exactly as gimplify_stmt, but you don't have to pass T as a
484 gimplify_and_add (tree t
, gimple_seq
*seq_p
)
486 gimplify_stmt (&t
, seq_p
);
489 /* Gimplify statement T into sequence *SEQ_P, and return the first
490 tuple in the sequence of generated tuples for this statement.
491 Return NULL if gimplifying T produced no tuples. */
494 gimplify_and_return_first (tree t
, gimple_seq
*seq_p
)
496 gimple_stmt_iterator last
= gsi_last (*seq_p
);
498 gimplify_and_add (t
, seq_p
);
500 if (!gsi_end_p (last
))
503 return gsi_stmt (last
);
506 return gimple_seq_first_stmt (*seq_p
);
509 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
510 LHS, or for a call argument. */
513 is_gimple_mem_rhs (tree t
)
515 /* If we're dealing with a renamable type, either source or dest must be
516 a renamed variable. */
517 if (is_gimple_reg_type (TREE_TYPE (t
)))
518 return is_gimple_val (t
);
520 return is_gimple_val (t
) || is_gimple_lvalue (t
);
523 /* Return true if T is a CALL_EXPR or an expression that can be
524 assigned to a temporary. Note that this predicate should only be
525 used during gimplification. See the rationale for this in
526 gimplify_modify_expr. */
529 is_gimple_reg_rhs_or_call (tree t
)
531 return (get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
532 || TREE_CODE (t
) == CALL_EXPR
);
535 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
536 this predicate should only be used during gimplification. See the
537 rationale for this in gimplify_modify_expr. */
540 is_gimple_mem_rhs_or_call (tree t
)
542 /* If we're dealing with a renamable type, either source or dest must be
543 a renamed variable. */
544 if (is_gimple_reg_type (TREE_TYPE (t
)))
545 return is_gimple_val (t
);
547 return (is_gimple_val (t
)
548 || is_gimple_lvalue (t
)
549 || TREE_CLOBBER_P (t
)
550 || TREE_CODE (t
) == CALL_EXPR
);
553 /* Create a temporary with a name derived from VAL. Subroutine of
554 lookup_tmp_var; nobody else should call this function. */
557 create_tmp_from_val (tree val
)
559 /* Drop all qualifiers and address-space information from the value type. */
560 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (val
));
561 tree var
= create_tmp_var (type
, get_name (val
));
562 if (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
563 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
564 DECL_GIMPLE_REG_P (var
) = 1;
568 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
569 an existing expression temporary. */
572 lookup_tmp_var (tree val
, bool is_formal
)
576 /* If not optimizing, never really reuse a temporary. local-alloc
577 won't allocate any variable that is used in more than one basic
578 block, which means it will go into memory, causing much extra
579 work in reload and final and poorer code generation, outweighing
580 the extra memory allocation here. */
581 if (!optimize
|| !is_formal
|| TREE_SIDE_EFFECTS (val
))
582 ret
= create_tmp_from_val (val
);
589 if (!gimplify_ctxp
->temp_htab
)
590 gimplify_ctxp
->temp_htab
= new hash_table
<gimplify_hasher
> (1000);
591 slot
= gimplify_ctxp
->temp_htab
->find_slot (&elt
, INSERT
);
594 elt_p
= XNEW (elt_t
);
596 elt_p
->temp
= ret
= create_tmp_from_val (val
);
609 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
612 internal_get_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
613 bool is_formal
, bool allow_ssa
)
617 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
618 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
619 gimplify_expr (&val
, pre_p
, post_p
, is_gimple_reg_rhs_or_call
,
623 && gimplify_ctxp
->into_ssa
624 && is_gimple_reg_type (TREE_TYPE (val
)))
626 t
= make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val
)));
627 if (! gimple_in_ssa_p (cfun
))
629 const char *name
= get_name (val
);
631 SET_SSA_NAME_VAR_OR_IDENTIFIER (t
, create_tmp_var_name (name
));
635 t
= lookup_tmp_var (val
, is_formal
);
637 mod
= build2 (INIT_EXPR
, TREE_TYPE (t
), t
, unshare_expr (val
));
639 SET_EXPR_LOCATION (mod
, EXPR_LOC_OR_LOC (val
, input_location
));
641 /* gimplify_modify_expr might want to reduce this further. */
642 gimplify_and_add (mod
, pre_p
);
648 /* Return a formal temporary variable initialized with VAL. PRE_P is as
649 in gimplify_expr. Only use this function if:
651 1) The value of the unfactored expression represented by VAL will not
652 change between the initialization and use of the temporary, and
653 2) The temporary will not be otherwise modified.
655 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
656 and #2 means it is inappropriate for && temps.
658 For other cases, use get_initialized_tmp_var instead. */
661 get_formal_tmp_var (tree val
, gimple_seq
*pre_p
)
663 return internal_get_tmp_var (val
, pre_p
, NULL
, true, true);
666 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
667 are as in gimplify_expr. */
670 get_initialized_tmp_var (tree val
, gimple_seq
*pre_p
,
671 gimple_seq
*post_p
/* = NULL */,
672 bool allow_ssa
/* = true */)
674 return internal_get_tmp_var (val
, pre_p
, post_p
, false, allow_ssa
);
677 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
678 generate debug info for them; otherwise don't. */
681 declare_vars (tree vars
, gimple
*gs
, bool debug_info
)
688 gbind
*scope
= as_a
<gbind
*> (gs
);
690 temps
= nreverse (last
);
692 block
= gimple_bind_block (scope
);
693 gcc_assert (!block
|| TREE_CODE (block
) == BLOCK
);
694 if (!block
|| !debug_info
)
696 DECL_CHAIN (last
) = gimple_bind_vars (scope
);
697 gimple_bind_set_vars (scope
, temps
);
701 /* We need to attach the nodes both to the BIND_EXPR and to its
702 associated BLOCK for debugging purposes. The key point here
703 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
704 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
705 if (BLOCK_VARS (block
))
706 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), temps
);
709 gimple_bind_set_vars (scope
,
710 chainon (gimple_bind_vars (scope
), temps
));
711 BLOCK_VARS (block
) = temps
;
717 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
718 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
719 no such upper bound can be obtained. */
722 force_constant_size (tree var
)
724 /* The only attempt we make is by querying the maximum size of objects
725 of the variable's type. */
727 HOST_WIDE_INT max_size
;
729 gcc_assert (VAR_P (var
));
731 max_size
= max_int_size_in_bytes (TREE_TYPE (var
));
733 gcc_assert (max_size
>= 0);
736 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var
)), max_size
);
738 = build_int_cst (TREE_TYPE (DECL_SIZE (var
)), max_size
* BITS_PER_UNIT
);
741 /* Push the temporary variable TMP into the current binding. */
744 gimple_add_tmp_var_fn (struct function
*fn
, tree tmp
)
746 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
748 /* Later processing assumes that the object size is constant, which might
749 not be true at this point. Force the use of a constant upper bound in
751 if (!tree_fits_poly_uint64_p (DECL_SIZE_UNIT (tmp
)))
752 force_constant_size (tmp
);
754 DECL_CONTEXT (tmp
) = fn
->decl
;
755 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
757 record_vars_into (tmp
, fn
->decl
);
760 /* Push the temporary variable TMP into the current binding. */
763 gimple_add_tmp_var (tree tmp
)
765 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
767 /* Later processing assumes that the object size is constant, which might
768 not be true at this point. Force the use of a constant upper bound in
770 if (!tree_fits_poly_uint64_p (DECL_SIZE_UNIT (tmp
)))
771 force_constant_size (tmp
);
773 DECL_CONTEXT (tmp
) = current_function_decl
;
774 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
778 DECL_CHAIN (tmp
) = gimplify_ctxp
->temps
;
779 gimplify_ctxp
->temps
= tmp
;
781 /* Mark temporaries local within the nearest enclosing parallel. */
782 if (gimplify_omp_ctxp
)
784 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
785 int flag
= GOVD_LOCAL
;
787 && (ctx
->region_type
== ORT_WORKSHARE
788 || ctx
->region_type
== ORT_TASKGROUP
789 || ctx
->region_type
== ORT_SIMD
790 || ctx
->region_type
== ORT_ACC
))
792 if (ctx
->region_type
== ORT_SIMD
793 && TREE_ADDRESSABLE (tmp
)
794 && !TREE_STATIC (tmp
))
796 if (TREE_CODE (DECL_SIZE_UNIT (tmp
)) != INTEGER_CST
)
797 ctx
->add_safelen1
= true;
802 ctx
= ctx
->outer_context
;
805 omp_add_variable (ctx
, tmp
, flag
| GOVD_SEEN
);
814 /* This case is for nested functions. We need to expose the locals
816 body_seq
= gimple_body (current_function_decl
);
817 declare_vars (tmp
, gimple_seq_first_stmt (body_seq
), false);
823 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
824 nodes that are referenced more than once in GENERIC functions. This is
825 necessary because gimplification (translation into GIMPLE) is performed
826 by modifying tree nodes in-place, so gimplication of a shared node in a
827 first context could generate an invalid GIMPLE form in a second context.
829 This is achieved with a simple mark/copy/unmark algorithm that walks the
830 GENERIC representation top-down, marks nodes with TREE_VISITED the first
831 time it encounters them, duplicates them if they already have TREE_VISITED
832 set, and finally removes the TREE_VISITED marks it has set.
834 The algorithm works only at the function level, i.e. it generates a GENERIC
835 representation of a function with no nodes shared within the function when
836 passed a GENERIC function (except for nodes that are allowed to be shared).
838 At the global level, it is also necessary to unshare tree nodes that are
839 referenced in more than one function, for the same aforementioned reason.
840 This requires some cooperation from the front-end. There are 2 strategies:
842 1. Manual unsharing. The front-end needs to call unshare_expr on every
843 expression that might end up being shared across functions.
845 2. Deep unsharing. This is an extension of regular unsharing. Instead
846 of calling unshare_expr on expressions that might be shared across
847 functions, the front-end pre-marks them with TREE_VISITED. This will
848 ensure that they are unshared on the first reference within functions
849 when the regular unsharing algorithm runs. The counterpart is that
850 this algorithm must look deeper than for manual unsharing, which is
851 specified by LANG_HOOKS_DEEP_UNSHARING.
853 If there are only few specific cases of node sharing across functions, it is
854 probably easier for a front-end to unshare the expressions manually. On the
855 contrary, if the expressions generated at the global level are as widespread
856 as expressions generated within functions, deep unsharing is very likely the
859 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
860 These nodes model computations that must be done once. If we were to
861 unshare something like SAVE_EXPR(i++), the gimplification process would
862 create wrong code. However, if DATA is non-null, it must hold a pointer
863 set that is used to unshare the subtrees of these nodes. */
866 mostly_copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
869 enum tree_code code
= TREE_CODE (t
);
871 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
872 copy their subtrees if we can make sure to do it only once. */
873 if (code
== SAVE_EXPR
|| code
== TARGET_EXPR
|| code
== BIND_EXPR
)
875 if (data
&& !((hash_set
<tree
> *)data
)->add (t
))
881 /* Stop at types, decls, constants like copy_tree_r. */
882 else if (TREE_CODE_CLASS (code
) == tcc_type
883 || TREE_CODE_CLASS (code
) == tcc_declaration
884 || TREE_CODE_CLASS (code
) == tcc_constant
)
887 /* Cope with the statement expression extension. */
888 else if (code
== STATEMENT_LIST
)
891 /* Leave the bulk of the work to copy_tree_r itself. */
893 copy_tree_r (tp
, walk_subtrees
, NULL
);
898 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
899 If *TP has been visited already, then *TP is deeply copied by calling
900 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
903 copy_if_shared_r (tree
*tp
, int *walk_subtrees
, void *data
)
906 enum tree_code code
= TREE_CODE (t
);
908 /* Skip types, decls, and constants. But we do want to look at their
909 types and the bounds of types. Mark them as visited so we properly
910 unmark their subtrees on the unmark pass. If we've already seen them,
911 don't look down further. */
912 if (TREE_CODE_CLASS (code
) == tcc_type
913 || TREE_CODE_CLASS (code
) == tcc_declaration
914 || TREE_CODE_CLASS (code
) == tcc_constant
)
916 if (TREE_VISITED (t
))
919 TREE_VISITED (t
) = 1;
922 /* If this node has been visited already, unshare it and don't look
924 else if (TREE_VISITED (t
))
926 walk_tree (tp
, mostly_copy_tree_r
, data
, NULL
);
930 /* Otherwise, mark the node as visited and keep looking. */
932 TREE_VISITED (t
) = 1;
937 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
938 copy_if_shared_r callback unmodified. */
941 copy_if_shared (tree
*tp
, void *data
)
943 walk_tree (tp
, copy_if_shared_r
, data
, NULL
);
946 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
947 any nested functions. */
950 unshare_body (tree fndecl
)
952 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
953 /* If the language requires deep unsharing, we need a pointer set to make
954 sure we don't repeatedly unshare subtrees of unshareable nodes. */
955 hash_set
<tree
> *visited
956 = lang_hooks
.deep_unsharing
? new hash_set
<tree
> : NULL
;
958 copy_if_shared (&DECL_SAVED_TREE (fndecl
), visited
);
959 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl
)), visited
);
960 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)), visited
);
965 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
966 unshare_body (cgn
->decl
);
969 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
970 Subtrees are walked until the first unvisited node is encountered. */
973 unmark_visited_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
977 /* If this node has been visited, unmark it and keep looking. */
978 if (TREE_VISITED (t
))
979 TREE_VISITED (t
) = 0;
981 /* Otherwise, don't look any deeper. */
988 /* Unmark the visited trees rooted at *TP. */
991 unmark_visited (tree
*tp
)
993 walk_tree (tp
, unmark_visited_r
, NULL
, NULL
);
996 /* Likewise, but mark all trees as not visited. */
999 unvisit_body (tree fndecl
)
1001 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
1003 unmark_visited (&DECL_SAVED_TREE (fndecl
));
1004 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl
)));
1005 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)));
1008 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
1009 unvisit_body (cgn
->decl
);
1012 /* Unconditionally make an unshared copy of EXPR. This is used when using
1013 stored expressions which span multiple functions, such as BINFO_VTABLE,
1014 as the normal unsharing process can't tell that they're shared. */
1017 unshare_expr (tree expr
)
1019 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
1023 /* Worker for unshare_expr_without_location. */
1026 prune_expr_location (tree
*tp
, int *walk_subtrees
, void *)
1029 SET_EXPR_LOCATION (*tp
, UNKNOWN_LOCATION
);
1035 /* Similar to unshare_expr but also prune all expression locations
1039 unshare_expr_without_location (tree expr
)
1041 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
1043 walk_tree (&expr
, prune_expr_location
, NULL
, NULL
);
1047 /* Return the EXPR_LOCATION of EXPR, if it (maybe recursively) has
1048 one, OR_ELSE otherwise. The location of a STATEMENT_LISTs
1049 comprising at least one DEBUG_BEGIN_STMT followed by exactly one
1050 EXPR is the location of the EXPR. */
1053 rexpr_location (tree expr
, location_t or_else
= UNKNOWN_LOCATION
)
1058 if (EXPR_HAS_LOCATION (expr
))
1059 return EXPR_LOCATION (expr
);
1061 if (TREE_CODE (expr
) != STATEMENT_LIST
)
1064 tree_stmt_iterator i
= tsi_start (expr
);
1067 while (!tsi_end_p (i
) && TREE_CODE (tsi_stmt (i
)) == DEBUG_BEGIN_STMT
)
1073 if (!found
|| !tsi_one_before_end_p (i
))
1076 return rexpr_location (tsi_stmt (i
), or_else
);
1079 /* Return TRUE iff EXPR (maybe recursively) has a location; see
1080 rexpr_location for the potential recursion. */
1083 rexpr_has_location (tree expr
)
1085 return rexpr_location (expr
) != UNKNOWN_LOCATION
;
1089 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1090 contain statements and have a value. Assign its value to a temporary
1091 and give it void_type_node. Return the temporary, or NULL_TREE if
1092 WRAPPER was already void. */
1095 voidify_wrapper_expr (tree wrapper
, tree temp
)
1097 tree type
= TREE_TYPE (wrapper
);
1098 if (type
&& !VOID_TYPE_P (type
))
1102 /* Set p to point to the body of the wrapper. Loop until we find
1103 something that isn't a wrapper. */
1104 for (p
= &wrapper
; p
&& *p
; )
1106 switch (TREE_CODE (*p
))
1109 TREE_SIDE_EFFECTS (*p
) = 1;
1110 TREE_TYPE (*p
) = void_type_node
;
1111 /* For a BIND_EXPR, the body is operand 1. */
1112 p
= &BIND_EXPR_BODY (*p
);
1115 case CLEANUP_POINT_EXPR
:
1116 case TRY_FINALLY_EXPR
:
1117 case TRY_CATCH_EXPR
:
1118 TREE_SIDE_EFFECTS (*p
) = 1;
1119 TREE_TYPE (*p
) = void_type_node
;
1120 p
= &TREE_OPERAND (*p
, 0);
1123 case STATEMENT_LIST
:
1125 tree_stmt_iterator i
= tsi_last (*p
);
1126 TREE_SIDE_EFFECTS (*p
) = 1;
1127 TREE_TYPE (*p
) = void_type_node
;
1128 p
= tsi_end_p (i
) ? NULL
: tsi_stmt_ptr (i
);
1133 /* Advance to the last statement. Set all container types to
1135 for (; TREE_CODE (*p
) == COMPOUND_EXPR
; p
= &TREE_OPERAND (*p
, 1))
1137 TREE_SIDE_EFFECTS (*p
) = 1;
1138 TREE_TYPE (*p
) = void_type_node
;
1142 case TRANSACTION_EXPR
:
1143 TREE_SIDE_EFFECTS (*p
) = 1;
1144 TREE_TYPE (*p
) = void_type_node
;
1145 p
= &TRANSACTION_EXPR_BODY (*p
);
1149 /* Assume that any tree upon which voidify_wrapper_expr is
1150 directly called is a wrapper, and that its body is op0. */
1153 TREE_SIDE_EFFECTS (*p
) = 1;
1154 TREE_TYPE (*p
) = void_type_node
;
1155 p
= &TREE_OPERAND (*p
, 0);
1163 if (p
== NULL
|| IS_EMPTY_STMT (*p
))
1167 /* The wrapper is on the RHS of an assignment that we're pushing
1169 gcc_assert (TREE_CODE (temp
) == INIT_EXPR
1170 || TREE_CODE (temp
) == MODIFY_EXPR
);
1171 TREE_OPERAND (temp
, 1) = *p
;
1176 temp
= create_tmp_var (type
, "retval");
1177 *p
= build2 (INIT_EXPR
, type
, temp
, *p
);
1186 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1187 a temporary through which they communicate. */
1190 build_stack_save_restore (gcall
**save
, gcall
**restore
)
1194 *save
= gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE
), 0);
1195 tmp_var
= create_tmp_var (ptr_type_node
, "saved_stack");
1196 gimple_call_set_lhs (*save
, tmp_var
);
1199 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE
),
1203 /* Generate IFN_ASAN_MARK call that poisons shadow of a for DECL variable. */
1206 build_asan_poison_call_expr (tree decl
)
1208 /* Do not poison variables that have size equal to zero. */
1209 tree unit_size
= DECL_SIZE_UNIT (decl
);
1210 if (zerop (unit_size
))
1213 tree base
= build_fold_addr_expr (decl
);
1215 return build_call_expr_internal_loc (UNKNOWN_LOCATION
, IFN_ASAN_MARK
,
1217 build_int_cst (integer_type_node
,
1222 /* Generate IFN_ASAN_MARK call that would poison or unpoison, depending
1223 on POISON flag, shadow memory of a DECL variable. The call will be
1224 put on location identified by IT iterator, where BEFORE flag drives
1225 position where the stmt will be put. */
1228 asan_poison_variable (tree decl
, bool poison
, gimple_stmt_iterator
*it
,
1231 tree unit_size
= DECL_SIZE_UNIT (decl
);
1232 tree base
= build_fold_addr_expr (decl
);
1234 /* Do not poison variables that have size equal to zero. */
1235 if (zerop (unit_size
))
1238 /* It's necessary to have all stack variables aligned to ASAN granularity
1240 if (DECL_ALIGN_UNIT (decl
) <= ASAN_SHADOW_GRANULARITY
)
1241 SET_DECL_ALIGN (decl
, BITS_PER_UNIT
* ASAN_SHADOW_GRANULARITY
);
1243 HOST_WIDE_INT flags
= poison
? ASAN_MARK_POISON
: ASAN_MARK_UNPOISON
;
1246 = gimple_build_call_internal (IFN_ASAN_MARK
, 3,
1247 build_int_cst (integer_type_node
, flags
),
1251 gsi_insert_before (it
, g
, GSI_NEW_STMT
);
1253 gsi_insert_after (it
, g
, GSI_NEW_STMT
);
1256 /* Generate IFN_ASAN_MARK internal call that depending on POISON flag
1257 either poisons or unpoisons a DECL. Created statement is appended
1258 to SEQ_P gimple sequence. */
1261 asan_poison_variable (tree decl
, bool poison
, gimple_seq
*seq_p
)
1263 gimple_stmt_iterator it
= gsi_last (*seq_p
);
1264 bool before
= false;
1269 asan_poison_variable (decl
, poison
, &it
, before
);
1272 /* Sort pair of VAR_DECLs A and B by DECL_UID. */
1275 sort_by_decl_uid (const void *a
, const void *b
)
1277 const tree
*t1
= (const tree
*)a
;
1278 const tree
*t2
= (const tree
*)b
;
1280 int uid1
= DECL_UID (*t1
);
1281 int uid2
= DECL_UID (*t2
);
1285 else if (uid1
> uid2
)
1291 /* Generate IFN_ASAN_MARK internal call for all VARIABLES
1292 depending on POISON flag. Created statement is appended
1293 to SEQ_P gimple sequence. */
1296 asan_poison_variables (hash_set
<tree
> *variables
, bool poison
, gimple_seq
*seq_p
)
1298 unsigned c
= variables
->elements ();
1302 auto_vec
<tree
> sorted_variables (c
);
1304 for (hash_set
<tree
>::iterator it
= variables
->begin ();
1305 it
!= variables
->end (); ++it
)
1306 sorted_variables
.safe_push (*it
);
1308 sorted_variables
.qsort (sort_by_decl_uid
);
1312 FOR_EACH_VEC_ELT (sorted_variables
, i
, var
)
1314 asan_poison_variable (var
, poison
, seq_p
);
1316 /* Add use_after_scope_memory attribute for the variable in order
1317 to prevent re-written into SSA. */
1318 if (!lookup_attribute (ASAN_USE_AFTER_SCOPE_ATTRIBUTE
,
1319 DECL_ATTRIBUTES (var
)))
1320 DECL_ATTRIBUTES (var
)
1321 = tree_cons (get_identifier (ASAN_USE_AFTER_SCOPE_ATTRIBUTE
),
1323 DECL_ATTRIBUTES (var
));
1327 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1329 static enum gimplify_status
1330 gimplify_bind_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1332 tree bind_expr
= *expr_p
;
1333 bool old_keep_stack
= gimplify_ctxp
->keep_stack
;
1334 bool old_save_stack
= gimplify_ctxp
->save_stack
;
1337 gimple_seq body
, cleanup
;
1339 location_t start_locus
= 0, end_locus
= 0;
1340 tree ret_clauses
= NULL
;
1342 tree temp
= voidify_wrapper_expr (bind_expr
, NULL
);
1344 /* Mark variables seen in this bind expr. */
1345 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1349 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1351 /* Mark variable as local. */
1352 if (ctx
&& ctx
->region_type
!= ORT_NONE
&& !DECL_EXTERNAL (t
))
1354 if (! DECL_SEEN_IN_BIND_EXPR_P (t
)
1355 || splay_tree_lookup (ctx
->variables
,
1356 (splay_tree_key
) t
) == NULL
)
1358 int flag
= GOVD_LOCAL
;
1359 if (ctx
->region_type
== ORT_SIMD
1360 && TREE_ADDRESSABLE (t
)
1361 && !TREE_STATIC (t
))
1363 if (TREE_CODE (DECL_SIZE_UNIT (t
)) != INTEGER_CST
)
1364 ctx
->add_safelen1
= true;
1366 flag
= GOVD_PRIVATE
;
1368 omp_add_variable (ctx
, t
, flag
| GOVD_SEEN
);
1370 /* Static locals inside of target construct or offloaded
1371 routines need to be "omp declare target". */
1372 if (TREE_STATIC (t
))
1373 for (; ctx
; ctx
= ctx
->outer_context
)
1374 if ((ctx
->region_type
& ORT_TARGET
) != 0)
1376 if (!lookup_attribute ("omp declare target",
1377 DECL_ATTRIBUTES (t
)))
1379 tree id
= get_identifier ("omp declare target");
1381 = tree_cons (id
, NULL_TREE
, DECL_ATTRIBUTES (t
));
1382 varpool_node
*node
= varpool_node::get (t
);
1385 node
->offloadable
= 1;
1386 if (ENABLE_OFFLOADING
&& !DECL_EXTERNAL (t
))
1388 g
->have_offload
= true;
1390 vec_safe_push (offload_vars
, t
);
1398 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
1400 if (DECL_HARD_REGISTER (t
) && !is_global_var (t
) && cfun
)
1401 cfun
->has_local_explicit_reg_vars
= true;
1404 /* Preliminarily mark non-addressed complex variables as eligible
1405 for promotion to gimple registers. We'll transform their uses
1407 if ((TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
1408 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1409 && !TREE_THIS_VOLATILE (t
)
1410 && (VAR_P (t
) && !DECL_HARD_REGISTER (t
))
1411 && !needs_to_live_in_memory (t
))
1412 DECL_GIMPLE_REG_P (t
) = 1;
1415 bind_stmt
= gimple_build_bind (BIND_EXPR_VARS (bind_expr
), NULL
,
1416 BIND_EXPR_BLOCK (bind_expr
));
1417 gimple_push_bind_expr (bind_stmt
);
1419 gimplify_ctxp
->keep_stack
= false;
1420 gimplify_ctxp
->save_stack
= false;
1422 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1424 gimplify_stmt (&BIND_EXPR_BODY (bind_expr
), &body
);
1425 gimple_bind_set_body (bind_stmt
, body
);
1427 /* Source location wise, the cleanup code (stack_restore and clobbers)
1428 belongs to the end of the block, so propagate what we have. The
1429 stack_save operation belongs to the beginning of block, which we can
1430 infer from the bind_expr directly if the block has no explicit
1432 if (BIND_EXPR_BLOCK (bind_expr
))
1434 end_locus
= BLOCK_SOURCE_END_LOCATION (BIND_EXPR_BLOCK (bind_expr
));
1435 start_locus
= BLOCK_SOURCE_LOCATION (BIND_EXPR_BLOCK (bind_expr
));
1437 if (start_locus
== 0)
1438 start_locus
= EXPR_LOCATION (bind_expr
);
1443 /* If the code both contains VLAs and calls alloca, then we cannot reclaim
1444 the stack space allocated to the VLAs. */
1445 if (gimplify_ctxp
->save_stack
&& !gimplify_ctxp
->keep_stack
)
1447 gcall
*stack_restore
;
1449 /* Save stack on entry and restore it on exit. Add a try_finally
1450 block to achieve this. */
1451 build_stack_save_restore (&stack_save
, &stack_restore
);
1453 gimple_set_location (stack_save
, start_locus
);
1454 gimple_set_location (stack_restore
, end_locus
);
1456 gimplify_seq_add_stmt (&cleanup
, stack_restore
);
1459 /* Add clobbers for all variables that go out of scope. */
1460 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1463 && !is_global_var (t
)
1464 && DECL_CONTEXT (t
) == current_function_decl
)
1466 if (!DECL_HARD_REGISTER (t
)
1467 && !TREE_THIS_VOLATILE (t
)
1468 && !DECL_HAS_VALUE_EXPR_P (t
)
1469 /* Only care for variables that have to be in memory. Others
1470 will be rewritten into SSA names, hence moved to the
1472 && !is_gimple_reg (t
)
1473 && flag_stack_reuse
!= SR_NONE
)
1475 tree clobber
= build_clobber (TREE_TYPE (t
));
1476 gimple
*clobber_stmt
;
1477 clobber_stmt
= gimple_build_assign (t
, clobber
);
1478 gimple_set_location (clobber_stmt
, end_locus
);
1479 gimplify_seq_add_stmt (&cleanup
, clobber_stmt
);
1482 if (flag_openacc
&& oacc_declare_returns
!= NULL
)
1484 tree
*c
= oacc_declare_returns
->get (t
);
1488 OMP_CLAUSE_CHAIN (*c
) = ret_clauses
;
1492 oacc_declare_returns
->remove (t
);
1494 if (oacc_declare_returns
->is_empty ())
1496 delete oacc_declare_returns
;
1497 oacc_declare_returns
= NULL
;
1503 if (asan_poisoned_variables
!= NULL
1504 && asan_poisoned_variables
->contains (t
))
1506 asan_poisoned_variables
->remove (t
);
1507 asan_poison_variable (t
, true, &cleanup
);
1510 if (gimplify_ctxp
->live_switch_vars
!= NULL
1511 && gimplify_ctxp
->live_switch_vars
->contains (t
))
1512 gimplify_ctxp
->live_switch_vars
->remove (t
);
1518 gimple_stmt_iterator si
= gsi_start (cleanup
);
1520 stmt
= gimple_build_omp_target (NULL
, GF_OMP_TARGET_KIND_OACC_DECLARE
,
1522 gsi_insert_seq_before_without_update (&si
, stmt
, GSI_NEW_STMT
);
1528 gimple_seq new_body
;
1531 gs
= gimple_build_try (gimple_bind_body (bind_stmt
), cleanup
,
1532 GIMPLE_TRY_FINALLY
);
1535 gimplify_seq_add_stmt (&new_body
, stack_save
);
1536 gimplify_seq_add_stmt (&new_body
, gs
);
1537 gimple_bind_set_body (bind_stmt
, new_body
);
1540 /* keep_stack propagates all the way up to the outermost BIND_EXPR. */
1541 if (!gimplify_ctxp
->keep_stack
)
1542 gimplify_ctxp
->keep_stack
= old_keep_stack
;
1543 gimplify_ctxp
->save_stack
= old_save_stack
;
1545 gimple_pop_bind_expr ();
1547 gimplify_seq_add_stmt (pre_p
, bind_stmt
);
1555 *expr_p
= NULL_TREE
;
1559 /* Maybe add early return predict statement to PRE_P sequence. */
1562 maybe_add_early_return_predict_stmt (gimple_seq
*pre_p
)
1564 /* If we are not in a conditional context, add PREDICT statement. */
1565 if (gimple_conditional_context ())
1567 gimple
*predict
= gimple_build_predict (PRED_TREE_EARLY_RETURN
,
1569 gimplify_seq_add_stmt (pre_p
, predict
);
1573 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1574 GIMPLE value, it is assigned to a new temporary and the statement is
1575 re-written to return the temporary.
1577 PRE_P points to the sequence where side effects that must happen before
1578 STMT should be stored. */
1580 static enum gimplify_status
1581 gimplify_return_expr (tree stmt
, gimple_seq
*pre_p
)
1584 tree ret_expr
= TREE_OPERAND (stmt
, 0);
1585 tree result_decl
, result
;
1587 if (ret_expr
== error_mark_node
)
1591 || TREE_CODE (ret_expr
) == RESULT_DECL
)
1593 maybe_add_early_return_predict_stmt (pre_p
);
1594 greturn
*ret
= gimple_build_return (ret_expr
);
1595 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1596 gimplify_seq_add_stmt (pre_p
, ret
);
1600 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1601 result_decl
= NULL_TREE
;
1602 else if (TREE_CODE (ret_expr
) == COMPOUND_EXPR
)
1604 /* Used in C++ for handling EH cleanup of the return value if a local
1605 cleanup throws. Assume the front-end knows what it's doing. */
1606 result_decl
= DECL_RESULT (current_function_decl
);
1607 /* But crash if we end up trying to modify ret_expr below. */
1608 ret_expr
= NULL_TREE
;
1612 result_decl
= TREE_OPERAND (ret_expr
, 0);
1614 /* See through a return by reference. */
1615 if (TREE_CODE (result_decl
) == INDIRECT_REF
)
1616 result_decl
= TREE_OPERAND (result_decl
, 0);
1618 gcc_assert ((TREE_CODE (ret_expr
) == MODIFY_EXPR
1619 || TREE_CODE (ret_expr
) == INIT_EXPR
)
1620 && TREE_CODE (result_decl
) == RESULT_DECL
);
1623 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1624 Recall that aggregate_value_p is FALSE for any aggregate type that is
1625 returned in registers. If we're returning values in registers, then
1626 we don't want to extend the lifetime of the RESULT_DECL, particularly
1627 across another call. In addition, for those aggregates for which
1628 hard_function_value generates a PARALLEL, we'll die during normal
1629 expansion of structure assignments; there's special code in expand_return
1630 to handle this case that does not exist in expand_expr. */
1633 else if (aggregate_value_p (result_decl
, TREE_TYPE (current_function_decl
)))
1635 if (!poly_int_tree_p (DECL_SIZE (result_decl
)))
1637 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl
)))
1638 gimplify_type_sizes (TREE_TYPE (result_decl
), pre_p
);
1639 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1640 should be effectively allocated by the caller, i.e. all calls to
1641 this function must be subject to the Return Slot Optimization. */
1642 gimplify_one_sizepos (&DECL_SIZE (result_decl
), pre_p
);
1643 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl
), pre_p
);
1645 result
= result_decl
;
1647 else if (gimplify_ctxp
->return_temp
)
1648 result
= gimplify_ctxp
->return_temp
;
1651 result
= create_tmp_reg (TREE_TYPE (result_decl
));
1653 /* ??? With complex control flow (usually involving abnormal edges),
1654 we can wind up warning about an uninitialized value for this. Due
1655 to how this variable is constructed and initialized, this is never
1656 true. Give up and never warn. */
1657 TREE_NO_WARNING (result
) = 1;
1659 gimplify_ctxp
->return_temp
= result
;
1662 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1663 Then gimplify the whole thing. */
1664 if (result
!= result_decl
)
1665 TREE_OPERAND (ret_expr
, 0) = result
;
1667 gimplify_and_add (TREE_OPERAND (stmt
, 0), pre_p
);
1669 maybe_add_early_return_predict_stmt (pre_p
);
1670 ret
= gimple_build_return (result
);
1671 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1672 gimplify_seq_add_stmt (pre_p
, ret
);
1677 /* Gimplify a variable-length array DECL. */
1680 gimplify_vla_decl (tree decl
, gimple_seq
*seq_p
)
1682 /* This is a variable-sized decl. Simplify its size and mark it
1683 for deferred expansion. */
1684 tree t
, addr
, ptr_type
;
1686 gimplify_one_sizepos (&DECL_SIZE (decl
), seq_p
);
1687 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl
), seq_p
);
1689 /* Don't mess with a DECL_VALUE_EXPR set by the front-end. */
1690 if (DECL_HAS_VALUE_EXPR_P (decl
))
1693 /* All occurrences of this decl in final gimplified code will be
1694 replaced by indirection. Setting DECL_VALUE_EXPR does two
1695 things: First, it lets the rest of the gimplifier know what
1696 replacement to use. Second, it lets the debug info know
1697 where to find the value. */
1698 ptr_type
= build_pointer_type (TREE_TYPE (decl
));
1699 addr
= create_tmp_var (ptr_type
, get_name (decl
));
1700 DECL_IGNORED_P (addr
) = 0;
1701 t
= build_fold_indirect_ref (addr
);
1702 TREE_THIS_NOTRAP (t
) = 1;
1703 SET_DECL_VALUE_EXPR (decl
, t
);
1704 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1706 t
= build_alloca_call_expr (DECL_SIZE_UNIT (decl
), DECL_ALIGN (decl
),
1707 max_int_size_in_bytes (TREE_TYPE (decl
)));
1708 /* The call has been built for a variable-sized object. */
1709 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
1710 t
= fold_convert (ptr_type
, t
);
1711 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
1713 gimplify_and_add (t
, seq_p
);
1715 /* Record the dynamic allocation associated with DECL if requested. */
1716 if (flag_callgraph_info
& CALLGRAPH_INFO_DYNAMIC_ALLOC
)
1717 record_dynamic_alloc (decl
);
1720 /* A helper function to be called via walk_tree. Mark all labels under *TP
1721 as being forced. To be called for DECL_INITIAL of static variables. */
1724 force_labels_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1728 if (TREE_CODE (*tp
) == LABEL_DECL
)
1730 FORCED_LABEL (*tp
) = 1;
1731 cfun
->has_forced_label_in_static
= 1;
1737 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1738 and initialization explicit. */
1740 static enum gimplify_status
1741 gimplify_decl_expr (tree
*stmt_p
, gimple_seq
*seq_p
)
1743 tree stmt
= *stmt_p
;
1744 tree decl
= DECL_EXPR_DECL (stmt
);
1746 *stmt_p
= NULL_TREE
;
1748 if (TREE_TYPE (decl
) == error_mark_node
)
1751 if ((TREE_CODE (decl
) == TYPE_DECL
1753 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl
)))
1755 gimplify_type_sizes (TREE_TYPE (decl
), seq_p
);
1756 if (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
)
1757 gimplify_type_sizes (TREE_TYPE (TREE_TYPE (decl
)), seq_p
);
1760 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1761 in case its size expressions contain problematic nodes like CALL_EXPR. */
1762 if (TREE_CODE (decl
) == TYPE_DECL
1763 && DECL_ORIGINAL_TYPE (decl
)
1764 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl
)))
1766 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl
), seq_p
);
1767 if (TREE_CODE (DECL_ORIGINAL_TYPE (decl
)) == REFERENCE_TYPE
)
1768 gimplify_type_sizes (TREE_TYPE (DECL_ORIGINAL_TYPE (decl
)), seq_p
);
1771 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
1773 tree init
= DECL_INITIAL (decl
);
1774 bool is_vla
= false;
1777 if (!poly_int_tree_p (DECL_SIZE_UNIT (decl
), &size
)
1778 || (!TREE_STATIC (decl
)
1779 && flag_stack_check
== GENERIC_STACK_CHECK
1781 (unsigned HOST_WIDE_INT
) STACK_CHECK_MAX_VAR_SIZE
)))
1783 gimplify_vla_decl (decl
, seq_p
);
1787 if (asan_poisoned_variables
1789 && TREE_ADDRESSABLE (decl
)
1790 && !TREE_STATIC (decl
)
1791 && !DECL_HAS_VALUE_EXPR_P (decl
)
1792 && DECL_ALIGN (decl
) <= MAX_SUPPORTED_STACK_ALIGNMENT
1793 && dbg_cnt (asan_use_after_scope
)
1794 && !gimplify_omp_ctxp
)
1796 asan_poisoned_variables
->add (decl
);
1797 asan_poison_variable (decl
, false, seq_p
);
1798 if (!DECL_ARTIFICIAL (decl
) && gimplify_ctxp
->live_switch_vars
)
1799 gimplify_ctxp
->live_switch_vars
->add (decl
);
1802 /* Some front ends do not explicitly declare all anonymous
1803 artificial variables. We compensate here by declaring the
1804 variables, though it would be better if the front ends would
1805 explicitly declare them. */
1806 if (!DECL_SEEN_IN_BIND_EXPR_P (decl
)
1807 && DECL_ARTIFICIAL (decl
) && DECL_NAME (decl
) == NULL_TREE
)
1808 gimple_add_tmp_var (decl
);
1810 if (init
&& init
!= error_mark_node
)
1812 if (!TREE_STATIC (decl
))
1814 DECL_INITIAL (decl
) = NULL_TREE
;
1815 init
= build2 (INIT_EXPR
, void_type_node
, decl
, init
);
1816 gimplify_and_add (init
, seq_p
);
1820 /* We must still examine initializers for static variables
1821 as they may contain a label address. */
1822 walk_tree (&init
, force_labels_r
, NULL
, NULL
);
1829 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1830 and replacing the LOOP_EXPR with goto, but if the loop contains an
1831 EXIT_EXPR, we need to append a label for it to jump to. */
1833 static enum gimplify_status
1834 gimplify_loop_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1836 tree saved_label
= gimplify_ctxp
->exit_label
;
1837 tree start_label
= create_artificial_label (UNKNOWN_LOCATION
);
1839 gimplify_seq_add_stmt (pre_p
, gimple_build_label (start_label
));
1841 gimplify_ctxp
->exit_label
= NULL_TREE
;
1843 gimplify_and_add (LOOP_EXPR_BODY (*expr_p
), pre_p
);
1845 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (start_label
));
1847 if (gimplify_ctxp
->exit_label
)
1848 gimplify_seq_add_stmt (pre_p
,
1849 gimple_build_label (gimplify_ctxp
->exit_label
));
1851 gimplify_ctxp
->exit_label
= saved_label
;
1857 /* Gimplify a statement list onto a sequence. These may be created either
1858 by an enlightened front-end, or by shortcut_cond_expr. */
1860 static enum gimplify_status
1861 gimplify_statement_list (tree
*expr_p
, gimple_seq
*pre_p
)
1863 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
1865 tree_stmt_iterator i
= tsi_start (*expr_p
);
1867 while (!tsi_end_p (i
))
1869 gimplify_stmt (tsi_stmt_ptr (i
), pre_p
);
1882 /* Callback for walk_gimple_seq. */
1885 warn_switch_unreachable_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
1886 struct walk_stmt_info
*wi
)
1888 gimple
*stmt
= gsi_stmt (*gsi_p
);
1890 *handled_ops_p
= true;
1891 switch (gimple_code (stmt
))
1894 /* A compiler-generated cleanup or a user-written try block.
1895 If it's empty, don't dive into it--that would result in
1896 worse location info. */
1897 if (gimple_try_eval (stmt
) == NULL
)
1900 return integer_zero_node
;
1905 case GIMPLE_EH_FILTER
:
1906 case GIMPLE_TRANSACTION
:
1907 /* Walk the sub-statements. */
1908 *handled_ops_p
= false;
1912 /* Ignore these. We may generate them before declarations that
1913 are never executed. If there's something to warn about,
1914 there will be non-debug stmts too, and we'll catch those. */
1918 if (gimple_call_internal_p (stmt
, IFN_ASAN_MARK
))
1920 *handled_ops_p
= false;
1925 /* Save the first "real" statement (not a decl/lexical scope/...). */
1927 return integer_zero_node
;
1932 /* Possibly warn about unreachable statements between switch's controlling
1933 expression and the first case. SEQ is the body of a switch expression. */
1936 maybe_warn_switch_unreachable (gimple_seq seq
)
1938 if (!warn_switch_unreachable
1939 /* This warning doesn't play well with Fortran when optimizations
1941 || lang_GNU_Fortran ()
1945 struct walk_stmt_info wi
;
1946 memset (&wi
, 0, sizeof (wi
));
1947 walk_gimple_seq (seq
, warn_switch_unreachable_r
, NULL
, &wi
);
1948 gimple
*stmt
= (gimple
*) wi
.info
;
1950 if (stmt
&& gimple_code (stmt
) != GIMPLE_LABEL
)
1952 if (gimple_code (stmt
) == GIMPLE_GOTO
1953 && TREE_CODE (gimple_goto_dest (stmt
)) == LABEL_DECL
1954 && DECL_ARTIFICIAL (gimple_goto_dest (stmt
)))
1955 /* Don't warn for compiler-generated gotos. These occur
1956 in Duff's devices, for example. */;
1958 warning_at (gimple_location (stmt
), OPT_Wswitch_unreachable
,
1959 "statement will never be executed");
1964 /* A label entry that pairs label and a location. */
1971 /* Find LABEL in vector of label entries VEC. */
1973 static struct label_entry
*
1974 find_label_entry (const auto_vec
<struct label_entry
> *vec
, tree label
)
1977 struct label_entry
*l
;
1979 FOR_EACH_VEC_ELT (*vec
, i
, l
)
1980 if (l
->label
== label
)
1985 /* Return true if LABEL, a LABEL_DECL, represents a case label
1986 in a vector of labels CASES. */
1989 case_label_p (const vec
<tree
> *cases
, tree label
)
1994 FOR_EACH_VEC_ELT (*cases
, i
, l
)
1995 if (CASE_LABEL (l
) == label
)
2000 /* Find the last nondebug statement in a scope STMT. */
2003 last_stmt_in_scope (gimple
*stmt
)
2008 switch (gimple_code (stmt
))
2012 gbind
*bind
= as_a
<gbind
*> (stmt
);
2013 stmt
= gimple_seq_last_nondebug_stmt (gimple_bind_body (bind
));
2014 return last_stmt_in_scope (stmt
);
2019 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
2020 stmt
= gimple_seq_last_nondebug_stmt (gimple_try_eval (try_stmt
));
2021 gimple
*last_eval
= last_stmt_in_scope (stmt
);
2022 if (gimple_stmt_may_fallthru (last_eval
)
2023 && (last_eval
== NULL
2024 || !gimple_call_internal_p (last_eval
, IFN_FALLTHROUGH
))
2025 && gimple_try_kind (try_stmt
) == GIMPLE_TRY_FINALLY
)
2027 stmt
= gimple_seq_last_nondebug_stmt (gimple_try_cleanup (try_stmt
));
2028 return last_stmt_in_scope (stmt
);
2042 /* Collect interesting labels in LABELS and return the statement preceding
2043 another case label, or a user-defined label. Store a location useful
2044 to give warnings at *PREVLOC (usually the location of the returned
2045 statement or of its surrounding scope). */
2048 collect_fallthrough_labels (gimple_stmt_iterator
*gsi_p
,
2049 auto_vec
<struct label_entry
> *labels
,
2050 location_t
*prevloc
)
2052 gimple
*prev
= NULL
;
2054 *prevloc
= UNKNOWN_LOCATION
;
2057 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_BIND
)
2059 /* Recognize the special GIMPLE_BIND added by gimplify_switch_expr,
2060 which starts on a GIMPLE_SWITCH and ends with a break label.
2061 Handle that as a single statement that can fall through. */
2062 gbind
*bind
= as_a
<gbind
*> (gsi_stmt (*gsi_p
));
2063 gimple
*first
= gimple_seq_first_stmt (gimple_bind_body (bind
));
2064 gimple
*last
= gimple_seq_last_stmt (gimple_bind_body (bind
));
2066 && gimple_code (first
) == GIMPLE_SWITCH
2067 && gimple_code (last
) == GIMPLE_LABEL
)
2069 tree label
= gimple_label_label (as_a
<glabel
*> (last
));
2070 if (SWITCH_BREAK_LABEL_P (label
))
2078 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_BIND
2079 || gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_TRY
)
2081 /* Nested scope. Only look at the last statement of
2082 the innermost scope. */
2083 location_t bind_loc
= gimple_location (gsi_stmt (*gsi_p
));
2084 gimple
*last
= last_stmt_in_scope (gsi_stmt (*gsi_p
));
2088 /* It might be a label without a location. Use the
2089 location of the scope then. */
2090 if (!gimple_has_location (prev
))
2091 *prevloc
= bind_loc
;
2097 /* Ifs are tricky. */
2098 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_COND
)
2100 gcond
*cond_stmt
= as_a
<gcond
*> (gsi_stmt (*gsi_p
));
2101 tree false_lab
= gimple_cond_false_label (cond_stmt
);
2102 location_t if_loc
= gimple_location (cond_stmt
);
2105 if (i > 1) goto <D.2259>; else goto D;
2106 we can't do much with the else-branch. */
2107 if (!DECL_ARTIFICIAL (false_lab
))
2110 /* Go on until the false label, then one step back. */
2111 for (; !gsi_end_p (*gsi_p
); gsi_next (gsi_p
))
2113 gimple
*stmt
= gsi_stmt (*gsi_p
);
2114 if (gimple_code (stmt
) == GIMPLE_LABEL
2115 && gimple_label_label (as_a
<glabel
*> (stmt
)) == false_lab
)
2119 /* Not found? Oops. */
2120 if (gsi_end_p (*gsi_p
))
2123 struct label_entry l
= { false_lab
, if_loc
};
2124 labels
->safe_push (l
);
2126 /* Go to the last statement of the then branch. */
2129 /* if (i != 0) goto <D.1759>; else goto <D.1760>;
2135 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_GOTO
2136 && !gimple_has_location (gsi_stmt (*gsi_p
)))
2138 /* Look at the statement before, it might be
2139 attribute fallthrough, in which case don't warn. */
2141 bool fallthru_before_dest
2142 = gimple_call_internal_p (gsi_stmt (*gsi_p
), IFN_FALLTHROUGH
);
2144 tree goto_dest
= gimple_goto_dest (gsi_stmt (*gsi_p
));
2145 if (!fallthru_before_dest
)
2147 struct label_entry l
= { goto_dest
, if_loc
};
2148 labels
->safe_push (l
);
2151 /* And move back. */
2155 /* Remember the last statement. Skip labels that are of no interest
2157 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_LABEL
)
2159 tree label
= gimple_label_label (as_a
<glabel
*> (gsi_stmt (*gsi_p
)));
2160 if (find_label_entry (labels
, label
))
2161 prev
= gsi_stmt (*gsi_p
);
2163 else if (gimple_call_internal_p (gsi_stmt (*gsi_p
), IFN_ASAN_MARK
))
2165 else if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_PREDICT
)
2167 else if (!is_gimple_debug (gsi_stmt (*gsi_p
)))
2168 prev
= gsi_stmt (*gsi_p
);
2171 while (!gsi_end_p (*gsi_p
)
2172 /* Stop if we find a case or a user-defined label. */
2173 && (gimple_code (gsi_stmt (*gsi_p
)) != GIMPLE_LABEL
2174 || !gimple_has_location (gsi_stmt (*gsi_p
))));
2176 if (prev
&& gimple_has_location (prev
))
2177 *prevloc
= gimple_location (prev
);
2181 /* Return true if the switch fallthough warning should occur. LABEL is
2182 the label statement that we're falling through to. */
2185 should_warn_for_implicit_fallthrough (gimple_stmt_iterator
*gsi_p
, tree label
)
2187 gimple_stmt_iterator gsi
= *gsi_p
;
2189 /* Don't warn if the label is marked with a "falls through" comment. */
2190 if (FALLTHROUGH_LABEL_P (label
))
2193 /* Don't warn for non-case labels followed by a statement:
2198 as these are likely intentional. */
2199 if (!case_label_p (&gimplify_ctxp
->case_labels
, label
))
2202 while (!gsi_end_p (gsi
)
2203 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_LABEL
2204 && (l
= gimple_label_label (as_a
<glabel
*> (gsi_stmt (gsi
))))
2205 && !case_label_p (&gimplify_ctxp
->case_labels
, l
))
2206 gsi_next_nondebug (&gsi
);
2207 if (gsi_end_p (gsi
) || gimple_code (gsi_stmt (gsi
)) != GIMPLE_LABEL
)
2211 /* Don't warn for terminated branches, i.e. when the subsequent case labels
2212 immediately breaks. */
2215 /* Skip all immediately following labels. */
2216 while (!gsi_end_p (gsi
)
2217 && (gimple_code (gsi_stmt (gsi
)) == GIMPLE_LABEL
2218 || gimple_code (gsi_stmt (gsi
)) == GIMPLE_PREDICT
))
2219 gsi_next_nondebug (&gsi
);
2221 /* { ... something; default:; } */
2223 /* { ... something; default: break; } or
2224 { ... something; default: goto L; } */
2225 || gimple_code (gsi_stmt (gsi
)) == GIMPLE_GOTO
2226 /* { ... something; default: return; } */
2227 || gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
2233 /* Callback for walk_gimple_seq. */
2236 warn_implicit_fallthrough_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
2237 struct walk_stmt_info
*)
2239 gimple
*stmt
= gsi_stmt (*gsi_p
);
2241 *handled_ops_p
= true;
2242 switch (gimple_code (stmt
))
2247 case GIMPLE_EH_FILTER
:
2248 case GIMPLE_TRANSACTION
:
2249 /* Walk the sub-statements. */
2250 *handled_ops_p
= false;
2253 /* Find a sequence of form:
2260 and possibly warn. */
2263 /* Found a label. Skip all immediately following labels. */
2264 while (!gsi_end_p (*gsi_p
)
2265 && gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_LABEL
)
2266 gsi_next_nondebug (gsi_p
);
2268 /* There might be no more statements. */
2269 if (gsi_end_p (*gsi_p
))
2270 return integer_zero_node
;
2272 /* Vector of labels that fall through. */
2273 auto_vec
<struct label_entry
> labels
;
2275 gimple
*prev
= collect_fallthrough_labels (gsi_p
, &labels
, &prevloc
);
2277 /* There might be no more statements. */
2278 if (gsi_end_p (*gsi_p
))
2279 return integer_zero_node
;
2281 gimple
*next
= gsi_stmt (*gsi_p
);
2283 /* If what follows is a label, then we may have a fallthrough. */
2284 if (gimple_code (next
) == GIMPLE_LABEL
2285 && gimple_has_location (next
)
2286 && (label
= gimple_label_label (as_a
<glabel
*> (next
)))
2289 struct label_entry
*l
;
2290 bool warned_p
= false;
2291 auto_diagnostic_group d
;
2292 if (!should_warn_for_implicit_fallthrough (gsi_p
, label
))
2294 else if (gimple_code (prev
) == GIMPLE_LABEL
2295 && (label
= gimple_label_label (as_a
<glabel
*> (prev
)))
2296 && (l
= find_label_entry (&labels
, label
)))
2297 warned_p
= warning_at (l
->loc
, OPT_Wimplicit_fallthrough_
,
2298 "this statement may fall through");
2299 else if (!gimple_call_internal_p (prev
, IFN_FALLTHROUGH
)
2300 /* Try to be clever and don't warn when the statement
2301 can't actually fall through. */
2302 && gimple_stmt_may_fallthru (prev
)
2303 && prevloc
!= UNKNOWN_LOCATION
)
2304 warned_p
= warning_at (prevloc
,
2305 OPT_Wimplicit_fallthrough_
,
2306 "this statement may fall through");
2308 inform (gimple_location (next
), "here");
2310 /* Mark this label as processed so as to prevent multiple
2311 warnings in nested switches. */
2312 FALLTHROUGH_LABEL_P (label
) = true;
2314 /* So that next warn_implicit_fallthrough_r will start looking for
2315 a new sequence starting with this label. */
2326 /* Warn when a switch case falls through. */
2329 maybe_warn_implicit_fallthrough (gimple_seq seq
)
2331 if (!warn_implicit_fallthrough
)
2334 /* This warning is meant for C/C++/ObjC/ObjC++ only. */
2337 || lang_GNU_OBJC ()))
2340 struct walk_stmt_info wi
;
2341 memset (&wi
, 0, sizeof (wi
));
2342 walk_gimple_seq (seq
, warn_implicit_fallthrough_r
, NULL
, &wi
);
2345 /* Callback for walk_gimple_seq. */
2348 expand_FALLTHROUGH_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
2349 struct walk_stmt_info
*wi
)
2351 gimple
*stmt
= gsi_stmt (*gsi_p
);
2353 *handled_ops_p
= true;
2354 switch (gimple_code (stmt
))
2359 case GIMPLE_EH_FILTER
:
2360 case GIMPLE_TRANSACTION
:
2361 /* Walk the sub-statements. */
2362 *handled_ops_p
= false;
2365 if (gimple_call_internal_p (stmt
, IFN_FALLTHROUGH
))
2367 gsi_remove (gsi_p
, true);
2368 if (gsi_end_p (*gsi_p
))
2370 *static_cast<location_t
*>(wi
->info
) = gimple_location (stmt
);
2371 return integer_zero_node
;
2375 location_t loc
= gimple_location (stmt
);
2377 gimple_stmt_iterator gsi2
= *gsi_p
;
2378 stmt
= gsi_stmt (gsi2
);
2379 if (gimple_code (stmt
) == GIMPLE_GOTO
&& !gimple_has_location (stmt
))
2381 /* Go on until the artificial label. */
2382 tree goto_dest
= gimple_goto_dest (stmt
);
2383 for (; !gsi_end_p (gsi2
); gsi_next (&gsi2
))
2385 if (gimple_code (gsi_stmt (gsi2
)) == GIMPLE_LABEL
2386 && gimple_label_label (as_a
<glabel
*> (gsi_stmt (gsi2
)))
2391 /* Not found? Stop. */
2392 if (gsi_end_p (gsi2
))
2395 /* Look one past it. */
2399 /* We're looking for a case label or default label here. */
2400 while (!gsi_end_p (gsi2
))
2402 stmt
= gsi_stmt (gsi2
);
2403 if (gimple_code (stmt
) == GIMPLE_LABEL
)
2405 tree label
= gimple_label_label (as_a
<glabel
*> (stmt
));
2406 if (gimple_has_location (stmt
) && DECL_ARTIFICIAL (label
))
2412 else if (gimple_call_internal_p (stmt
, IFN_ASAN_MARK
))
2414 else if (!is_gimple_debug (stmt
))
2415 /* Anything else is not expected. */
2420 pedwarn (loc
, 0, "attribute %<fallthrough%> not preceding "
2421 "a case label or default label");
2430 /* Expand all FALLTHROUGH () calls in SEQ. */
2433 expand_FALLTHROUGH (gimple_seq
*seq_p
)
2435 struct walk_stmt_info wi
;
2437 memset (&wi
, 0, sizeof (wi
));
2438 wi
.info
= (void *) &loc
;
2439 walk_gimple_seq_mod (seq_p
, expand_FALLTHROUGH_r
, NULL
, &wi
);
2440 if (wi
.callback_result
== integer_zero_node
)
2441 /* We've found [[fallthrough]]; at the end of a switch, which the C++
2442 standard says is ill-formed; see [dcl.attr.fallthrough]. */
2443 pedwarn (loc
, 0, "attribute %<fallthrough%> not preceding "
2444 "a case label or default label");
2448 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
2451 static enum gimplify_status
2452 gimplify_switch_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2454 tree switch_expr
= *expr_p
;
2455 gimple_seq switch_body_seq
= NULL
;
2456 enum gimplify_status ret
;
2457 tree index_type
= TREE_TYPE (switch_expr
);
2458 if (index_type
== NULL_TREE
)
2459 index_type
= TREE_TYPE (SWITCH_COND (switch_expr
));
2461 ret
= gimplify_expr (&SWITCH_COND (switch_expr
), pre_p
, NULL
, is_gimple_val
,
2463 if (ret
== GS_ERROR
|| ret
== GS_UNHANDLED
)
2466 if (SWITCH_BODY (switch_expr
))
2469 vec
<tree
> saved_labels
;
2470 hash_set
<tree
> *saved_live_switch_vars
= NULL
;
2471 tree default_case
= NULL_TREE
;
2472 gswitch
*switch_stmt
;
2474 /* Save old labels, get new ones from body, then restore the old
2475 labels. Save all the things from the switch body to append after. */
2476 saved_labels
= gimplify_ctxp
->case_labels
;
2477 gimplify_ctxp
->case_labels
.create (8);
2479 /* Do not create live_switch_vars if SWITCH_BODY is not a BIND_EXPR. */
2480 saved_live_switch_vars
= gimplify_ctxp
->live_switch_vars
;
2481 tree_code body_type
= TREE_CODE (SWITCH_BODY (switch_expr
));
2482 if (body_type
== BIND_EXPR
|| body_type
== STATEMENT_LIST
)
2483 gimplify_ctxp
->live_switch_vars
= new hash_set
<tree
> (4);
2485 gimplify_ctxp
->live_switch_vars
= NULL
;
2487 bool old_in_switch_expr
= gimplify_ctxp
->in_switch_expr
;
2488 gimplify_ctxp
->in_switch_expr
= true;
2490 gimplify_stmt (&SWITCH_BODY (switch_expr
), &switch_body_seq
);
2492 gimplify_ctxp
->in_switch_expr
= old_in_switch_expr
;
2493 maybe_warn_switch_unreachable (switch_body_seq
);
2494 maybe_warn_implicit_fallthrough (switch_body_seq
);
2495 /* Only do this for the outermost GIMPLE_SWITCH. */
2496 if (!gimplify_ctxp
->in_switch_expr
)
2497 expand_FALLTHROUGH (&switch_body_seq
);
2499 labels
= gimplify_ctxp
->case_labels
;
2500 gimplify_ctxp
->case_labels
= saved_labels
;
2502 if (gimplify_ctxp
->live_switch_vars
)
2504 gcc_assert (gimplify_ctxp
->live_switch_vars
->is_empty ());
2505 delete gimplify_ctxp
->live_switch_vars
;
2507 gimplify_ctxp
->live_switch_vars
= saved_live_switch_vars
;
2509 preprocess_case_label_vec_for_gimple (labels
, index_type
,
2512 bool add_bind
= false;
2515 glabel
*new_default
;
2518 = build_case_label (NULL_TREE
, NULL_TREE
,
2519 create_artificial_label (UNKNOWN_LOCATION
));
2520 if (old_in_switch_expr
)
2522 SWITCH_BREAK_LABEL_P (CASE_LABEL (default_case
)) = 1;
2525 new_default
= gimple_build_label (CASE_LABEL (default_case
));
2526 gimplify_seq_add_stmt (&switch_body_seq
, new_default
);
2528 else if (old_in_switch_expr
)
2530 gimple
*last
= gimple_seq_last_stmt (switch_body_seq
);
2531 if (last
&& gimple_code (last
) == GIMPLE_LABEL
)
2533 tree label
= gimple_label_label (as_a
<glabel
*> (last
));
2534 if (SWITCH_BREAK_LABEL_P (label
))
2539 switch_stmt
= gimple_build_switch (SWITCH_COND (switch_expr
),
2540 default_case
, labels
);
2541 /* For the benefit of -Wimplicit-fallthrough, if switch_body_seq
2542 ends with a GIMPLE_LABEL holding SWITCH_BREAK_LABEL_P LABEL_DECL,
2543 wrap the GIMPLE_SWITCH up to that GIMPLE_LABEL into a GIMPLE_BIND,
2544 so that we can easily find the start and end of the switch
2548 gimple_seq bind_body
= NULL
;
2549 gimplify_seq_add_stmt (&bind_body
, switch_stmt
);
2550 gimple_seq_add_seq (&bind_body
, switch_body_seq
);
2551 gbind
*bind
= gimple_build_bind (NULL_TREE
, bind_body
, NULL_TREE
);
2552 gimple_set_location (bind
, EXPR_LOCATION (switch_expr
));
2553 gimplify_seq_add_stmt (pre_p
, bind
);
2557 gimplify_seq_add_stmt (pre_p
, switch_stmt
);
2558 gimplify_seq_add_seq (pre_p
, switch_body_seq
);
2568 /* Gimplify the LABEL_EXPR pointed to by EXPR_P. */
2570 static enum gimplify_status
2571 gimplify_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2573 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p
))
2574 == current_function_decl
);
2576 tree label
= LABEL_EXPR_LABEL (*expr_p
);
2577 glabel
*label_stmt
= gimple_build_label (label
);
2578 gimple_set_location (label_stmt
, EXPR_LOCATION (*expr_p
));
2579 gimplify_seq_add_stmt (pre_p
, label_stmt
);
2581 if (lookup_attribute ("cold", DECL_ATTRIBUTES (label
)))
2582 gimple_seq_add_stmt (pre_p
, gimple_build_predict (PRED_COLD_LABEL
,
2584 else if (lookup_attribute ("hot", DECL_ATTRIBUTES (label
)))
2585 gimple_seq_add_stmt (pre_p
, gimple_build_predict (PRED_HOT_LABEL
,
2591 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
2593 static enum gimplify_status
2594 gimplify_case_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2596 struct gimplify_ctx
*ctxp
;
2599 /* Invalid programs can play Duff's Device type games with, for example,
2600 #pragma omp parallel. At least in the C front end, we don't
2601 detect such invalid branches until after gimplification, in the
2602 diagnose_omp_blocks pass. */
2603 for (ctxp
= gimplify_ctxp
; ; ctxp
= ctxp
->prev_context
)
2604 if (ctxp
->case_labels
.exists ())
2607 tree label
= CASE_LABEL (*expr_p
);
2608 label_stmt
= gimple_build_label (label
);
2609 gimple_set_location (label_stmt
, EXPR_LOCATION (*expr_p
));
2610 ctxp
->case_labels
.safe_push (*expr_p
);
2611 gimplify_seq_add_stmt (pre_p
, label_stmt
);
2613 if (lookup_attribute ("cold", DECL_ATTRIBUTES (label
)))
2614 gimple_seq_add_stmt (pre_p
, gimple_build_predict (PRED_COLD_LABEL
,
2616 else if (lookup_attribute ("hot", DECL_ATTRIBUTES (label
)))
2617 gimple_seq_add_stmt (pre_p
, gimple_build_predict (PRED_HOT_LABEL
,
2623 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
2627 build_and_jump (tree
*label_p
)
2629 if (label_p
== NULL
)
2630 /* If there's nowhere to jump, just fall through. */
2633 if (*label_p
== NULL_TREE
)
2635 tree label
= create_artificial_label (UNKNOWN_LOCATION
);
2639 return build1 (GOTO_EXPR
, void_type_node
, *label_p
);
2642 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
2643 This also involves building a label to jump to and communicating it to
2644 gimplify_loop_expr through gimplify_ctxp->exit_label. */
2646 static enum gimplify_status
2647 gimplify_exit_expr (tree
*expr_p
)
2649 tree cond
= TREE_OPERAND (*expr_p
, 0);
2652 expr
= build_and_jump (&gimplify_ctxp
->exit_label
);
2653 expr
= build3 (COND_EXPR
, void_type_node
, cond
, expr
, NULL_TREE
);
2659 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
2660 different from its canonical type, wrap the whole thing inside a
2661 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
2664 The canonical type of a COMPONENT_REF is the type of the field being
2665 referenced--unless the field is a bit-field which can be read directly
2666 in a smaller mode, in which case the canonical type is the
2667 sign-appropriate type corresponding to that mode. */
2670 canonicalize_component_ref (tree
*expr_p
)
2672 tree expr
= *expr_p
;
2675 gcc_assert (TREE_CODE (expr
) == COMPONENT_REF
);
2677 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
2678 type
= TREE_TYPE (get_unwidened (expr
, NULL_TREE
));
2680 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
2682 /* One could argue that all the stuff below is not necessary for
2683 the non-bitfield case and declare it a FE error if type
2684 adjustment would be needed. */
2685 if (TREE_TYPE (expr
) != type
)
2687 #ifdef ENABLE_TYPES_CHECKING
2688 tree old_type
= TREE_TYPE (expr
);
2692 /* We need to preserve qualifiers and propagate them from
2694 type_quals
= TYPE_QUALS (type
)
2695 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr
, 0)));
2696 if (TYPE_QUALS (type
) != type_quals
)
2697 type
= build_qualified_type (TYPE_MAIN_VARIANT (type
), type_quals
);
2699 /* Set the type of the COMPONENT_REF to the underlying type. */
2700 TREE_TYPE (expr
) = type
;
2702 #ifdef ENABLE_TYPES_CHECKING
2703 /* It is now a FE error, if the conversion from the canonical
2704 type to the original expression type is not useless. */
2705 gcc_assert (useless_type_conversion_p (old_type
, type
));
2710 /* If a NOP conversion is changing a pointer to array of foo to a pointer
2711 to foo, embed that change in the ADDR_EXPR by converting
2716 where L is the lower bound. For simplicity, only do this for constant
2718 The constraint is that the type of &array[L] is trivially convertible
2722 canonicalize_addr_expr (tree
*expr_p
)
2724 tree expr
= *expr_p
;
2725 tree addr_expr
= TREE_OPERAND (expr
, 0);
2726 tree datype
, ddatype
, pddatype
;
2728 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
2729 if (!POINTER_TYPE_P (TREE_TYPE (expr
))
2730 || TREE_CODE (addr_expr
) != ADDR_EXPR
)
2733 /* The addr_expr type should be a pointer to an array. */
2734 datype
= TREE_TYPE (TREE_TYPE (addr_expr
));
2735 if (TREE_CODE (datype
) != ARRAY_TYPE
)
2738 /* The pointer to element type shall be trivially convertible to
2739 the expression pointer type. */
2740 ddatype
= TREE_TYPE (datype
);
2741 pddatype
= build_pointer_type (ddatype
);
2742 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)),
2746 /* The lower bound and element sizes must be constant. */
2747 if (!TYPE_SIZE_UNIT (ddatype
)
2748 || TREE_CODE (TYPE_SIZE_UNIT (ddatype
)) != INTEGER_CST
2749 || !TYPE_DOMAIN (datype
) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))
2750 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))) != INTEGER_CST
)
2753 /* All checks succeeded. Build a new node to merge the cast. */
2754 *expr_p
= build4 (ARRAY_REF
, ddatype
, TREE_OPERAND (addr_expr
, 0),
2755 TYPE_MIN_VALUE (TYPE_DOMAIN (datype
)),
2756 NULL_TREE
, NULL_TREE
);
2757 *expr_p
= build1 (ADDR_EXPR
, pddatype
, *expr_p
);
2759 /* We can have stripped a required restrict qualifier above. */
2760 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
2761 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
2764 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
2765 underneath as appropriate. */
2767 static enum gimplify_status
2768 gimplify_conversion (tree
*expr_p
)
2770 location_t loc
= EXPR_LOCATION (*expr_p
);
2771 gcc_assert (CONVERT_EXPR_P (*expr_p
));
2773 /* Then strip away all but the outermost conversion. */
2774 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p
, 0));
2776 /* And remove the outermost conversion if it's useless. */
2777 if (tree_ssa_useless_type_conversion (*expr_p
))
2778 *expr_p
= TREE_OPERAND (*expr_p
, 0);
2780 /* If we still have a conversion at the toplevel,
2781 then canonicalize some constructs. */
2782 if (CONVERT_EXPR_P (*expr_p
))
2784 tree sub
= TREE_OPERAND (*expr_p
, 0);
2786 /* If a NOP conversion is changing the type of a COMPONENT_REF
2787 expression, then canonicalize its type now in order to expose more
2788 redundant conversions. */
2789 if (TREE_CODE (sub
) == COMPONENT_REF
)
2790 canonicalize_component_ref (&TREE_OPERAND (*expr_p
, 0));
2792 /* If a NOP conversion is changing a pointer to array of foo
2793 to a pointer to foo, embed that change in the ADDR_EXPR. */
2794 else if (TREE_CODE (sub
) == ADDR_EXPR
)
2795 canonicalize_addr_expr (expr_p
);
2798 /* If we have a conversion to a non-register type force the
2799 use of a VIEW_CONVERT_EXPR instead. */
2800 if (CONVERT_EXPR_P (*expr_p
) && !is_gimple_reg_type (TREE_TYPE (*expr_p
)))
2801 *expr_p
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (*expr_p
),
2802 TREE_OPERAND (*expr_p
, 0));
2804 /* Canonicalize CONVERT_EXPR to NOP_EXPR. */
2805 if (TREE_CODE (*expr_p
) == CONVERT_EXPR
)
2806 TREE_SET_CODE (*expr_p
, NOP_EXPR
);
2811 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
2812 DECL_VALUE_EXPR, and it's worth re-examining things. */
2814 static enum gimplify_status
2815 gimplify_var_or_parm_decl (tree
*expr_p
)
2817 tree decl
= *expr_p
;
2819 /* ??? If this is a local variable, and it has not been seen in any
2820 outer BIND_EXPR, then it's probably the result of a duplicate
2821 declaration, for which we've already issued an error. It would
2822 be really nice if the front end wouldn't leak these at all.
2823 Currently the only known culprit is C++ destructors, as seen
2824 in g++.old-deja/g++.jason/binding.C. */
2826 && !DECL_SEEN_IN_BIND_EXPR_P (decl
)
2827 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)
2828 && decl_function_context (decl
) == current_function_decl
)
2830 gcc_assert (seen_error ());
2834 /* When within an OMP context, notice uses of variables. */
2835 if (gimplify_omp_ctxp
&& omp_notice_variable (gimplify_omp_ctxp
, decl
, true))
2838 /* If the decl is an alias for another expression, substitute it now. */
2839 if (DECL_HAS_VALUE_EXPR_P (decl
))
2841 *expr_p
= unshare_expr (DECL_VALUE_EXPR (decl
));
2848 /* Recalculate the value of the TREE_SIDE_EFFECTS flag for T. */
2851 recalculate_side_effects (tree t
)
2853 enum tree_code code
= TREE_CODE (t
);
2854 int len
= TREE_OPERAND_LENGTH (t
);
2857 switch (TREE_CODE_CLASS (code
))
2859 case tcc_expression
:
2865 case PREDECREMENT_EXPR
:
2866 case PREINCREMENT_EXPR
:
2867 case POSTDECREMENT_EXPR
:
2868 case POSTINCREMENT_EXPR
:
2869 /* All of these have side-effects, no matter what their
2878 case tcc_comparison
: /* a comparison expression */
2879 case tcc_unary
: /* a unary arithmetic expression */
2880 case tcc_binary
: /* a binary arithmetic expression */
2881 case tcc_reference
: /* a reference */
2882 case tcc_vl_exp
: /* a function call */
2883 TREE_SIDE_EFFECTS (t
) = TREE_THIS_VOLATILE (t
);
2884 for (i
= 0; i
< len
; ++i
)
2886 tree op
= TREE_OPERAND (t
, i
);
2887 if (op
&& TREE_SIDE_EFFECTS (op
))
2888 TREE_SIDE_EFFECTS (t
) = 1;
2893 /* No side-effects. */
2901 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
2905 : min_lval '[' val ']'
2907 | compound_lval '[' val ']'
2908 | compound_lval '.' ID
2910 This is not part of the original SIMPLE definition, which separates
2911 array and member references, but it seems reasonable to handle them
2912 together. Also, this way we don't run into problems with union
2913 aliasing; gcc requires that for accesses through a union to alias, the
2914 union reference must be explicit, which was not always the case when we
2915 were splitting up array and member refs.
2917 PRE_P points to the sequence where side effects that must happen before
2918 *EXPR_P should be stored.
2920 POST_P points to the sequence where side effects that must happen after
2921 *EXPR_P should be stored. */
2923 static enum gimplify_status
2924 gimplify_compound_lval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2925 fallback_t fallback
)
2928 enum gimplify_status ret
= GS_ALL_DONE
, tret
;
2930 location_t loc
= EXPR_LOCATION (*expr_p
);
2931 tree expr
= *expr_p
;
2933 /* Create a stack of the subexpressions so later we can walk them in
2934 order from inner to outer. */
2935 auto_vec
<tree
, 10> expr_stack
;
2937 /* We can handle anything that get_inner_reference can deal with. */
2938 for (p
= expr_p
; ; p
= &TREE_OPERAND (*p
, 0))
2941 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2942 if (TREE_CODE (*p
) == INDIRECT_REF
)
2943 *p
= fold_indirect_ref_loc (loc
, *p
);
2945 if (handled_component_p (*p
))
2947 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2948 additional COMPONENT_REFs. */
2949 else if ((VAR_P (*p
) || TREE_CODE (*p
) == PARM_DECL
)
2950 && gimplify_var_or_parm_decl (p
) == GS_OK
)
2955 expr_stack
.safe_push (*p
);
2958 gcc_assert (expr_stack
.length ());
2960 /* Now EXPR_STACK is a stack of pointers to all the refs we've
2961 walked through and P points to the innermost expression.
2963 Java requires that we elaborated nodes in source order. That
2964 means we must gimplify the inner expression followed by each of
2965 the indices, in order. But we can't gimplify the inner
2966 expression until we deal with any variable bounds, sizes, or
2967 positions in order to deal with PLACEHOLDER_EXPRs.
2969 So we do this in three steps. First we deal with the annotations
2970 for any variables in the components, then we gimplify the base,
2971 then we gimplify any indices, from left to right. */
2972 for (i
= expr_stack
.length () - 1; i
>= 0; i
--)
2974 tree t
= expr_stack
[i
];
2976 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2978 /* Gimplify the low bound and element type size and put them into
2979 the ARRAY_REF. If these values are set, they have already been
2981 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2983 tree low
= unshare_expr (array_ref_low_bound (t
));
2984 if (!is_gimple_min_invariant (low
))
2986 TREE_OPERAND (t
, 2) = low
;
2987 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2988 post_p
, is_gimple_reg
,
2990 ret
= MIN (ret
, tret
);
2995 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2996 is_gimple_reg
, fb_rvalue
);
2997 ret
= MIN (ret
, tret
);
3000 if (TREE_OPERAND (t
, 3) == NULL_TREE
)
3002 tree elmt_size
= array_ref_element_size (t
);
3003 if (!is_gimple_min_invariant (elmt_size
))
3005 elmt_size
= unshare_expr (elmt_size
);
3006 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0)));
3007 tree factor
= size_int (TYPE_ALIGN_UNIT (elmt_type
));
3009 /* Divide the element size by the alignment of the element
3011 elmt_size
= size_binop_loc (loc
, EXACT_DIV_EXPR
,
3014 TREE_OPERAND (t
, 3) = elmt_size
;
3015 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
,
3016 post_p
, is_gimple_reg
,
3018 ret
= MIN (ret
, tret
);
3023 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
, post_p
,
3024 is_gimple_reg
, fb_rvalue
);
3025 ret
= MIN (ret
, tret
);
3028 else if (TREE_CODE (t
) == COMPONENT_REF
)
3030 /* Set the field offset into T and gimplify it. */
3031 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
3033 tree offset
= component_ref_field_offset (t
);
3034 if (!is_gimple_min_invariant (offset
))
3036 offset
= unshare_expr (offset
);
3037 tree field
= TREE_OPERAND (t
, 1);
3039 = size_int (DECL_OFFSET_ALIGN (field
) / BITS_PER_UNIT
);
3041 /* Divide the offset by its alignment. */
3042 offset
= size_binop_loc (loc
, EXACT_DIV_EXPR
,
3045 TREE_OPERAND (t
, 2) = offset
;
3046 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
3047 post_p
, is_gimple_reg
,
3049 ret
= MIN (ret
, tret
);
3054 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
3055 is_gimple_reg
, fb_rvalue
);
3056 ret
= MIN (ret
, tret
);
3061 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
3062 so as to match the min_lval predicate. Failure to do so may result
3063 in the creation of large aggregate temporaries. */
3064 tret
= gimplify_expr (p
, pre_p
, post_p
, is_gimple_min_lval
,
3065 fallback
| fb_lvalue
);
3066 ret
= MIN (ret
, tret
);
3068 /* And finally, the indices and operands of ARRAY_REF. During this
3069 loop we also remove any useless conversions. */
3070 for (; expr_stack
.length () > 0; )
3072 tree t
= expr_stack
.pop ();
3074 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
3076 /* Gimplify the dimension. */
3077 if (!is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
3079 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
3080 is_gimple_val
, fb_rvalue
);
3081 ret
= MIN (ret
, tret
);
3085 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t
, 0));
3087 /* The innermost expression P may have originally had
3088 TREE_SIDE_EFFECTS set which would have caused all the outer
3089 expressions in *EXPR_P leading to P to also have had
3090 TREE_SIDE_EFFECTS set. */
3091 recalculate_side_effects (t
);
3094 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
3095 if ((fallback
& fb_rvalue
) && TREE_CODE (*expr_p
) == COMPONENT_REF
)
3097 canonicalize_component_ref (expr_p
);
3100 expr_stack
.release ();
3102 gcc_assert (*expr_p
== expr
|| ret
!= GS_ALL_DONE
);
3107 /* Gimplify the self modifying expression pointed to by EXPR_P
3110 PRE_P points to the list where side effects that must happen before
3111 *EXPR_P should be stored.
3113 POST_P points to the list where side effects that must happen after
3114 *EXPR_P should be stored.
3116 WANT_VALUE is nonzero iff we want to use the value of this expression
3117 in another expression.
3119 ARITH_TYPE is the type the computation should be performed in. */
3121 enum gimplify_status
3122 gimplify_self_mod_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3123 bool want_value
, tree arith_type
)
3125 enum tree_code code
;
3126 tree lhs
, lvalue
, rhs
, t1
;
3127 gimple_seq post
= NULL
, *orig_post_p
= post_p
;
3129 enum tree_code arith_code
;
3130 enum gimplify_status ret
;
3131 location_t loc
= EXPR_LOCATION (*expr_p
);
3133 code
= TREE_CODE (*expr_p
);
3135 gcc_assert (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
3136 || code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
);
3138 /* Prefix or postfix? */
3139 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
3140 /* Faster to treat as prefix if result is not used. */
3141 postfix
= want_value
;
3145 /* For postfix, make sure the inner expression's post side effects
3146 are executed after side effects from this expression. */
3150 /* Add or subtract? */
3151 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
3152 arith_code
= PLUS_EXPR
;
3154 arith_code
= MINUS_EXPR
;
3156 /* Gimplify the LHS into a GIMPLE lvalue. */
3157 lvalue
= TREE_OPERAND (*expr_p
, 0);
3158 ret
= gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
3159 if (ret
== GS_ERROR
)
3162 /* Extract the operands to the arithmetic operation. */
3164 rhs
= TREE_OPERAND (*expr_p
, 1);
3166 /* For postfix operator, we evaluate the LHS to an rvalue and then use
3167 that as the result value and in the postqueue operation. */
3170 ret
= gimplify_expr (&lhs
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
3171 if (ret
== GS_ERROR
)
3174 lhs
= get_initialized_tmp_var (lhs
, pre_p
);
3177 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
3178 if (POINTER_TYPE_P (TREE_TYPE (lhs
)))
3180 rhs
= convert_to_ptrofftype_loc (loc
, rhs
);
3181 if (arith_code
== MINUS_EXPR
)
3182 rhs
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
3183 t1
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (*expr_p
), lhs
, rhs
);
3186 t1
= fold_convert (TREE_TYPE (*expr_p
),
3187 fold_build2 (arith_code
, arith_type
,
3188 fold_convert (arith_type
, lhs
),
3189 fold_convert (arith_type
, rhs
)));
3193 gimplify_assign (lvalue
, t1
, pre_p
);
3194 gimplify_seq_add_seq (orig_post_p
, post
);
3200 *expr_p
= build2 (MODIFY_EXPR
, TREE_TYPE (lvalue
), lvalue
, t1
);
3205 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
3208 maybe_with_size_expr (tree
*expr_p
)
3210 tree expr
= *expr_p
;
3211 tree type
= TREE_TYPE (expr
);
3214 /* If we've already wrapped this or the type is error_mark_node, we can't do
3216 if (TREE_CODE (expr
) == WITH_SIZE_EXPR
3217 || type
== error_mark_node
)
3220 /* If the size isn't known or is a constant, we have nothing to do. */
3221 size
= TYPE_SIZE_UNIT (type
);
3222 if (!size
|| poly_int_tree_p (size
))
3225 /* Otherwise, make a WITH_SIZE_EXPR. */
3226 size
= unshare_expr (size
);
3227 size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (size
, expr
);
3228 *expr_p
= build2 (WITH_SIZE_EXPR
, type
, expr
, size
);
3231 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
3232 Store any side-effects in PRE_P. CALL_LOCATION is the location of
3233 the CALL_EXPR. If ALLOW_SSA is set the actual parameter may be
3234 gimplified to an SSA name. */
3236 enum gimplify_status
3237 gimplify_arg (tree
*arg_p
, gimple_seq
*pre_p
, location_t call_location
,
3240 bool (*test
) (tree
);
3243 /* In general, we allow lvalues for function arguments to avoid
3244 extra overhead of copying large aggregates out of even larger
3245 aggregates into temporaries only to copy the temporaries to
3246 the argument list. Make optimizers happy by pulling out to
3247 temporaries those types that fit in registers. */
3248 if (is_gimple_reg_type (TREE_TYPE (*arg_p
)))
3249 test
= is_gimple_val
, fb
= fb_rvalue
;
3252 test
= is_gimple_lvalue
, fb
= fb_either
;
3253 /* Also strip a TARGET_EXPR that would force an extra copy. */
3254 if (TREE_CODE (*arg_p
) == TARGET_EXPR
)
3256 tree init
= TARGET_EXPR_INITIAL (*arg_p
);
3258 && !VOID_TYPE_P (TREE_TYPE (init
)))
3263 /* If this is a variable sized type, we must remember the size. */
3264 maybe_with_size_expr (arg_p
);
3266 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
3267 /* Make sure arguments have the same location as the function call
3269 protected_set_expr_location (*arg_p
, call_location
);
3271 /* There is a sequence point before a function call. Side effects in
3272 the argument list must occur before the actual call. So, when
3273 gimplifying arguments, force gimplify_expr to use an internal
3274 post queue which is then appended to the end of PRE_P. */
3275 return gimplify_expr (arg_p
, pre_p
, NULL
, test
, fb
, allow_ssa
);
3278 /* Don't fold inside offloading or taskreg regions: it can break code by
3279 adding decl references that weren't in the source. We'll do it during
3280 omplower pass instead. */
3283 maybe_fold_stmt (gimple_stmt_iterator
*gsi
)
3285 struct gimplify_omp_ctx
*ctx
;
3286 for (ctx
= gimplify_omp_ctxp
; ctx
; ctx
= ctx
->outer_context
)
3287 if ((ctx
->region_type
& (ORT_TARGET
| ORT_PARALLEL
| ORT_TASK
)) != 0)
3289 else if ((ctx
->region_type
& ORT_HOST_TEAMS
) == ORT_HOST_TEAMS
)
3291 /* Delay folding of builtins until the IL is in consistent state
3292 so the diagnostic machinery can do a better job. */
3293 if (gimple_call_builtin_p (gsi_stmt (*gsi
)))
3295 return fold_stmt (gsi
);
3298 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
3299 WANT_VALUE is true if the result of the call is desired. */
3301 static enum gimplify_status
3302 gimplify_call_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
3304 tree fndecl
, parms
, p
, fnptrtype
;
3305 enum gimplify_status ret
;
3308 bool builtin_va_start_p
= false;
3309 location_t loc
= EXPR_LOCATION (*expr_p
);
3311 gcc_assert (TREE_CODE (*expr_p
) == CALL_EXPR
);
3313 /* For reliable diagnostics during inlining, it is necessary that
3314 every call_expr be annotated with file and line. */
3315 if (! EXPR_HAS_LOCATION (*expr_p
))
3316 SET_EXPR_LOCATION (*expr_p
, input_location
);
3318 /* Gimplify internal functions created in the FEs. */
3319 if (CALL_EXPR_FN (*expr_p
) == NULL_TREE
)
3324 nargs
= call_expr_nargs (*expr_p
);
3325 enum internal_fn ifn
= CALL_EXPR_IFN (*expr_p
);
3326 auto_vec
<tree
> vargs (nargs
);
3328 for (i
= 0; i
< nargs
; i
++)
3330 gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
3331 EXPR_LOCATION (*expr_p
));
3332 vargs
.quick_push (CALL_EXPR_ARG (*expr_p
, i
));
3335 gcall
*call
= gimple_build_call_internal_vec (ifn
, vargs
);
3336 gimple_call_set_nothrow (call
, TREE_NOTHROW (*expr_p
));
3337 gimplify_seq_add_stmt (pre_p
, call
);
3341 /* This may be a call to a builtin function.
3343 Builtin function calls may be transformed into different
3344 (and more efficient) builtin function calls under certain
3345 circumstances. Unfortunately, gimplification can muck things
3346 up enough that the builtin expanders are not aware that certain
3347 transformations are still valid.
3349 So we attempt transformation/gimplification of the call before
3350 we gimplify the CALL_EXPR. At this time we do not manage to
3351 transform all calls in the same manner as the expanders do, but
3352 we do transform most of them. */
3353 fndecl
= get_callee_fndecl (*expr_p
);
3354 if (fndecl
&& fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
3355 switch (DECL_FUNCTION_CODE (fndecl
))
3357 CASE_BUILT_IN_ALLOCA
:
3358 /* If the call has been built for a variable-sized object, then we
3359 want to restore the stack level when the enclosing BIND_EXPR is
3360 exited to reclaim the allocated space; otherwise, we precisely
3361 need to do the opposite and preserve the latest stack level. */
3362 if (CALL_ALLOCA_FOR_VAR_P (*expr_p
))
3363 gimplify_ctxp
->save_stack
= true;
3365 gimplify_ctxp
->keep_stack
= true;
3368 case BUILT_IN_VA_START
:
3370 builtin_va_start_p
= TRUE
;
3371 if (call_expr_nargs (*expr_p
) < 2)
3373 error ("too few arguments to function %<va_start%>");
3374 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
3378 if (fold_builtin_next_arg (*expr_p
, true))
3380 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
3386 case BUILT_IN_EH_RETURN
:
3387 cfun
->calls_eh_return
= true;
3393 if (fndecl
&& fndecl_built_in_p (fndecl
))
3395 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
3396 if (new_tree
&& new_tree
!= *expr_p
)
3398 /* There was a transformation of this call which computes the
3399 same value, but in a more efficient way. Return and try
3406 /* Remember the original function pointer type. */
3407 fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*expr_p
));
3412 && (cfun
->curr_properties
& PROP_gimple_any
) == 0)
3414 tree variant
= omp_resolve_declare_variant (fndecl
);
3415 if (variant
!= fndecl
)
3416 CALL_EXPR_FN (*expr_p
) = build1 (ADDR_EXPR
, fnptrtype
, variant
);
3419 /* There is a sequence point before the call, so any side effects in
3420 the calling expression must occur before the actual call. Force
3421 gimplify_expr to use an internal post queue. */
3422 ret
= gimplify_expr (&CALL_EXPR_FN (*expr_p
), pre_p
, NULL
,
3423 is_gimple_call_addr
, fb_rvalue
);
3425 nargs
= call_expr_nargs (*expr_p
);
3427 /* Get argument types for verification. */
3428 fndecl
= get_callee_fndecl (*expr_p
);
3431 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
3433 parms
= TYPE_ARG_TYPES (TREE_TYPE (fnptrtype
));
3435 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
3436 p
= DECL_ARGUMENTS (fndecl
);
3441 for (i
= 0; i
< nargs
&& p
; i
++, p
= TREE_CHAIN (p
))
3444 /* If the last argument is __builtin_va_arg_pack () and it is not
3445 passed as a named argument, decrease the number of CALL_EXPR
3446 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
3449 && TREE_CODE (CALL_EXPR_ARG (*expr_p
, nargs
- 1)) == CALL_EXPR
)
3451 tree last_arg
= CALL_EXPR_ARG (*expr_p
, nargs
- 1);
3452 tree last_arg_fndecl
= get_callee_fndecl (last_arg
);
3455 && fndecl_built_in_p (last_arg_fndecl
, BUILT_IN_VA_ARG_PACK
))
3457 tree call
= *expr_p
;
3460 *expr_p
= build_call_array_loc (loc
, TREE_TYPE (call
),
3461 CALL_EXPR_FN (call
),
3462 nargs
, CALL_EXPR_ARGP (call
));
3464 /* Copy all CALL_EXPR flags, location and block, except
3465 CALL_EXPR_VA_ARG_PACK flag. */
3466 CALL_EXPR_STATIC_CHAIN (*expr_p
) = CALL_EXPR_STATIC_CHAIN (call
);
3467 CALL_EXPR_TAILCALL (*expr_p
) = CALL_EXPR_TAILCALL (call
);
3468 CALL_EXPR_RETURN_SLOT_OPT (*expr_p
)
3469 = CALL_EXPR_RETURN_SLOT_OPT (call
);
3470 CALL_FROM_THUNK_P (*expr_p
) = CALL_FROM_THUNK_P (call
);
3471 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (call
));
3473 /* Set CALL_EXPR_VA_ARG_PACK. */
3474 CALL_EXPR_VA_ARG_PACK (*expr_p
) = 1;
3478 /* If the call returns twice then after building the CFG the call
3479 argument computations will no longer dominate the call because
3480 we add an abnormal incoming edge to the call. So do not use SSA
3482 bool returns_twice
= call_expr_flags (*expr_p
) & ECF_RETURNS_TWICE
;
3484 /* Gimplify the function arguments. */
3487 for (i
= (PUSH_ARGS_REVERSED
? nargs
- 1 : 0);
3488 PUSH_ARGS_REVERSED
? i
>= 0 : i
< nargs
;
3489 PUSH_ARGS_REVERSED
? i
-- : i
++)
3491 enum gimplify_status t
;
3493 /* Avoid gimplifying the second argument to va_start, which needs to
3494 be the plain PARM_DECL. */
3495 if ((i
!= 1) || !builtin_va_start_p
)
3497 t
= gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
3498 EXPR_LOCATION (*expr_p
), ! returns_twice
);
3506 /* Gimplify the static chain. */
3507 if (CALL_EXPR_STATIC_CHAIN (*expr_p
))
3509 if (fndecl
&& !DECL_STATIC_CHAIN (fndecl
))
3510 CALL_EXPR_STATIC_CHAIN (*expr_p
) = NULL
;
3513 enum gimplify_status t
;
3514 t
= gimplify_arg (&CALL_EXPR_STATIC_CHAIN (*expr_p
), pre_p
,
3515 EXPR_LOCATION (*expr_p
), ! returns_twice
);
3521 /* Verify the function result. */
3522 if (want_value
&& fndecl
3523 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype
))))
3525 error_at (loc
, "using result of function returning %<void%>");
3529 /* Try this again in case gimplification exposed something. */
3530 if (ret
!= GS_ERROR
)
3532 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
3534 if (new_tree
&& new_tree
!= *expr_p
)
3536 /* There was a transformation of this call which computes the
3537 same value, but in a more efficient way. Return and try
3545 *expr_p
= error_mark_node
;
3549 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
3550 decl. This allows us to eliminate redundant or useless
3551 calls to "const" functions. */
3552 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
3554 int flags
= call_expr_flags (*expr_p
);
3555 if (flags
& (ECF_CONST
| ECF_PURE
)
3556 /* An infinite loop is considered a side effect. */
3557 && !(flags
& (ECF_LOOPING_CONST_OR_PURE
)))
3558 TREE_SIDE_EFFECTS (*expr_p
) = 0;
3561 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
3562 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
3563 form and delegate the creation of a GIMPLE_CALL to
3564 gimplify_modify_expr. This is always possible because when
3565 WANT_VALUE is true, the caller wants the result of this call into
3566 a temporary, which means that we will emit an INIT_EXPR in
3567 internal_get_tmp_var which will then be handled by
3568 gimplify_modify_expr. */
3571 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
3572 have to do is replicate it as a GIMPLE_CALL tuple. */
3573 gimple_stmt_iterator gsi
;
3574 call
= gimple_build_call_from_tree (*expr_p
, fnptrtype
);
3575 notice_special_calls (call
);
3576 gimplify_seq_add_stmt (pre_p
, call
);
3577 gsi
= gsi_last (*pre_p
);
3578 maybe_fold_stmt (&gsi
);
3579 *expr_p
= NULL_TREE
;
3582 /* Remember the original function type. */
3583 CALL_EXPR_FN (*expr_p
) = build1 (NOP_EXPR
, fnptrtype
,
3584 CALL_EXPR_FN (*expr_p
));
3589 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
3590 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
3592 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
3593 condition is true or false, respectively. If null, we should generate
3594 our own to skip over the evaluation of this specific expression.
3596 LOCUS is the source location of the COND_EXPR.
3598 This function is the tree equivalent of do_jump.
3600 shortcut_cond_r should only be called by shortcut_cond_expr. */
3603 shortcut_cond_r (tree pred
, tree
*true_label_p
, tree
*false_label_p
,
3606 tree local_label
= NULL_TREE
;
3607 tree t
, expr
= NULL
;
3609 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
3610 retain the shortcut semantics. Just insert the gotos here;
3611 shortcut_cond_expr will append the real blocks later. */
3612 if (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
3614 location_t new_locus
;
3616 /* Turn if (a && b) into
3618 if (a); else goto no;
3619 if (b) goto yes; else goto no;
3622 if (false_label_p
== NULL
)
3623 false_label_p
= &local_label
;
3625 /* Keep the original source location on the first 'if'. */
3626 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), NULL
, false_label_p
, locus
);
3627 append_to_statement_list (t
, &expr
);
3629 /* Set the source location of the && on the second 'if'. */
3630 new_locus
= rexpr_location (pred
, locus
);
3631 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
3633 append_to_statement_list (t
, &expr
);
3635 else if (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
3637 location_t new_locus
;
3639 /* Turn if (a || b) into
3642 if (b) goto yes; else goto no;
3645 if (true_label_p
== NULL
)
3646 true_label_p
= &local_label
;
3648 /* Keep the original source location on the first 'if'. */
3649 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), true_label_p
, NULL
, locus
);
3650 append_to_statement_list (t
, &expr
);
3652 /* Set the source location of the || on the second 'if'. */
3653 new_locus
= rexpr_location (pred
, locus
);
3654 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
3656 append_to_statement_list (t
, &expr
);
3658 else if (TREE_CODE (pred
) == COND_EXPR
3659 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 1)))
3660 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 2))))
3662 location_t new_locus
;
3664 /* As long as we're messing with gotos, turn if (a ? b : c) into
3666 if (b) goto yes; else goto no;
3668 if (c) goto yes; else goto no;
3670 Don't do this if one of the arms has void type, which can happen
3671 in C++ when the arm is throw. */
3673 /* Keep the original source location on the first 'if'. Set the source
3674 location of the ? on the second 'if'. */
3675 new_locus
= rexpr_location (pred
, locus
);
3676 expr
= build3 (COND_EXPR
, void_type_node
, TREE_OPERAND (pred
, 0),
3677 shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
,
3678 false_label_p
, locus
),
3679 shortcut_cond_r (TREE_OPERAND (pred
, 2), true_label_p
,
3680 false_label_p
, new_locus
));
3684 expr
= build3 (COND_EXPR
, void_type_node
, pred
,
3685 build_and_jump (true_label_p
),
3686 build_and_jump (false_label_p
));
3687 SET_EXPR_LOCATION (expr
, locus
);
3692 t
= build1 (LABEL_EXPR
, void_type_node
, local_label
);
3693 append_to_statement_list (t
, &expr
);
3699 /* If EXPR is a GOTO_EXPR, return it. If it is a STATEMENT_LIST, skip
3700 any of its leading DEBUG_BEGIN_STMTS and recurse on the subsequent
3701 statement, if it is the last one. Otherwise, return NULL. */
3704 find_goto (tree expr
)
3709 if (TREE_CODE (expr
) == GOTO_EXPR
)
3712 if (TREE_CODE (expr
) != STATEMENT_LIST
)
3715 tree_stmt_iterator i
= tsi_start (expr
);
3717 while (!tsi_end_p (i
) && TREE_CODE (tsi_stmt (i
)) == DEBUG_BEGIN_STMT
)
3720 if (!tsi_one_before_end_p (i
))
3723 return find_goto (tsi_stmt (i
));
3726 /* Same as find_goto, except that it returns NULL if the destination
3727 is not a LABEL_DECL. */
3730 find_goto_label (tree expr
)
3732 tree dest
= find_goto (expr
);
3733 if (dest
&& TREE_CODE (GOTO_DESTINATION (dest
)) == LABEL_DECL
)
3738 /* Given a conditional expression EXPR with short-circuit boolean
3739 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
3740 predicate apart into the equivalent sequence of conditionals. */
3743 shortcut_cond_expr (tree expr
)
3745 tree pred
= TREE_OPERAND (expr
, 0);
3746 tree then_
= TREE_OPERAND (expr
, 1);
3747 tree else_
= TREE_OPERAND (expr
, 2);
3748 tree true_label
, false_label
, end_label
, t
;
3750 tree
*false_label_p
;
3751 bool emit_end
, emit_false
, jump_over_else
;
3752 bool then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
3753 bool else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
3755 /* First do simple transformations. */
3758 /* If there is no 'else', turn
3761 if (a) if (b) then c. */
3762 while (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
3764 /* Keep the original source location on the first 'if'. */
3765 location_t locus
= EXPR_LOC_OR_LOC (expr
, input_location
);
3766 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
3767 /* Set the source location of the && on the second 'if'. */
3768 if (rexpr_has_location (pred
))
3769 SET_EXPR_LOCATION (expr
, rexpr_location (pred
));
3770 then_
= shortcut_cond_expr (expr
);
3771 then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
3772 pred
= TREE_OPERAND (pred
, 0);
3773 expr
= build3 (COND_EXPR
, void_type_node
, pred
, then_
, NULL_TREE
);
3774 SET_EXPR_LOCATION (expr
, locus
);
3780 /* If there is no 'then', turn
3783 if (a); else if (b); else d. */
3784 while (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
3786 /* Keep the original source location on the first 'if'. */
3787 location_t locus
= EXPR_LOC_OR_LOC (expr
, input_location
);
3788 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
3789 /* Set the source location of the || on the second 'if'. */
3790 if (rexpr_has_location (pred
))
3791 SET_EXPR_LOCATION (expr
, rexpr_location (pred
));
3792 else_
= shortcut_cond_expr (expr
);
3793 else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
3794 pred
= TREE_OPERAND (pred
, 0);
3795 expr
= build3 (COND_EXPR
, void_type_node
, pred
, NULL_TREE
, else_
);
3796 SET_EXPR_LOCATION (expr
, locus
);
3800 /* If we're done, great. */
3801 if (TREE_CODE (pred
) != TRUTH_ANDIF_EXPR
3802 && TREE_CODE (pred
) != TRUTH_ORIF_EXPR
)
3805 /* Otherwise we need to mess with gotos. Change
3808 if (a); else goto no;
3811 and recursively gimplify the condition. */
3813 true_label
= false_label
= end_label
= NULL_TREE
;
3815 /* If our arms just jump somewhere, hijack those labels so we don't
3816 generate jumps to jumps. */
3818 if (tree then_goto
= find_goto_label (then_
))
3820 true_label
= GOTO_DESTINATION (then_goto
);
3825 if (tree else_goto
= find_goto_label (else_
))
3827 false_label
= GOTO_DESTINATION (else_goto
);
3832 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
3834 true_label_p
= &true_label
;
3836 true_label_p
= NULL
;
3838 /* The 'else' branch also needs a label if it contains interesting code. */
3839 if (false_label
|| else_se
)
3840 false_label_p
= &false_label
;
3842 false_label_p
= NULL
;
3844 /* If there was nothing else in our arms, just forward the label(s). */
3845 if (!then_se
&& !else_se
)
3846 return shortcut_cond_r (pred
, true_label_p
, false_label_p
,
3847 EXPR_LOC_OR_LOC (expr
, input_location
));
3849 /* If our last subexpression already has a terminal label, reuse it. */
3851 t
= expr_last (else_
);
3853 t
= expr_last (then_
);
3856 if (t
&& TREE_CODE (t
) == LABEL_EXPR
)
3857 end_label
= LABEL_EXPR_LABEL (t
);
3859 /* If we don't care about jumping to the 'else' branch, jump to the end
3860 if the condition is false. */
3862 false_label_p
= &end_label
;
3864 /* We only want to emit these labels if we aren't hijacking them. */
3865 emit_end
= (end_label
== NULL_TREE
);
3866 emit_false
= (false_label
== NULL_TREE
);
3868 /* We only emit the jump over the else clause if we have to--if the
3869 then clause may fall through. Otherwise we can wind up with a
3870 useless jump and a useless label at the end of gimplified code,
3871 which will cause us to think that this conditional as a whole
3872 falls through even if it doesn't. If we then inline a function
3873 which ends with such a condition, that can cause us to issue an
3874 inappropriate warning about control reaching the end of a
3875 non-void function. */
3876 jump_over_else
= block_may_fallthru (then_
);
3878 pred
= shortcut_cond_r (pred
, true_label_p
, false_label_p
,
3879 EXPR_LOC_OR_LOC (expr
, input_location
));
3882 append_to_statement_list (pred
, &expr
);
3884 append_to_statement_list (then_
, &expr
);
3889 tree last
= expr_last (expr
);
3890 t
= build_and_jump (&end_label
);
3891 if (rexpr_has_location (last
))
3892 SET_EXPR_LOCATION (t
, rexpr_location (last
));
3893 append_to_statement_list (t
, &expr
);
3897 t
= build1 (LABEL_EXPR
, void_type_node
, false_label
);
3898 append_to_statement_list (t
, &expr
);
3900 append_to_statement_list (else_
, &expr
);
3902 if (emit_end
&& end_label
)
3904 t
= build1 (LABEL_EXPR
, void_type_node
, end_label
);
3905 append_to_statement_list (t
, &expr
);
3911 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
3914 gimple_boolify (tree expr
)
3916 tree type
= TREE_TYPE (expr
);
3917 location_t loc
= EXPR_LOCATION (expr
);
3919 if (TREE_CODE (expr
) == NE_EXPR
3920 && TREE_CODE (TREE_OPERAND (expr
, 0)) == CALL_EXPR
3921 && integer_zerop (TREE_OPERAND (expr
, 1)))
3923 tree call
= TREE_OPERAND (expr
, 0);
3924 tree fn
= get_callee_fndecl (call
);
3926 /* For __builtin_expect ((long) (x), y) recurse into x as well
3927 if x is truth_value_p. */
3929 && fndecl_built_in_p (fn
, BUILT_IN_EXPECT
)
3930 && call_expr_nargs (call
) == 2)
3932 tree arg
= CALL_EXPR_ARG (call
, 0);
3935 if (TREE_CODE (arg
) == NOP_EXPR
3936 && TREE_TYPE (arg
) == TREE_TYPE (call
))
3937 arg
= TREE_OPERAND (arg
, 0);
3938 if (truth_value_p (TREE_CODE (arg
)))
3940 arg
= gimple_boolify (arg
);
3941 CALL_EXPR_ARG (call
, 0)
3942 = fold_convert_loc (loc
, TREE_TYPE (call
), arg
);
3948 switch (TREE_CODE (expr
))
3950 case TRUTH_AND_EXPR
:
3952 case TRUTH_XOR_EXPR
:
3953 case TRUTH_ANDIF_EXPR
:
3954 case TRUTH_ORIF_EXPR
:
3955 /* Also boolify the arguments of truth exprs. */
3956 TREE_OPERAND (expr
, 1) = gimple_boolify (TREE_OPERAND (expr
, 1));
3959 case TRUTH_NOT_EXPR
:
3960 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3962 /* These expressions always produce boolean results. */
3963 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3964 TREE_TYPE (expr
) = boolean_type_node
;
3968 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (expr
, 1)))
3970 case annot_expr_ivdep_kind
:
3971 case annot_expr_unroll_kind
:
3972 case annot_expr_no_vector_kind
:
3973 case annot_expr_vector_kind
:
3974 case annot_expr_parallel_kind
:
3975 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3976 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3977 TREE_TYPE (expr
) = boolean_type_node
;
3984 if (COMPARISON_CLASS_P (expr
))
3986 /* There expressions always prduce boolean results. */
3987 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3988 TREE_TYPE (expr
) = boolean_type_node
;
3991 /* Other expressions that get here must have boolean values, but
3992 might need to be converted to the appropriate mode. */
3993 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
3995 return fold_convert_loc (loc
, boolean_type_node
, expr
);
3999 /* Given a conditional expression *EXPR_P without side effects, gimplify
4000 its operands. New statements are inserted to PRE_P. */
4002 static enum gimplify_status
4003 gimplify_pure_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
)
4005 tree expr
= *expr_p
, cond
;
4006 enum gimplify_status ret
, tret
;
4007 enum tree_code code
;
4009 cond
= gimple_boolify (COND_EXPR_COND (expr
));
4011 /* We need to handle && and || specially, as their gimplification
4012 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
4013 code
= TREE_CODE (cond
);
4014 if (code
== TRUTH_ANDIF_EXPR
)
4015 TREE_SET_CODE (cond
, TRUTH_AND_EXPR
);
4016 else if (code
== TRUTH_ORIF_EXPR
)
4017 TREE_SET_CODE (cond
, TRUTH_OR_EXPR
);
4018 ret
= gimplify_expr (&cond
, pre_p
, NULL
, is_gimple_condexpr
, fb_rvalue
);
4019 COND_EXPR_COND (*expr_p
) = cond
;
4021 tret
= gimplify_expr (&COND_EXPR_THEN (expr
), pre_p
, NULL
,
4022 is_gimple_val
, fb_rvalue
);
4023 ret
= MIN (ret
, tret
);
4024 tret
= gimplify_expr (&COND_EXPR_ELSE (expr
), pre_p
, NULL
,
4025 is_gimple_val
, fb_rvalue
);
4027 return MIN (ret
, tret
);
4030 /* Return true if evaluating EXPR could trap.
4031 EXPR is GENERIC, while tree_could_trap_p can be called
4035 generic_expr_could_trap_p (tree expr
)
4039 if (!expr
|| is_gimple_val (expr
))
4042 if (!EXPR_P (expr
) || tree_could_trap_p (expr
))
4045 n
= TREE_OPERAND_LENGTH (expr
);
4046 for (i
= 0; i
< n
; i
++)
4047 if (generic_expr_could_trap_p (TREE_OPERAND (expr
, i
)))
4053 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
4062 The second form is used when *EXPR_P is of type void.
4064 PRE_P points to the list where side effects that must happen before
4065 *EXPR_P should be stored. */
4067 static enum gimplify_status
4068 gimplify_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
, fallback_t fallback
)
4070 tree expr
= *expr_p
;
4071 tree type
= TREE_TYPE (expr
);
4072 location_t loc
= EXPR_LOCATION (expr
);
4073 tree tmp
, arm1
, arm2
;
4074 enum gimplify_status ret
;
4075 tree label_true
, label_false
, label_cont
;
4076 bool have_then_clause_p
, have_else_clause_p
;
4078 enum tree_code pred_code
;
4079 gimple_seq seq
= NULL
;
4081 /* If this COND_EXPR has a value, copy the values into a temporary within
4083 if (!VOID_TYPE_P (type
))
4085 tree then_
= TREE_OPERAND (expr
, 1), else_
= TREE_OPERAND (expr
, 2);
4088 /* If either an rvalue is ok or we do not require an lvalue, create the
4089 temporary. But we cannot do that if the type is addressable. */
4090 if (((fallback
& fb_rvalue
) || !(fallback
& fb_lvalue
))
4091 && !TREE_ADDRESSABLE (type
))
4093 if (gimplify_ctxp
->allow_rhs_cond_expr
4094 /* If either branch has side effects or could trap, it can't be
4095 evaluated unconditionally. */
4096 && !TREE_SIDE_EFFECTS (then_
)
4097 && !generic_expr_could_trap_p (then_
)
4098 && !TREE_SIDE_EFFECTS (else_
)
4099 && !generic_expr_could_trap_p (else_
))
4100 return gimplify_pure_cond_expr (expr_p
, pre_p
);
4102 tmp
= create_tmp_var (type
, "iftmp");
4106 /* Otherwise, only create and copy references to the values. */
4109 type
= build_pointer_type (type
);
4111 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
4112 then_
= build_fold_addr_expr_loc (loc
, then_
);
4114 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
4115 else_
= build_fold_addr_expr_loc (loc
, else_
);
4118 = build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0), then_
, else_
);
4120 tmp
= create_tmp_var (type
, "iftmp");
4121 result
= build_simple_mem_ref_loc (loc
, tmp
);
4124 /* Build the new then clause, `tmp = then_;'. But don't build the
4125 assignment if the value is void; in C++ it can be if it's a throw. */
4126 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
4127 TREE_OPERAND (expr
, 1) = build2 (INIT_EXPR
, type
, tmp
, then_
);
4129 /* Similarly, build the new else clause, `tmp = else_;'. */
4130 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
4131 TREE_OPERAND (expr
, 2) = build2 (INIT_EXPR
, type
, tmp
, else_
);
4133 TREE_TYPE (expr
) = void_type_node
;
4134 recalculate_side_effects (expr
);
4136 /* Move the COND_EXPR to the prequeue. */
4137 gimplify_stmt (&expr
, pre_p
);
4143 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
4144 STRIP_TYPE_NOPS (TREE_OPERAND (expr
, 0));
4145 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == COMPOUND_EXPR
)
4146 gimplify_compound_expr (&TREE_OPERAND (expr
, 0), pre_p
, true);
4148 /* Make sure the condition has BOOLEAN_TYPE. */
4149 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
4151 /* Break apart && and || conditions. */
4152 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ANDIF_EXPR
4153 || TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ORIF_EXPR
)
4155 expr
= shortcut_cond_expr (expr
);
4157 if (expr
!= *expr_p
)
4161 /* We can't rely on gimplify_expr to re-gimplify the expanded
4162 form properly, as cleanups might cause the target labels to be
4163 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
4164 set up a conditional context. */
4165 gimple_push_condition ();
4166 gimplify_stmt (expr_p
, &seq
);
4167 gimple_pop_condition (pre_p
);
4168 gimple_seq_add_seq (pre_p
, seq
);
4174 /* Now do the normal gimplification. */
4176 /* Gimplify condition. */
4177 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, NULL
,
4178 is_gimple_condexpr_for_cond
, fb_rvalue
);
4179 if (ret
== GS_ERROR
)
4181 gcc_assert (TREE_OPERAND (expr
, 0) != NULL_TREE
);
4183 gimple_push_condition ();
4185 have_then_clause_p
= have_else_clause_p
= false;
4186 label_true
= find_goto_label (TREE_OPERAND (expr
, 1));
4188 && DECL_CONTEXT (GOTO_DESTINATION (label_true
)) == current_function_decl
4189 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
4190 have different locations, otherwise we end up with incorrect
4191 location information on the branches. */
4193 || !EXPR_HAS_LOCATION (expr
)
4194 || !rexpr_has_location (label_true
)
4195 || EXPR_LOCATION (expr
) == rexpr_location (label_true
)))
4197 have_then_clause_p
= true;
4198 label_true
= GOTO_DESTINATION (label_true
);
4201 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
4202 label_false
= find_goto_label (TREE_OPERAND (expr
, 2));
4204 && DECL_CONTEXT (GOTO_DESTINATION (label_false
)) == current_function_decl
4205 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
4206 have different locations, otherwise we end up with incorrect
4207 location information on the branches. */
4209 || !EXPR_HAS_LOCATION (expr
)
4210 || !rexpr_has_location (label_false
)
4211 || EXPR_LOCATION (expr
) == rexpr_location (label_false
)))
4213 have_else_clause_p
= true;
4214 label_false
= GOTO_DESTINATION (label_false
);
4217 label_false
= create_artificial_label (UNKNOWN_LOCATION
);
4219 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr
), &pred_code
, &arm1
,
4221 cond_stmt
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
,
4223 gimple_set_no_warning (cond_stmt
, TREE_NO_WARNING (COND_EXPR_COND (expr
)));
4224 gimplify_seq_add_stmt (&seq
, cond_stmt
);
4225 gimple_stmt_iterator gsi
= gsi_last (seq
);
4226 maybe_fold_stmt (&gsi
);
4228 label_cont
= NULL_TREE
;
4229 if (!have_then_clause_p
)
4231 /* For if (...) {} else { code; } put label_true after
4233 if (TREE_OPERAND (expr
, 1) == NULL_TREE
4234 && !have_else_clause_p
4235 && TREE_OPERAND (expr
, 2) != NULL_TREE
)
4236 label_cont
= label_true
;
4239 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_true
));
4240 have_then_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 1), &seq
);
4241 /* For if (...) { code; } else {} or
4242 if (...) { code; } else goto label; or
4243 if (...) { code; return; } else { ... }
4244 label_cont isn't needed. */
4245 if (!have_else_clause_p
4246 && TREE_OPERAND (expr
, 2) != NULL_TREE
4247 && gimple_seq_may_fallthru (seq
))
4250 label_cont
= create_artificial_label (UNKNOWN_LOCATION
);
4252 g
= gimple_build_goto (label_cont
);
4254 /* GIMPLE_COND's are very low level; they have embedded
4255 gotos. This particular embedded goto should not be marked
4256 with the location of the original COND_EXPR, as it would
4257 correspond to the COND_EXPR's condition, not the ELSE or the
4258 THEN arms. To avoid marking it with the wrong location, flag
4259 it as "no location". */
4260 gimple_set_do_not_emit_location (g
);
4262 gimplify_seq_add_stmt (&seq
, g
);
4266 if (!have_else_clause_p
)
4268 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_false
));
4269 have_else_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 2), &seq
);
4272 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_cont
));
4274 gimple_pop_condition (pre_p
);
4275 gimple_seq_add_seq (pre_p
, seq
);
4277 if (ret
== GS_ERROR
)
4279 else if (have_then_clause_p
|| have_else_clause_p
)
4283 /* Both arms are empty; replace the COND_EXPR with its predicate. */
4284 expr
= TREE_OPERAND (expr
, 0);
4285 gimplify_stmt (&expr
, pre_p
);
4292 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
4293 to be marked addressable.
4295 We cannot rely on such an expression being directly markable if a temporary
4296 has been created by the gimplification. In this case, we create another
4297 temporary and initialize it with a copy, which will become a store after we
4298 mark it addressable. This can happen if the front-end passed us something
4299 that it could not mark addressable yet, like a Fortran pass-by-reference
4300 parameter (int) floatvar. */
4303 prepare_gimple_addressable (tree
*expr_p
, gimple_seq
*seq_p
)
4305 while (handled_component_p (*expr_p
))
4306 expr_p
= &TREE_OPERAND (*expr_p
, 0);
4307 if (is_gimple_reg (*expr_p
))
4309 /* Do not allow an SSA name as the temporary. */
4310 tree var
= get_initialized_tmp_var (*expr_p
, seq_p
, NULL
, false);
4311 DECL_GIMPLE_REG_P (var
) = 0;
4316 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
4317 a call to __builtin_memcpy. */
4319 static enum gimplify_status
4320 gimplify_modify_expr_to_memcpy (tree
*expr_p
, tree size
, bool want_value
,
4323 tree t
, to
, to_ptr
, from
, from_ptr
;
4325 location_t loc
= EXPR_LOCATION (*expr_p
);
4327 to
= TREE_OPERAND (*expr_p
, 0);
4328 from
= TREE_OPERAND (*expr_p
, 1);
4330 /* Mark the RHS addressable. Beware that it may not be possible to do so
4331 directly if a temporary has been created by the gimplification. */
4332 prepare_gimple_addressable (&from
, seq_p
);
4334 mark_addressable (from
);
4335 from_ptr
= build_fold_addr_expr_loc (loc
, from
);
4336 gimplify_arg (&from_ptr
, seq_p
, loc
);
4338 mark_addressable (to
);
4339 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
4340 gimplify_arg (&to_ptr
, seq_p
, loc
);
4342 t
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
4344 gs
= gimple_build_call (t
, 3, to_ptr
, from_ptr
, size
);
4348 /* tmp = memcpy() */
4349 t
= create_tmp_var (TREE_TYPE (to_ptr
));
4350 gimple_call_set_lhs (gs
, t
);
4351 gimplify_seq_add_stmt (seq_p
, gs
);
4353 *expr_p
= build_simple_mem_ref (t
);
4357 gimplify_seq_add_stmt (seq_p
, gs
);
4362 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
4363 a call to __builtin_memset. In this case we know that the RHS is
4364 a CONSTRUCTOR with an empty element list. */
4366 static enum gimplify_status
4367 gimplify_modify_expr_to_memset (tree
*expr_p
, tree size
, bool want_value
,
4370 tree t
, from
, to
, to_ptr
;
4372 location_t loc
= EXPR_LOCATION (*expr_p
);
4374 /* Assert our assumptions, to abort instead of producing wrong code
4375 silently if they are not met. Beware that the RHS CONSTRUCTOR might
4376 not be immediately exposed. */
4377 from
= TREE_OPERAND (*expr_p
, 1);
4378 if (TREE_CODE (from
) == WITH_SIZE_EXPR
)
4379 from
= TREE_OPERAND (from
, 0);
4381 gcc_assert (TREE_CODE (from
) == CONSTRUCTOR
4382 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from
)));
4385 to
= TREE_OPERAND (*expr_p
, 0);
4387 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
4388 gimplify_arg (&to_ptr
, seq_p
, loc
);
4389 t
= builtin_decl_implicit (BUILT_IN_MEMSET
);
4391 gs
= gimple_build_call (t
, 3, to_ptr
, integer_zero_node
, size
);
4395 /* tmp = memset() */
4396 t
= create_tmp_var (TREE_TYPE (to_ptr
));
4397 gimple_call_set_lhs (gs
, t
);
4398 gimplify_seq_add_stmt (seq_p
, gs
);
4400 *expr_p
= build1 (INDIRECT_REF
, TREE_TYPE (to
), t
);
4404 gimplify_seq_add_stmt (seq_p
, gs
);
4409 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
4410 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
4411 assignment. Return non-null if we detect a potential overlap. */
4413 struct gimplify_init_ctor_preeval_data
4415 /* The base decl of the lhs object. May be NULL, in which case we
4416 have to assume the lhs is indirect. */
4419 /* The alias set of the lhs object. */
4420 alias_set_type lhs_alias_set
;
4424 gimplify_init_ctor_preeval_1 (tree
*tp
, int *walk_subtrees
, void *xdata
)
4426 struct gimplify_init_ctor_preeval_data
*data
4427 = (struct gimplify_init_ctor_preeval_data
*) xdata
;
4430 /* If we find the base object, obviously we have overlap. */
4431 if (data
->lhs_base_decl
== t
)
4434 /* If the constructor component is indirect, determine if we have a
4435 potential overlap with the lhs. The only bits of information we
4436 have to go on at this point are addressability and alias sets. */
4437 if ((INDIRECT_REF_P (t
)
4438 || TREE_CODE (t
) == MEM_REF
)
4439 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
4440 && alias_sets_conflict_p (data
->lhs_alias_set
, get_alias_set (t
)))
4443 /* If the constructor component is a call, determine if it can hide a
4444 potential overlap with the lhs through an INDIRECT_REF like above.
4445 ??? Ugh - this is completely broken. In fact this whole analysis
4446 doesn't look conservative. */
4447 if (TREE_CODE (t
) == CALL_EXPR
)
4449 tree type
, fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t
)));
4451 for (type
= TYPE_ARG_TYPES (fntype
); type
; type
= TREE_CHAIN (type
))
4452 if (POINTER_TYPE_P (TREE_VALUE (type
))
4453 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
4454 && alias_sets_conflict_p (data
->lhs_alias_set
,
4456 (TREE_TYPE (TREE_VALUE (type
)))))
4460 if (IS_TYPE_OR_DECL_P (t
))
4465 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
4466 force values that overlap with the lhs (as described by *DATA)
4467 into temporaries. */
4470 gimplify_init_ctor_preeval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4471 struct gimplify_init_ctor_preeval_data
*data
)
4473 enum gimplify_status one
;
4475 /* If the value is constant, then there's nothing to pre-evaluate. */
4476 if (TREE_CONSTANT (*expr_p
))
4478 /* Ensure it does not have side effects, it might contain a reference to
4479 the object we're initializing. */
4480 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p
));
4484 /* If the type has non-trivial constructors, we can't pre-evaluate. */
4485 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p
)))
4488 /* Recurse for nested constructors. */
4489 if (TREE_CODE (*expr_p
) == CONSTRUCTOR
)
4491 unsigned HOST_WIDE_INT ix
;
4492 constructor_elt
*ce
;
4493 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (*expr_p
);
4495 FOR_EACH_VEC_SAFE_ELT (v
, ix
, ce
)
4496 gimplify_init_ctor_preeval (&ce
->value
, pre_p
, post_p
, data
);
4501 /* If this is a variable sized type, we must remember the size. */
4502 maybe_with_size_expr (expr_p
);
4504 /* Gimplify the constructor element to something appropriate for the rhs
4505 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
4506 the gimplifier will consider this a store to memory. Doing this
4507 gimplification now means that we won't have to deal with complicated
4508 language-specific trees, nor trees like SAVE_EXPR that can induce
4509 exponential search behavior. */
4510 one
= gimplify_expr (expr_p
, pre_p
, post_p
, is_gimple_mem_rhs
, fb_rvalue
);
4511 if (one
== GS_ERROR
)
4517 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
4518 with the lhs, since "a = { .x=a }" doesn't make sense. This will
4519 always be true for all scalars, since is_gimple_mem_rhs insists on a
4520 temporary variable for them. */
4521 if (DECL_P (*expr_p
))
4524 /* If this is of variable size, we have no choice but to assume it doesn't
4525 overlap since we can't make a temporary for it. */
4526 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p
))) != INTEGER_CST
)
4529 /* Otherwise, we must search for overlap ... */
4530 if (!walk_tree (expr_p
, gimplify_init_ctor_preeval_1
, data
, NULL
))
4533 /* ... and if found, force the value into a temporary. */
4534 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
4537 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
4538 a RANGE_EXPR in a CONSTRUCTOR for an array.
4542 object[var] = value;
4549 We increment var _after_ the loop exit check because we might otherwise
4550 fail if upper == TYPE_MAX_VALUE (type for upper).
4552 Note that we never have to deal with SAVE_EXPRs here, because this has
4553 already been taken care of for us, in gimplify_init_ctor_preeval(). */
4555 static void gimplify_init_ctor_eval (tree
, vec
<constructor_elt
, va_gc
> *,
4556 gimple_seq
*, bool);
4559 gimplify_init_ctor_eval_range (tree object
, tree lower
, tree upper
,
4560 tree value
, tree array_elt_type
,
4561 gimple_seq
*pre_p
, bool cleared
)
4563 tree loop_entry_label
, loop_exit_label
, fall_thru_label
;
4564 tree var
, var_type
, cref
, tmp
;
4566 loop_entry_label
= create_artificial_label (UNKNOWN_LOCATION
);
4567 loop_exit_label
= create_artificial_label (UNKNOWN_LOCATION
);
4568 fall_thru_label
= create_artificial_label (UNKNOWN_LOCATION
);
4570 /* Create and initialize the index variable. */
4571 var_type
= TREE_TYPE (upper
);
4572 var
= create_tmp_var (var_type
);
4573 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, lower
));
4575 /* Add the loop entry label. */
4576 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_entry_label
));
4578 /* Build the reference. */
4579 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
4580 var
, NULL_TREE
, NULL_TREE
);
4582 /* If we are a constructor, just call gimplify_init_ctor_eval to do
4583 the store. Otherwise just assign value to the reference. */
4585 if (TREE_CODE (value
) == CONSTRUCTOR
)
4586 /* NB we might have to call ourself recursively through
4587 gimplify_init_ctor_eval if the value is a constructor. */
4588 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
4591 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (cref
, value
));
4593 /* We exit the loop when the index var is equal to the upper bound. */
4594 gimplify_seq_add_stmt (pre_p
,
4595 gimple_build_cond (EQ_EXPR
, var
, upper
,
4596 loop_exit_label
, fall_thru_label
));
4598 gimplify_seq_add_stmt (pre_p
, gimple_build_label (fall_thru_label
));
4600 /* Otherwise, increment the index var... */
4601 tmp
= build2 (PLUS_EXPR
, var_type
, var
,
4602 fold_convert (var_type
, integer_one_node
));
4603 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, tmp
));
4605 /* ...and jump back to the loop entry. */
4606 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (loop_entry_label
));
4608 /* Add the loop exit label. */
4609 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_exit_label
));
4612 /* Return true if FDECL is accessing a field that is zero sized. */
4615 zero_sized_field_decl (const_tree fdecl
)
4617 if (TREE_CODE (fdecl
) == FIELD_DECL
&& DECL_SIZE (fdecl
)
4618 && integer_zerop (DECL_SIZE (fdecl
)))
4623 /* Return true if TYPE is zero sized. */
4626 zero_sized_type (const_tree type
)
4628 if (AGGREGATE_TYPE_P (type
) && TYPE_SIZE (type
)
4629 && integer_zerop (TYPE_SIZE (type
)))
4634 /* A subroutine of gimplify_init_constructor. Generate individual
4635 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
4636 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
4637 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
4641 gimplify_init_ctor_eval (tree object
, vec
<constructor_elt
, va_gc
> *elts
,
4642 gimple_seq
*pre_p
, bool cleared
)
4644 tree array_elt_type
= NULL
;
4645 unsigned HOST_WIDE_INT ix
;
4646 tree purpose
, value
;
4648 if (TREE_CODE (TREE_TYPE (object
)) == ARRAY_TYPE
)
4649 array_elt_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object
)));
4651 FOR_EACH_CONSTRUCTOR_ELT (elts
, ix
, purpose
, value
)
4655 /* NULL values are created above for gimplification errors. */
4659 if (cleared
&& initializer_zerop (value
))
4662 /* ??? Here's to hoping the front end fills in all of the indices,
4663 so we don't have to figure out what's missing ourselves. */
4664 gcc_assert (purpose
);
4666 /* Skip zero-sized fields, unless value has side-effects. This can
4667 happen with calls to functions returning a zero-sized type, which
4668 we shouldn't discard. As a number of downstream passes don't
4669 expect sets of zero-sized fields, we rely on the gimplification of
4670 the MODIFY_EXPR we make below to drop the assignment statement. */
4671 if (! TREE_SIDE_EFFECTS (value
) && zero_sized_field_decl (purpose
))
4674 /* If we have a RANGE_EXPR, we have to build a loop to assign the
4676 if (TREE_CODE (purpose
) == RANGE_EXPR
)
4678 tree lower
= TREE_OPERAND (purpose
, 0);
4679 tree upper
= TREE_OPERAND (purpose
, 1);
4681 /* If the lower bound is equal to upper, just treat it as if
4682 upper was the index. */
4683 if (simple_cst_equal (lower
, upper
))
4687 gimplify_init_ctor_eval_range (object
, lower
, upper
, value
,
4688 array_elt_type
, pre_p
, cleared
);
4695 /* Do not use bitsizetype for ARRAY_REF indices. */
4696 if (TYPE_DOMAIN (TREE_TYPE (object
)))
4698 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object
))),
4700 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
4701 purpose
, NULL_TREE
, NULL_TREE
);
4705 gcc_assert (TREE_CODE (purpose
) == FIELD_DECL
);
4706 cref
= build3 (COMPONENT_REF
, TREE_TYPE (purpose
),
4707 unshare_expr (object
), purpose
, NULL_TREE
);
4710 if (TREE_CODE (value
) == CONSTRUCTOR
4711 && TREE_CODE (TREE_TYPE (value
)) != VECTOR_TYPE
)
4712 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
4716 tree init
= build2 (INIT_EXPR
, TREE_TYPE (cref
), cref
, value
);
4717 gimplify_and_add (init
, pre_p
);
4723 /* Return the appropriate RHS predicate for this LHS. */
4726 rhs_predicate_for (tree lhs
)
4728 if (is_gimple_reg (lhs
))
4729 return is_gimple_reg_rhs_or_call
;
4731 return is_gimple_mem_rhs_or_call
;
4734 /* Return the initial guess for an appropriate RHS predicate for this LHS,
4735 before the LHS has been gimplified. */
4737 static gimple_predicate
4738 initial_rhs_predicate_for (tree lhs
)
4740 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
4741 return is_gimple_reg_rhs_or_call
;
4743 return is_gimple_mem_rhs_or_call
;
4746 /* Gimplify a C99 compound literal expression. This just means adding
4747 the DECL_EXPR before the current statement and using its anonymous
4750 static enum gimplify_status
4751 gimplify_compound_literal_expr (tree
*expr_p
, gimple_seq
*pre_p
,
4752 bool (*gimple_test_f
) (tree
),
4753 fallback_t fallback
)
4755 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p
);
4756 tree decl
= DECL_EXPR_DECL (decl_s
);
4757 tree init
= DECL_INITIAL (decl
);
4758 /* Mark the decl as addressable if the compound literal
4759 expression is addressable now, otherwise it is marked too late
4760 after we gimplify the initialization expression. */
4761 if (TREE_ADDRESSABLE (*expr_p
))
4762 TREE_ADDRESSABLE (decl
) = 1;
4763 /* Otherwise, if we don't need an lvalue and have a literal directly
4764 substitute it. Check if it matches the gimple predicate, as
4765 otherwise we'd generate a new temporary, and we can as well just
4766 use the decl we already have. */
4767 else if (!TREE_ADDRESSABLE (decl
)
4768 && !TREE_THIS_VOLATILE (decl
)
4770 && (fallback
& fb_lvalue
) == 0
4771 && gimple_test_f (init
))
4777 /* Preliminarily mark non-addressed complex variables as eligible
4778 for promotion to gimple registers. We'll transform their uses
4780 if ((TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
4781 || TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
)
4782 && !TREE_THIS_VOLATILE (decl
)
4783 && !needs_to_live_in_memory (decl
))
4784 DECL_GIMPLE_REG_P (decl
) = 1;
4786 /* If the decl is not addressable, then it is being used in some
4787 expression or on the right hand side of a statement, and it can
4788 be put into a readonly data section. */
4789 if (!TREE_ADDRESSABLE (decl
) && (fallback
& fb_lvalue
) == 0)
4790 TREE_READONLY (decl
) = 1;
4792 /* This decl isn't mentioned in the enclosing block, so add it to the
4793 list of temps. FIXME it seems a bit of a kludge to say that
4794 anonymous artificial vars aren't pushed, but everything else is. */
4795 if (DECL_NAME (decl
) == NULL_TREE
&& !DECL_SEEN_IN_BIND_EXPR_P (decl
))
4796 gimple_add_tmp_var (decl
);
4798 gimplify_and_add (decl_s
, pre_p
);
4803 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
4804 return a new CONSTRUCTOR if something changed. */
4807 optimize_compound_literals_in_ctor (tree orig_ctor
)
4809 tree ctor
= orig_ctor
;
4810 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
4811 unsigned int idx
, num
= vec_safe_length (elts
);
4813 for (idx
= 0; idx
< num
; idx
++)
4815 tree value
= (*elts
)[idx
].value
;
4816 tree newval
= value
;
4817 if (TREE_CODE (value
) == CONSTRUCTOR
)
4818 newval
= optimize_compound_literals_in_ctor (value
);
4819 else if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
4821 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (value
);
4822 tree decl
= DECL_EXPR_DECL (decl_s
);
4823 tree init
= DECL_INITIAL (decl
);
4825 if (!TREE_ADDRESSABLE (value
)
4826 && !TREE_ADDRESSABLE (decl
)
4828 && TREE_CODE (init
) == CONSTRUCTOR
)
4829 newval
= optimize_compound_literals_in_ctor (init
);
4831 if (newval
== value
)
4834 if (ctor
== orig_ctor
)
4836 ctor
= copy_node (orig_ctor
);
4837 CONSTRUCTOR_ELTS (ctor
) = vec_safe_copy (elts
);
4838 elts
= CONSTRUCTOR_ELTS (ctor
);
4840 (*elts
)[idx
].value
= newval
;
4845 /* A subroutine of gimplify_modify_expr. Break out elements of a
4846 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
4848 Note that we still need to clear any elements that don't have explicit
4849 initializers, so if not all elements are initialized we keep the
4850 original MODIFY_EXPR, we just remove all of the constructor elements.
4852 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
4853 GS_ERROR if we would have to create a temporary when gimplifying
4854 this constructor. Otherwise, return GS_OK.
4856 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
4858 static enum gimplify_status
4859 gimplify_init_constructor (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4860 bool want_value
, bool notify_temp_creation
)
4862 tree object
, ctor
, type
;
4863 enum gimplify_status ret
;
4864 vec
<constructor_elt
, va_gc
> *elts
;
4866 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == CONSTRUCTOR
);
4868 if (!notify_temp_creation
)
4870 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
4871 is_gimple_lvalue
, fb_lvalue
);
4872 if (ret
== GS_ERROR
)
4876 object
= TREE_OPERAND (*expr_p
, 0);
4877 ctor
= TREE_OPERAND (*expr_p
, 1)
4878 = optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p
, 1));
4879 type
= TREE_TYPE (ctor
);
4880 elts
= CONSTRUCTOR_ELTS (ctor
);
4883 switch (TREE_CODE (type
))
4887 case QUAL_UNION_TYPE
:
4890 struct gimplify_init_ctor_preeval_data preeval_data
;
4891 HOST_WIDE_INT num_ctor_elements
, num_nonzero_elements
;
4892 HOST_WIDE_INT num_unique_nonzero_elements
;
4893 bool cleared
, complete_p
, valid_const_initializer
;
4894 /* Use readonly data for initializers of this or smaller size
4895 regardless of the num_nonzero_elements / num_unique_nonzero_elements
4897 const HOST_WIDE_INT min_unique_size
= 64;
4898 /* If num_nonzero_elements / num_unique_nonzero_elements ratio
4899 is smaller than this, use readonly data. */
4900 const int unique_nonzero_ratio
= 8;
4902 /* Aggregate types must lower constructors to initialization of
4903 individual elements. The exception is that a CONSTRUCTOR node
4904 with no elements indicates zero-initialization of the whole. */
4905 if (vec_safe_is_empty (elts
))
4907 if (notify_temp_creation
)
4912 /* Fetch information about the constructor to direct later processing.
4913 We might want to make static versions of it in various cases, and
4914 can only do so if it known to be a valid constant initializer. */
4915 valid_const_initializer
4916 = categorize_ctor_elements (ctor
, &num_nonzero_elements
,
4917 &num_unique_nonzero_elements
,
4918 &num_ctor_elements
, &complete_p
);
4920 /* If a const aggregate variable is being initialized, then it
4921 should never be a lose to promote the variable to be static. */
4922 if (valid_const_initializer
4923 && num_nonzero_elements
> 1
4924 && TREE_READONLY (object
)
4926 && !DECL_REGISTER (object
)
4927 && (flag_merge_constants
>= 2 || !TREE_ADDRESSABLE (object
))
4928 /* For ctors that have many repeated nonzero elements
4929 represented through RANGE_EXPRs, prefer initializing
4930 those through runtime loops over copies of large amounts
4931 of data from readonly data section. */
4932 && (num_unique_nonzero_elements
4933 > num_nonzero_elements
/ unique_nonzero_ratio
4934 || ((unsigned HOST_WIDE_INT
) int_size_in_bytes (type
)
4935 <= (unsigned HOST_WIDE_INT
) min_unique_size
)))
4937 if (notify_temp_creation
)
4939 DECL_INITIAL (object
) = ctor
;
4940 TREE_STATIC (object
) = 1;
4941 if (!DECL_NAME (object
))
4942 DECL_NAME (object
) = create_tmp_var_name ("C");
4943 walk_tree (&DECL_INITIAL (object
), force_labels_r
, NULL
, NULL
);
4945 /* ??? C++ doesn't automatically append a .<number> to the
4946 assembler name, and even when it does, it looks at FE private
4947 data structures to figure out what that number should be,
4948 which are not set for this variable. I suppose this is
4949 important for local statics for inline functions, which aren't
4950 "local" in the object file sense. So in order to get a unique
4951 TU-local symbol, we must invoke the lhd version now. */
4952 lhd_set_decl_assembler_name (object
);
4954 *expr_p
= NULL_TREE
;
4958 /* If there are "lots" of initialized elements, even discounting
4959 those that are not address constants (and thus *must* be
4960 computed at runtime), then partition the constructor into
4961 constant and non-constant parts. Block copy the constant
4962 parts in, then generate code for the non-constant parts. */
4963 /* TODO. There's code in cp/typeck.c to do this. */
4965 if (int_size_in_bytes (TREE_TYPE (ctor
)) < 0)
4966 /* store_constructor will ignore the clearing of variable-sized
4967 objects. Initializers for such objects must explicitly set
4968 every field that needs to be set. */
4970 else if (!complete_p
)
4971 /* If the constructor isn't complete, clear the whole object
4972 beforehand, unless CONSTRUCTOR_NO_CLEARING is set on it.
4974 ??? This ought not to be needed. For any element not present
4975 in the initializer, we should simply set them to zero. Except
4976 we'd need to *find* the elements that are not present, and that
4977 requires trickery to avoid quadratic compile-time behavior in
4978 large cases or excessive memory use in small cases. */
4979 cleared
= !CONSTRUCTOR_NO_CLEARING (ctor
);
4980 else if (num_ctor_elements
- num_nonzero_elements
4981 > CLEAR_RATIO (optimize_function_for_speed_p (cfun
))
4982 && num_nonzero_elements
< num_ctor_elements
/ 4)
4983 /* If there are "lots" of zeros, it's more efficient to clear
4984 the memory and then set the nonzero elements. */
4989 /* If there are "lots" of initialized elements, and all of them
4990 are valid address constants, then the entire initializer can
4991 be dropped to memory, and then memcpy'd out. Don't do this
4992 for sparse arrays, though, as it's more efficient to follow
4993 the standard CONSTRUCTOR behavior of memset followed by
4994 individual element initialization. Also don't do this for small
4995 all-zero initializers (which aren't big enough to merit
4996 clearing), and don't try to make bitwise copies of
4997 TREE_ADDRESSABLE types. */
4999 if (valid_const_initializer
5000 && !(cleared
|| num_nonzero_elements
== 0)
5001 && !TREE_ADDRESSABLE (type
))
5003 HOST_WIDE_INT size
= int_size_in_bytes (type
);
5006 /* ??? We can still get unbounded array types, at least
5007 from the C++ front end. This seems wrong, but attempt
5008 to work around it for now. */
5011 size
= int_size_in_bytes (TREE_TYPE (object
));
5013 TREE_TYPE (ctor
) = type
= TREE_TYPE (object
);
5016 /* Find the maximum alignment we can assume for the object. */
5017 /* ??? Make use of DECL_OFFSET_ALIGN. */
5018 if (DECL_P (object
))
5019 align
= DECL_ALIGN (object
);
5021 align
= TYPE_ALIGN (type
);
5023 /* Do a block move either if the size is so small as to make
5024 each individual move a sub-unit move on average, or if it
5025 is so large as to make individual moves inefficient. */
5027 && num_nonzero_elements
> 1
5028 /* For ctors that have many repeated nonzero elements
5029 represented through RANGE_EXPRs, prefer initializing
5030 those through runtime loops over copies of large amounts
5031 of data from readonly data section. */
5032 && (num_unique_nonzero_elements
5033 > num_nonzero_elements
/ unique_nonzero_ratio
5034 || size
<= min_unique_size
)
5035 && (size
< num_nonzero_elements
5036 || !can_move_by_pieces (size
, align
)))
5038 if (notify_temp_creation
)
5041 walk_tree (&ctor
, force_labels_r
, NULL
, NULL
);
5042 ctor
= tree_output_constant_def (ctor
);
5043 if (!useless_type_conversion_p (type
, TREE_TYPE (ctor
)))
5044 ctor
= build1 (VIEW_CONVERT_EXPR
, type
, ctor
);
5045 TREE_OPERAND (*expr_p
, 1) = ctor
;
5047 /* This is no longer an assignment of a CONSTRUCTOR, but
5048 we still may have processing to do on the LHS. So
5049 pretend we didn't do anything here to let that happen. */
5050 return GS_UNHANDLED
;
5054 /* If the target is volatile, we have non-zero elements and more than
5055 one field to assign, initialize the target from a temporary. */
5056 if (TREE_THIS_VOLATILE (object
)
5057 && !TREE_ADDRESSABLE (type
)
5058 && (num_nonzero_elements
> 0 || !cleared
)
5059 && vec_safe_length (elts
) > 1)
5061 tree temp
= create_tmp_var (TYPE_MAIN_VARIANT (type
));
5062 TREE_OPERAND (*expr_p
, 0) = temp
;
5063 *expr_p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*expr_p
),
5065 build2 (MODIFY_EXPR
, void_type_node
,
5070 if (notify_temp_creation
)
5073 /* If there are nonzero elements and if needed, pre-evaluate to capture
5074 elements overlapping with the lhs into temporaries. We must do this
5075 before clearing to fetch the values before they are zeroed-out. */
5076 if (num_nonzero_elements
> 0 && TREE_CODE (*expr_p
) != INIT_EXPR
)
5078 preeval_data
.lhs_base_decl
= get_base_address (object
);
5079 if (!DECL_P (preeval_data
.lhs_base_decl
))
5080 preeval_data
.lhs_base_decl
= NULL
;
5081 preeval_data
.lhs_alias_set
= get_alias_set (object
);
5083 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p
, 1),
5084 pre_p
, post_p
, &preeval_data
);
5087 bool ctor_has_side_effects_p
5088 = TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p
, 1));
5092 /* Zap the CONSTRUCTOR element list, which simplifies this case.
5093 Note that we still have to gimplify, in order to handle the
5094 case of variable sized types. Avoid shared tree structures. */
5095 CONSTRUCTOR_ELTS (ctor
) = NULL
;
5096 TREE_SIDE_EFFECTS (ctor
) = 0;
5097 object
= unshare_expr (object
);
5098 gimplify_stmt (expr_p
, pre_p
);
5101 /* If we have not block cleared the object, or if there are nonzero
5102 elements in the constructor, or if the constructor has side effects,
5103 add assignments to the individual scalar fields of the object. */
5105 || num_nonzero_elements
> 0
5106 || ctor_has_side_effects_p
)
5107 gimplify_init_ctor_eval (object
, elts
, pre_p
, cleared
);
5109 *expr_p
= NULL_TREE
;
5117 if (notify_temp_creation
)
5120 /* Extract the real and imaginary parts out of the ctor. */
5121 gcc_assert (elts
->length () == 2);
5122 r
= (*elts
)[0].value
;
5123 i
= (*elts
)[1].value
;
5124 if (r
== NULL
|| i
== NULL
)
5126 tree zero
= build_zero_cst (TREE_TYPE (type
));
5133 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
5134 represent creation of a complex value. */
5135 if (TREE_CONSTANT (r
) && TREE_CONSTANT (i
))
5137 ctor
= build_complex (type
, r
, i
);
5138 TREE_OPERAND (*expr_p
, 1) = ctor
;
5142 ctor
= build2 (COMPLEX_EXPR
, type
, r
, i
);
5143 TREE_OPERAND (*expr_p
, 1) = ctor
;
5144 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1),
5147 rhs_predicate_for (TREE_OPERAND (*expr_p
, 0)),
5155 unsigned HOST_WIDE_INT ix
;
5156 constructor_elt
*ce
;
5158 if (notify_temp_creation
)
5161 /* Go ahead and simplify constant constructors to VECTOR_CST. */
5162 if (TREE_CONSTANT (ctor
))
5164 bool constant_p
= true;
5167 /* Even when ctor is constant, it might contain non-*_CST
5168 elements, such as addresses or trapping values like
5169 1.0/0.0 - 1.0/0.0. Such expressions don't belong
5170 in VECTOR_CST nodes. */
5171 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
5172 if (!CONSTANT_CLASS_P (value
))
5180 TREE_OPERAND (*expr_p
, 1) = build_vector_from_ctor (type
, elts
);
5184 TREE_CONSTANT (ctor
) = 0;
5187 /* Vector types use CONSTRUCTOR all the way through gimple
5188 compilation as a general initializer. */
5189 FOR_EACH_VEC_SAFE_ELT (elts
, ix
, ce
)
5191 enum gimplify_status tret
;
5192 tret
= gimplify_expr (&ce
->value
, pre_p
, post_p
, is_gimple_val
,
5194 if (tret
== GS_ERROR
)
5196 else if (TREE_STATIC (ctor
)
5197 && !initializer_constant_valid_p (ce
->value
,
5198 TREE_TYPE (ce
->value
)))
5199 TREE_STATIC (ctor
) = 0;
5201 if (!is_gimple_reg (TREE_OPERAND (*expr_p
, 0)))
5202 TREE_OPERAND (*expr_p
, 1) = get_formal_tmp_var (ctor
, pre_p
);
5207 /* So how did we get a CONSTRUCTOR for a scalar type? */
5211 if (ret
== GS_ERROR
)
5213 /* If we have gimplified both sides of the initializer but have
5214 not emitted an assignment, do so now. */
5217 tree lhs
= TREE_OPERAND (*expr_p
, 0);
5218 tree rhs
= TREE_OPERAND (*expr_p
, 1);
5219 if (want_value
&& object
== lhs
)
5220 lhs
= unshare_expr (lhs
);
5221 gassign
*init
= gimple_build_assign (lhs
, rhs
);
5222 gimplify_seq_add_stmt (pre_p
, init
);
5236 /* Given a pointer value OP0, return a simplified version of an
5237 indirection through OP0, or NULL_TREE if no simplification is
5238 possible. This may only be applied to a rhs of an expression.
5239 Note that the resulting type may be different from the type pointed
5240 to in the sense that it is still compatible from the langhooks
5244 gimple_fold_indirect_ref_rhs (tree t
)
5246 return gimple_fold_indirect_ref (t
);
5249 /* Subroutine of gimplify_modify_expr to do simplifications of
5250 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
5251 something changes. */
5253 static enum gimplify_status
5254 gimplify_modify_expr_rhs (tree
*expr_p
, tree
*from_p
, tree
*to_p
,
5255 gimple_seq
*pre_p
, gimple_seq
*post_p
,
5258 enum gimplify_status ret
= GS_UNHANDLED
;
5264 switch (TREE_CODE (*from_p
))
5267 /* If we're assigning from a read-only variable initialized with
5268 a constructor, do the direct assignment from the constructor,
5269 but only if neither source nor target are volatile since this
5270 latter assignment might end up being done on a per-field basis. */
5271 if (DECL_INITIAL (*from_p
)
5272 && TREE_READONLY (*from_p
)
5273 && !TREE_THIS_VOLATILE (*from_p
)
5274 && !TREE_THIS_VOLATILE (*to_p
)
5275 && TREE_CODE (DECL_INITIAL (*from_p
)) == CONSTRUCTOR
)
5277 tree old_from
= *from_p
;
5278 enum gimplify_status subret
;
5280 /* Move the constructor into the RHS. */
5281 *from_p
= unshare_expr (DECL_INITIAL (*from_p
));
5283 /* Let's see if gimplify_init_constructor will need to put
5285 subret
= gimplify_init_constructor (expr_p
, NULL
, NULL
,
5287 if (subret
== GS_ERROR
)
5289 /* If so, revert the change. */
5301 /* If we have code like
5305 where the type of "x" is a (possibly cv-qualified variant
5306 of "A"), treat the entire expression as identical to "x".
5307 This kind of code arises in C++ when an object is bound
5308 to a const reference, and if "x" is a TARGET_EXPR we want
5309 to take advantage of the optimization below. */
5310 bool volatile_p
= TREE_THIS_VOLATILE (*from_p
);
5311 tree t
= gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p
, 0));
5314 if (TREE_THIS_VOLATILE (t
) != volatile_p
)
5317 t
= build_simple_mem_ref_loc (EXPR_LOCATION (*from_p
),
5318 build_fold_addr_expr (t
));
5319 if (REFERENCE_CLASS_P (t
))
5320 TREE_THIS_VOLATILE (t
) = volatile_p
;
5331 /* If we are initializing something from a TARGET_EXPR, strip the
5332 TARGET_EXPR and initialize it directly, if possible. This can't
5333 be done if the initializer is void, since that implies that the
5334 temporary is set in some non-trivial way.
5336 ??? What about code that pulls out the temp and uses it
5337 elsewhere? I think that such code never uses the TARGET_EXPR as
5338 an initializer. If I'm wrong, we'll die because the temp won't
5339 have any RTL. In that case, I guess we'll need to replace
5340 references somehow. */
5341 tree init
= TARGET_EXPR_INITIAL (*from_p
);
5344 && (TREE_CODE (*expr_p
) != MODIFY_EXPR
5345 || !TARGET_EXPR_NO_ELIDE (*from_p
))
5346 && !VOID_TYPE_P (TREE_TYPE (init
)))
5356 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
5358 gimplify_compound_expr (from_p
, pre_p
, true);
5364 /* If we already made some changes, let the front end have a
5365 crack at this before we break it down. */
5366 if (ret
!= GS_UNHANDLED
)
5368 /* If we're initializing from a CONSTRUCTOR, break this into
5369 individual MODIFY_EXPRs. */
5370 return gimplify_init_constructor (expr_p
, pre_p
, post_p
, want_value
,
5374 /* If we're assigning to a non-register type, push the assignment
5375 down into the branches. This is mandatory for ADDRESSABLE types,
5376 since we cannot generate temporaries for such, but it saves a
5377 copy in other cases as well. */
5378 if (!is_gimple_reg_type (TREE_TYPE (*from_p
)))
5380 /* This code should mirror the code in gimplify_cond_expr. */
5381 enum tree_code code
= TREE_CODE (*expr_p
);
5382 tree cond
= *from_p
;
5383 tree result
= *to_p
;
5385 ret
= gimplify_expr (&result
, pre_p
, post_p
,
5386 is_gimple_lvalue
, fb_lvalue
);
5387 if (ret
!= GS_ERROR
)
5390 /* If we are going to write RESULT more than once, clear
5391 TREE_READONLY flag, otherwise we might incorrectly promote
5392 the variable to static const and initialize it at compile
5393 time in one of the branches. */
5395 && TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
5396 && TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
5397 TREE_READONLY (result
) = 0;
5398 if (TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
)
5399 TREE_OPERAND (cond
, 1)
5400 = build2 (code
, void_type_node
, result
,
5401 TREE_OPERAND (cond
, 1));
5402 if (TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
5403 TREE_OPERAND (cond
, 2)
5404 = build2 (code
, void_type_node
, unshare_expr (result
),
5405 TREE_OPERAND (cond
, 2));
5407 TREE_TYPE (cond
) = void_type_node
;
5408 recalculate_side_effects (cond
);
5412 gimplify_and_add (cond
, pre_p
);
5413 *expr_p
= unshare_expr (result
);
5422 /* For calls that return in memory, give *to_p as the CALL_EXPR's
5423 return slot so that we don't generate a temporary. */
5424 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p
)
5425 && aggregate_value_p (*from_p
, *from_p
))
5429 if (!(rhs_predicate_for (*to_p
))(*from_p
))
5430 /* If we need a temporary, *to_p isn't accurate. */
5432 /* It's OK to use the return slot directly unless it's an NRV. */
5433 else if (TREE_CODE (*to_p
) == RESULT_DECL
5434 && DECL_NAME (*to_p
) == NULL_TREE
5435 && needs_to_live_in_memory (*to_p
))
5437 else if (is_gimple_reg_type (TREE_TYPE (*to_p
))
5438 || (DECL_P (*to_p
) && DECL_REGISTER (*to_p
)))
5439 /* Don't force regs into memory. */
5441 else if (TREE_CODE (*expr_p
) == INIT_EXPR
)
5442 /* It's OK to use the target directly if it's being
5445 else if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (*to_p
)))
5447 /* Always use the target and thus RSO for variable-sized types.
5448 GIMPLE cannot deal with a variable-sized assignment
5449 embedded in a call statement. */
5451 else if (TREE_CODE (*to_p
) != SSA_NAME
5452 && (!is_gimple_variable (*to_p
)
5453 || needs_to_live_in_memory (*to_p
)))
5454 /* Don't use the original target if it's already addressable;
5455 if its address escapes, and the called function uses the
5456 NRV optimization, a conforming program could see *to_p
5457 change before the called function returns; see c++/19317.
5458 When optimizing, the return_slot pass marks more functions
5459 as safe after we have escape info. */
5466 CALL_EXPR_RETURN_SLOT_OPT (*from_p
) = 1;
5467 mark_addressable (*to_p
);
5472 case WITH_SIZE_EXPR
:
5473 /* Likewise for calls that return an aggregate of non-constant size,
5474 since we would not be able to generate a temporary at all. */
5475 if (TREE_CODE (TREE_OPERAND (*from_p
, 0)) == CALL_EXPR
)
5477 *from_p
= TREE_OPERAND (*from_p
, 0);
5478 /* We don't change ret in this case because the
5479 WITH_SIZE_EXPR might have been added in
5480 gimplify_modify_expr, so returning GS_OK would lead to an
5486 /* If we're initializing from a container, push the initialization
5488 case CLEANUP_POINT_EXPR
:
5490 case STATEMENT_LIST
:
5492 tree wrap
= *from_p
;
5495 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_min_lval
,
5497 if (ret
!= GS_ERROR
)
5500 t
= voidify_wrapper_expr (wrap
, *expr_p
);
5501 gcc_assert (t
== *expr_p
);
5505 gimplify_and_add (wrap
, pre_p
);
5506 *expr_p
= unshare_expr (*to_p
);
5513 case COMPOUND_LITERAL_EXPR
:
5515 tree complit
= TREE_OPERAND (*expr_p
, 1);
5516 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (complit
);
5517 tree decl
= DECL_EXPR_DECL (decl_s
);
5518 tree init
= DECL_INITIAL (decl
);
5520 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
5521 into struct T x = { 0, 1, 2 } if the address of the
5522 compound literal has never been taken. */
5523 if (!TREE_ADDRESSABLE (complit
)
5524 && !TREE_ADDRESSABLE (decl
)
5527 *expr_p
= copy_node (*expr_p
);
5528 TREE_OPERAND (*expr_p
, 1) = init
;
5543 /* Return true if T looks like a valid GIMPLE statement. */
5546 is_gimple_stmt (tree t
)
5548 const enum tree_code code
= TREE_CODE (t
);
5553 /* The only valid NOP_EXPR is the empty statement. */
5554 return IS_EMPTY_STMT (t
);
5558 /* These are only valid if they're void. */
5559 return TREE_TYPE (t
) == NULL
|| VOID_TYPE_P (TREE_TYPE (t
));
5565 case CASE_LABEL_EXPR
:
5566 case TRY_CATCH_EXPR
:
5567 case TRY_FINALLY_EXPR
:
5568 case EH_FILTER_EXPR
:
5571 case STATEMENT_LIST
:
5576 case OACC_HOST_DATA
:
5579 case OACC_ENTER_DATA
:
5580 case OACC_EXIT_DATA
:
5585 case OMP_DISTRIBUTE
:
5598 case OMP_TARGET_DATA
:
5599 case OMP_TARGET_UPDATE
:
5600 case OMP_TARGET_ENTER_DATA
:
5601 case OMP_TARGET_EXIT_DATA
:
5604 /* These are always void. */
5610 /* These are valid regardless of their type. */
5619 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
5620 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
5621 DECL_GIMPLE_REG_P set.
5623 IMPORTANT NOTE: This promotion is performed by introducing a load of the
5624 other, unmodified part of the complex object just before the total store.
5625 As a consequence, if the object is still uninitialized, an undefined value
5626 will be loaded into a register, which may result in a spurious exception
5627 if the register is floating-point and the value happens to be a signaling
5628 NaN for example. Then the fully-fledged complex operations lowering pass
5629 followed by a DCE pass are necessary in order to fix things up. */
5631 static enum gimplify_status
5632 gimplify_modify_expr_complex_part (tree
*expr_p
, gimple_seq
*pre_p
,
5635 enum tree_code code
, ocode
;
5636 tree lhs
, rhs
, new_rhs
, other
, realpart
, imagpart
;
5638 lhs
= TREE_OPERAND (*expr_p
, 0);
5639 rhs
= TREE_OPERAND (*expr_p
, 1);
5640 code
= TREE_CODE (lhs
);
5641 lhs
= TREE_OPERAND (lhs
, 0);
5643 ocode
= code
== REALPART_EXPR
? IMAGPART_EXPR
: REALPART_EXPR
;
5644 other
= build1 (ocode
, TREE_TYPE (rhs
), lhs
);
5645 TREE_NO_WARNING (other
) = 1;
5646 other
= get_formal_tmp_var (other
, pre_p
);
5648 realpart
= code
== REALPART_EXPR
? rhs
: other
;
5649 imagpart
= code
== REALPART_EXPR
? other
: rhs
;
5651 if (TREE_CONSTANT (realpart
) && TREE_CONSTANT (imagpart
))
5652 new_rhs
= build_complex (TREE_TYPE (lhs
), realpart
, imagpart
);
5654 new_rhs
= build2 (COMPLEX_EXPR
, TREE_TYPE (lhs
), realpart
, imagpart
);
5656 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (lhs
, new_rhs
));
5657 *expr_p
= (want_value
) ? rhs
: NULL_TREE
;
5662 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
5668 PRE_P points to the list where side effects that must happen before
5669 *EXPR_P should be stored.
5671 POST_P points to the list where side effects that must happen after
5672 *EXPR_P should be stored.
5674 WANT_VALUE is nonzero iff we want to use the value of this expression
5675 in another expression. */
5677 static enum gimplify_status
5678 gimplify_modify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
5681 tree
*from_p
= &TREE_OPERAND (*expr_p
, 1);
5682 tree
*to_p
= &TREE_OPERAND (*expr_p
, 0);
5683 enum gimplify_status ret
= GS_UNHANDLED
;
5685 location_t loc
= EXPR_LOCATION (*expr_p
);
5686 gimple_stmt_iterator gsi
;
5688 gcc_assert (TREE_CODE (*expr_p
) == MODIFY_EXPR
5689 || TREE_CODE (*expr_p
) == INIT_EXPR
);
5691 /* Trying to simplify a clobber using normal logic doesn't work,
5692 so handle it here. */
5693 if (TREE_CLOBBER_P (*from_p
))
5695 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
5696 if (ret
== GS_ERROR
)
5698 gcc_assert (!want_value
);
5699 if (!VAR_P (*to_p
) && TREE_CODE (*to_p
) != MEM_REF
)
5701 tree addr
= get_initialized_tmp_var (build_fold_addr_expr (*to_p
),
5703 *to_p
= build_simple_mem_ref_loc (EXPR_LOCATION (*to_p
), addr
);
5705 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (*to_p
, *from_p
));
5710 /* Insert pointer conversions required by the middle-end that are not
5711 required by the frontend. This fixes middle-end type checking for
5712 for example gcc.dg/redecl-6.c. */
5713 if (POINTER_TYPE_P (TREE_TYPE (*to_p
)))
5715 STRIP_USELESS_TYPE_CONVERSION (*from_p
);
5716 if (!useless_type_conversion_p (TREE_TYPE (*to_p
), TREE_TYPE (*from_p
)))
5717 *from_p
= fold_convert_loc (loc
, TREE_TYPE (*to_p
), *from_p
);
5720 /* See if any simplifications can be done based on what the RHS is. */
5721 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
5723 if (ret
!= GS_UNHANDLED
)
5726 /* For zero sized types only gimplify the left hand side and right hand
5727 side as statements and throw away the assignment. Do this after
5728 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
5730 if (zero_sized_type (TREE_TYPE (*from_p
))
5732 /* Don't do this for calls that return addressable types, expand_call
5733 relies on those having a lhs. */
5734 && !(TREE_ADDRESSABLE (TREE_TYPE (*from_p
))
5735 && TREE_CODE (*from_p
) == CALL_EXPR
))
5737 gimplify_stmt (from_p
, pre_p
);
5738 gimplify_stmt (to_p
, pre_p
);
5739 *expr_p
= NULL_TREE
;
5743 /* If the value being copied is of variable width, compute the length
5744 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
5745 before gimplifying any of the operands so that we can resolve any
5746 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
5747 the size of the expression to be copied, not of the destination, so
5748 that is what we must do here. */
5749 maybe_with_size_expr (from_p
);
5751 /* As a special case, we have to temporarily allow for assignments
5752 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
5753 a toplevel statement, when gimplifying the GENERIC expression
5754 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
5755 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
5757 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
5758 prevent gimplify_expr from trying to create a new temporary for
5759 foo's LHS, we tell it that it should only gimplify until it
5760 reaches the CALL_EXPR. On return from gimplify_expr, the newly
5761 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
5762 and all we need to do here is set 'a' to be its LHS. */
5764 /* Gimplify the RHS first for C++17 and bug 71104. */
5765 gimple_predicate initial_pred
= initial_rhs_predicate_for (*to_p
);
5766 ret
= gimplify_expr (from_p
, pre_p
, post_p
, initial_pred
, fb_rvalue
);
5767 if (ret
== GS_ERROR
)
5770 /* Then gimplify the LHS. */
5771 /* If we gimplified the RHS to a CALL_EXPR and that call may return
5772 twice we have to make sure to gimplify into non-SSA as otherwise
5773 the abnormal edge added later will make those defs not dominate
5775 ??? Technically this applies only to the registers used in the
5776 resulting non-register *TO_P. */
5777 bool saved_into_ssa
= gimplify_ctxp
->into_ssa
;
5779 && TREE_CODE (*from_p
) == CALL_EXPR
5780 && call_expr_flags (*from_p
) & ECF_RETURNS_TWICE
)
5781 gimplify_ctxp
->into_ssa
= false;
5782 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
5783 gimplify_ctxp
->into_ssa
= saved_into_ssa
;
5784 if (ret
== GS_ERROR
)
5787 /* Now that the LHS is gimplified, re-gimplify the RHS if our initial
5788 guess for the predicate was wrong. */
5789 gimple_predicate final_pred
= rhs_predicate_for (*to_p
);
5790 if (final_pred
!= initial_pred
)
5792 ret
= gimplify_expr (from_p
, pre_p
, post_p
, final_pred
, fb_rvalue
);
5793 if (ret
== GS_ERROR
)
5797 /* In case of va_arg internal fn wrappped in a WITH_SIZE_EXPR, add the type
5798 size as argument to the call. */
5799 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
5801 tree call
= TREE_OPERAND (*from_p
, 0);
5802 tree vlasize
= TREE_OPERAND (*from_p
, 1);
5804 if (TREE_CODE (call
) == CALL_EXPR
5805 && CALL_EXPR_IFN (call
) == IFN_VA_ARG
)
5807 int nargs
= call_expr_nargs (call
);
5808 tree type
= TREE_TYPE (call
);
5809 tree ap
= CALL_EXPR_ARG (call
, 0);
5810 tree tag
= CALL_EXPR_ARG (call
, 1);
5811 tree aptag
= CALL_EXPR_ARG (call
, 2);
5812 tree newcall
= build_call_expr_internal_loc (EXPR_LOCATION (call
),
5816 TREE_OPERAND (*from_p
, 0) = newcall
;
5820 /* Now see if the above changed *from_p to something we handle specially. */
5821 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
5823 if (ret
!= GS_UNHANDLED
)
5826 /* If we've got a variable sized assignment between two lvalues (i.e. does
5827 not involve a call), then we can make things a bit more straightforward
5828 by converting the assignment to memcpy or memset. */
5829 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
5831 tree from
= TREE_OPERAND (*from_p
, 0);
5832 tree size
= TREE_OPERAND (*from_p
, 1);
5834 if (TREE_CODE (from
) == CONSTRUCTOR
)
5835 return gimplify_modify_expr_to_memset (expr_p
, size
, want_value
, pre_p
);
5837 if (is_gimple_addressable (from
))
5840 return gimplify_modify_expr_to_memcpy (expr_p
, size
, want_value
,
5845 /* Transform partial stores to non-addressable complex variables into
5846 total stores. This allows us to use real instead of virtual operands
5847 for these variables, which improves optimization. */
5848 if ((TREE_CODE (*to_p
) == REALPART_EXPR
5849 || TREE_CODE (*to_p
) == IMAGPART_EXPR
)
5850 && is_gimple_reg (TREE_OPERAND (*to_p
, 0)))
5851 return gimplify_modify_expr_complex_part (expr_p
, pre_p
, want_value
);
5853 /* Try to alleviate the effects of the gimplification creating artificial
5854 temporaries (see for example is_gimple_reg_rhs) on the debug info, but
5855 make sure not to create DECL_DEBUG_EXPR links across functions. */
5856 if (!gimplify_ctxp
->into_ssa
5858 && DECL_IGNORED_P (*from_p
)
5860 && !DECL_IGNORED_P (*to_p
)
5861 && decl_function_context (*to_p
) == current_function_decl
5862 && decl_function_context (*from_p
) == current_function_decl
)
5864 if (!DECL_NAME (*from_p
) && DECL_NAME (*to_p
))
5866 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p
)));
5867 DECL_HAS_DEBUG_EXPR_P (*from_p
) = 1;
5868 SET_DECL_DEBUG_EXPR (*from_p
, *to_p
);
5871 if (want_value
&& TREE_THIS_VOLATILE (*to_p
))
5872 *from_p
= get_initialized_tmp_var (*from_p
, pre_p
, post_p
);
5874 if (TREE_CODE (*from_p
) == CALL_EXPR
)
5876 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
5877 instead of a GIMPLE_ASSIGN. */
5879 if (CALL_EXPR_FN (*from_p
) == NULL_TREE
)
5881 /* Gimplify internal functions created in the FEs. */
5882 int nargs
= call_expr_nargs (*from_p
), i
;
5883 enum internal_fn ifn
= CALL_EXPR_IFN (*from_p
);
5884 auto_vec
<tree
> vargs (nargs
);
5886 for (i
= 0; i
< nargs
; i
++)
5888 gimplify_arg (&CALL_EXPR_ARG (*from_p
, i
), pre_p
,
5889 EXPR_LOCATION (*from_p
));
5890 vargs
.quick_push (CALL_EXPR_ARG (*from_p
, i
));
5892 call_stmt
= gimple_build_call_internal_vec (ifn
, vargs
);
5893 gimple_call_set_nothrow (call_stmt
, TREE_NOTHROW (*from_p
));
5894 gimple_set_location (call_stmt
, EXPR_LOCATION (*expr_p
));
5898 tree fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*from_p
));
5899 CALL_EXPR_FN (*from_p
) = TREE_OPERAND (CALL_EXPR_FN (*from_p
), 0);
5900 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p
));
5901 tree fndecl
= get_callee_fndecl (*from_p
);
5903 && fndecl_built_in_p (fndecl
, BUILT_IN_EXPECT
)
5904 && call_expr_nargs (*from_p
) == 3)
5905 call_stmt
= gimple_build_call_internal (IFN_BUILTIN_EXPECT
, 3,
5906 CALL_EXPR_ARG (*from_p
, 0),
5907 CALL_EXPR_ARG (*from_p
, 1),
5908 CALL_EXPR_ARG (*from_p
, 2));
5911 call_stmt
= gimple_build_call_from_tree (*from_p
, fnptrtype
);
5914 notice_special_calls (call_stmt
);
5915 if (!gimple_call_noreturn_p (call_stmt
) || !should_remove_lhs_p (*to_p
))
5916 gimple_call_set_lhs (call_stmt
, *to_p
);
5917 else if (TREE_CODE (*to_p
) == SSA_NAME
)
5918 /* The above is somewhat premature, avoid ICEing later for a
5919 SSA name w/o a definition. We may have uses in the GIMPLE IL.
5920 ??? This doesn't make it a default-def. */
5921 SSA_NAME_DEF_STMT (*to_p
) = gimple_build_nop ();
5927 assign
= gimple_build_assign (*to_p
, *from_p
);
5928 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
5929 if (COMPARISON_CLASS_P (*from_p
))
5930 gimple_set_no_warning (assign
, TREE_NO_WARNING (*from_p
));
5933 if (gimplify_ctxp
->into_ssa
&& is_gimple_reg (*to_p
))
5935 /* We should have got an SSA name from the start. */
5936 gcc_assert (TREE_CODE (*to_p
) == SSA_NAME
5937 || ! gimple_in_ssa_p (cfun
));
5940 gimplify_seq_add_stmt (pre_p
, assign
);
5941 gsi
= gsi_last (*pre_p
);
5942 maybe_fold_stmt (&gsi
);
5946 *expr_p
= TREE_THIS_VOLATILE (*to_p
) ? *from_p
: unshare_expr (*to_p
);
5955 /* Gimplify a comparison between two variable-sized objects. Do this
5956 with a call to BUILT_IN_MEMCMP. */
5958 static enum gimplify_status
5959 gimplify_variable_sized_compare (tree
*expr_p
)
5961 location_t loc
= EXPR_LOCATION (*expr_p
);
5962 tree op0
= TREE_OPERAND (*expr_p
, 0);
5963 tree op1
= TREE_OPERAND (*expr_p
, 1);
5964 tree t
, arg
, dest
, src
, expr
;
5966 arg
= TYPE_SIZE_UNIT (TREE_TYPE (op0
));
5967 arg
= unshare_expr (arg
);
5968 arg
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg
, op0
);
5969 src
= build_fold_addr_expr_loc (loc
, op1
);
5970 dest
= build_fold_addr_expr_loc (loc
, op0
);
5971 t
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
5972 t
= build_call_expr_loc (loc
, t
, 3, dest
, src
, arg
);
5975 = build2 (TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), t
, integer_zero_node
);
5976 SET_EXPR_LOCATION (expr
, loc
);
5982 /* Gimplify a comparison between two aggregate objects of integral scalar
5983 mode as a comparison between the bitwise equivalent scalar values. */
5985 static enum gimplify_status
5986 gimplify_scalar_mode_aggregate_compare (tree
*expr_p
)
5988 location_t loc
= EXPR_LOCATION (*expr_p
);
5989 tree op0
= TREE_OPERAND (*expr_p
, 0);
5990 tree op1
= TREE_OPERAND (*expr_p
, 1);
5992 tree type
= TREE_TYPE (op0
);
5993 tree scalar_type
= lang_hooks
.types
.type_for_mode (TYPE_MODE (type
), 1);
5995 op0
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op0
);
5996 op1
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op1
);
5999 = fold_build2_loc (loc
, TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), op0
, op1
);
6004 /* Gimplify an expression sequence. This function gimplifies each
6005 expression and rewrites the original expression with the last
6006 expression of the sequence in GIMPLE form.
6008 PRE_P points to the list where the side effects for all the
6009 expressions in the sequence will be emitted.
6011 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
6013 static enum gimplify_status
6014 gimplify_compound_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
6020 tree
*sub_p
= &TREE_OPERAND (t
, 0);
6022 if (TREE_CODE (*sub_p
) == COMPOUND_EXPR
)
6023 gimplify_compound_expr (sub_p
, pre_p
, false);
6025 gimplify_stmt (sub_p
, pre_p
);
6027 t
= TREE_OPERAND (t
, 1);
6029 while (TREE_CODE (t
) == COMPOUND_EXPR
);
6036 gimplify_stmt (expr_p
, pre_p
);
6041 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
6042 gimplify. After gimplification, EXPR_P will point to a new temporary
6043 that holds the original value of the SAVE_EXPR node.
6045 PRE_P points to the list where side effects that must happen before
6046 *EXPR_P should be stored. */
6048 static enum gimplify_status
6049 gimplify_save_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
6051 enum gimplify_status ret
= GS_ALL_DONE
;
6054 gcc_assert (TREE_CODE (*expr_p
) == SAVE_EXPR
);
6055 val
= TREE_OPERAND (*expr_p
, 0);
6057 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
6058 if (!SAVE_EXPR_RESOLVED_P (*expr_p
))
6060 /* The operand may be a void-valued expression. It is
6061 being executed only for its side-effects. */
6062 if (TREE_TYPE (val
) == void_type_node
)
6064 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
6065 is_gimple_stmt
, fb_none
);
6069 /* The temporary may not be an SSA name as later abnormal and EH
6070 control flow may invalidate use/def domination. When in SSA
6071 form then assume there are no such issues and SAVE_EXPRs only
6072 appear via GENERIC foldings. */
6073 val
= get_initialized_tmp_var (val
, pre_p
, post_p
,
6074 gimple_in_ssa_p (cfun
));
6076 TREE_OPERAND (*expr_p
, 0) = val
;
6077 SAVE_EXPR_RESOLVED_P (*expr_p
) = 1;
6085 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
6092 PRE_P points to the list where side effects that must happen before
6093 *EXPR_P should be stored.
6095 POST_P points to the list where side effects that must happen after
6096 *EXPR_P should be stored. */
6098 static enum gimplify_status
6099 gimplify_addr_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
6101 tree expr
= *expr_p
;
6102 tree op0
= TREE_OPERAND (expr
, 0);
6103 enum gimplify_status ret
;
6104 location_t loc
= EXPR_LOCATION (*expr_p
);
6106 switch (TREE_CODE (op0
))
6110 /* Check if we are dealing with an expression of the form '&*ptr'.
6111 While the front end folds away '&*ptr' into 'ptr', these
6112 expressions may be generated internally by the compiler (e.g.,
6113 builtins like __builtin_va_end). */
6114 /* Caution: the silent array decomposition semantics we allow for
6115 ADDR_EXPR means we can't always discard the pair. */
6116 /* Gimplification of the ADDR_EXPR operand may drop
6117 cv-qualification conversions, so make sure we add them if
6120 tree op00
= TREE_OPERAND (op0
, 0);
6121 tree t_expr
= TREE_TYPE (expr
);
6122 tree t_op00
= TREE_TYPE (op00
);
6124 if (!useless_type_conversion_p (t_expr
, t_op00
))
6125 op00
= fold_convert_loc (loc
, TREE_TYPE (expr
), op00
);
6131 case VIEW_CONVERT_EXPR
:
6132 /* Take the address of our operand and then convert it to the type of
6135 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
6136 all clear. The impact of this transformation is even less clear. */
6138 /* If the operand is a useless conversion, look through it. Doing so
6139 guarantees that the ADDR_EXPR and its operand will remain of the
6141 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0
, 0)))
6142 op0
= TREE_OPERAND (op0
, 0);
6144 *expr_p
= fold_convert_loc (loc
, TREE_TYPE (expr
),
6145 build_fold_addr_expr_loc (loc
,
6146 TREE_OPERAND (op0
, 0)));
6151 if (integer_zerop (TREE_OPERAND (op0
, 1)))
6152 goto do_indirect_ref
;
6157 /* If we see a call to a declared builtin or see its address
6158 being taken (we can unify those cases here) then we can mark
6159 the builtin for implicit generation by GCC. */
6160 if (TREE_CODE (op0
) == FUNCTION_DECL
6161 && fndecl_built_in_p (op0
, BUILT_IN_NORMAL
)
6162 && builtin_decl_declared_p (DECL_FUNCTION_CODE (op0
)))
6163 set_builtin_decl_implicit_p (DECL_FUNCTION_CODE (op0
), true);
6165 /* We use fb_either here because the C frontend sometimes takes
6166 the address of a call that returns a struct; see
6167 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
6168 the implied temporary explicit. */
6170 /* Make the operand addressable. */
6171 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, post_p
,
6172 is_gimple_addressable
, fb_either
);
6173 if (ret
== GS_ERROR
)
6176 /* Then mark it. Beware that it may not be possible to do so directly
6177 if a temporary has been created by the gimplification. */
6178 prepare_gimple_addressable (&TREE_OPERAND (expr
, 0), pre_p
);
6180 op0
= TREE_OPERAND (expr
, 0);
6182 /* For various reasons, the gimplification of the expression
6183 may have made a new INDIRECT_REF. */
6184 if (TREE_CODE (op0
) == INDIRECT_REF
)
6185 goto do_indirect_ref
;
6187 mark_addressable (TREE_OPERAND (expr
, 0));
6189 /* The FEs may end up building ADDR_EXPRs early on a decl with
6190 an incomplete type. Re-build ADDR_EXPRs in canonical form
6192 if (!types_compatible_p (TREE_TYPE (op0
), TREE_TYPE (TREE_TYPE (expr
))))
6193 *expr_p
= build_fold_addr_expr (op0
);
6195 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
6196 recompute_tree_invariant_for_addr_expr (*expr_p
);
6198 /* If we re-built the ADDR_EXPR add a conversion to the original type
6200 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
6201 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
6209 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
6210 value; output operands should be a gimple lvalue. */
6212 static enum gimplify_status
6213 gimplify_asm_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
6217 const char **oconstraints
;
6220 const char *constraint
;
6221 bool allows_mem
, allows_reg
, is_inout
;
6222 enum gimplify_status ret
, tret
;
6224 vec
<tree
, va_gc
> *inputs
;
6225 vec
<tree
, va_gc
> *outputs
;
6226 vec
<tree
, va_gc
> *clobbers
;
6227 vec
<tree
, va_gc
> *labels
;
6231 noutputs
= list_length (ASM_OUTPUTS (expr
));
6232 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
6240 link_next
= NULL_TREE
;
6241 for (i
= 0, link
= ASM_OUTPUTS (expr
); link
; ++i
, link
= link_next
)
6244 size_t constraint_len
;
6246 link_next
= TREE_CHAIN (link
);
6250 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
6251 constraint_len
= strlen (constraint
);
6252 if (constraint_len
== 0)
6255 ok
= parse_output_constraint (&constraint
, i
, 0, 0,
6256 &allows_mem
, &allows_reg
, &is_inout
);
6263 /* If we can't make copies, we can only accept memory.
6264 Similarly for VLAs. */
6265 tree outtype
= TREE_TYPE (TREE_VALUE (link
));
6266 if (outtype
!= error_mark_node
6267 && (TREE_ADDRESSABLE (outtype
)
6268 || !COMPLETE_TYPE_P (outtype
)
6269 || !tree_fits_poly_uint64_p (TYPE_SIZE_UNIT (outtype
))))
6275 error ("impossible constraint in %<asm%>");
6276 error ("non-memory output %d must stay in memory", i
);
6281 if (!allows_reg
&& allows_mem
)
6282 mark_addressable (TREE_VALUE (link
));
6284 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
6285 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
6286 fb_lvalue
| fb_mayfail
);
6287 if (tret
== GS_ERROR
)
6289 error ("invalid lvalue in %<asm%> output %d", i
);
6293 /* If the constraint does not allow memory make sure we gimplify
6294 it to a register if it is not already but its base is. This
6295 happens for complex and vector components. */
6298 tree op
= TREE_VALUE (link
);
6299 if (! is_gimple_val (op
)
6300 && is_gimple_reg_type (TREE_TYPE (op
))
6301 && is_gimple_reg (get_base_address (op
)))
6303 tree tem
= create_tmp_reg (TREE_TYPE (op
));
6307 ass
= build2 (MODIFY_EXPR
, TREE_TYPE (tem
),
6308 tem
, unshare_expr (op
));
6309 gimplify_and_add (ass
, pre_p
);
6311 ass
= build2 (MODIFY_EXPR
, TREE_TYPE (tem
), op
, tem
);
6312 gimplify_and_add (ass
, post_p
);
6314 TREE_VALUE (link
) = tem
;
6319 vec_safe_push (outputs
, link
);
6320 TREE_CHAIN (link
) = NULL_TREE
;
6324 /* An input/output operand. To give the optimizers more
6325 flexibility, split it into separate input and output
6328 /* Buffer big enough to format a 32-bit UINT_MAX into. */
6331 /* Turn the in/out constraint into an output constraint. */
6332 char *p
= xstrdup (constraint
);
6334 TREE_VALUE (TREE_PURPOSE (link
)) = build_string (constraint_len
, p
);
6336 /* And add a matching input constraint. */
6339 sprintf (buf
, "%u", i
);
6341 /* If there are multiple alternatives in the constraint,
6342 handle each of them individually. Those that allow register
6343 will be replaced with operand number, the others will stay
6345 if (strchr (p
, ',') != NULL
)
6347 size_t len
= 0, buflen
= strlen (buf
);
6348 char *beg
, *end
, *str
, *dst
;
6352 end
= strchr (beg
, ',');
6354 end
= strchr (beg
, '\0');
6355 if ((size_t) (end
- beg
) < buflen
)
6358 len
+= end
- beg
+ 1;
6365 str
= (char *) alloca (len
);
6366 for (beg
= p
+ 1, dst
= str
;;)
6369 bool mem_p
, reg_p
, inout_p
;
6371 end
= strchr (beg
, ',');
6376 parse_output_constraint (&tem
, i
, 0, 0,
6377 &mem_p
, ®_p
, &inout_p
);
6382 memcpy (dst
, buf
, buflen
);
6391 memcpy (dst
, beg
, len
);
6400 input
= build_string (dst
- str
, str
);
6403 input
= build_string (strlen (buf
), buf
);
6406 input
= build_string (constraint_len
- 1, constraint
+ 1);
6410 input
= build_tree_list (build_tree_list (NULL_TREE
, input
),
6411 unshare_expr (TREE_VALUE (link
)));
6412 ASM_INPUTS (expr
) = chainon (ASM_INPUTS (expr
), input
);
6416 link_next
= NULL_TREE
;
6417 for (link
= ASM_INPUTS (expr
); link
; ++i
, link
= link_next
)
6419 link_next
= TREE_CHAIN (link
);
6420 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
6421 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
6422 oconstraints
, &allows_mem
, &allows_reg
);
6424 /* If we can't make copies, we can only accept memory. */
6425 tree intype
= TREE_TYPE (TREE_VALUE (link
));
6426 if (intype
!= error_mark_node
6427 && (TREE_ADDRESSABLE (intype
)
6428 || !COMPLETE_TYPE_P (intype
)
6429 || !tree_fits_poly_uint64_p (TYPE_SIZE_UNIT (intype
))))
6435 error ("impossible constraint in %<asm%>");
6436 error ("non-memory input %d must stay in memory", i
);
6441 /* If the operand is a memory input, it should be an lvalue. */
6442 if (!allows_reg
&& allows_mem
)
6444 tree inputv
= TREE_VALUE (link
);
6445 STRIP_NOPS (inputv
);
6446 if (TREE_CODE (inputv
) == PREDECREMENT_EXPR
6447 || TREE_CODE (inputv
) == PREINCREMENT_EXPR
6448 || TREE_CODE (inputv
) == POSTDECREMENT_EXPR
6449 || TREE_CODE (inputv
) == POSTINCREMENT_EXPR
6450 || TREE_CODE (inputv
) == MODIFY_EXPR
)
6451 TREE_VALUE (link
) = error_mark_node
;
6452 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
6453 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
6454 if (tret
!= GS_ERROR
)
6456 /* Unlike output operands, memory inputs are not guaranteed
6457 to be lvalues by the FE, and while the expressions are
6458 marked addressable there, if it is e.g. a statement
6459 expression, temporaries in it might not end up being
6460 addressable. They might be already used in the IL and thus
6461 it is too late to make them addressable now though. */
6462 tree x
= TREE_VALUE (link
);
6463 while (handled_component_p (x
))
6464 x
= TREE_OPERAND (x
, 0);
6465 if (TREE_CODE (x
) == MEM_REF
6466 && TREE_CODE (TREE_OPERAND (x
, 0)) == ADDR_EXPR
)
6467 x
= TREE_OPERAND (TREE_OPERAND (x
, 0), 0);
6469 || TREE_CODE (x
) == PARM_DECL
6470 || TREE_CODE (x
) == RESULT_DECL
)
6471 && !TREE_ADDRESSABLE (x
)
6472 && is_gimple_reg (x
))
6474 warning_at (EXPR_LOC_OR_LOC (TREE_VALUE (link
),
6476 "memory input %d is not directly addressable",
6478 prepare_gimple_addressable (&TREE_VALUE (link
), pre_p
);
6481 mark_addressable (TREE_VALUE (link
));
6482 if (tret
== GS_ERROR
)
6484 error_at (EXPR_LOC_OR_LOC (TREE_VALUE (link
), input_location
),
6485 "memory input %d is not directly addressable", i
);
6491 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
6492 is_gimple_asm_val
, fb_rvalue
);
6493 if (tret
== GS_ERROR
)
6497 TREE_CHAIN (link
) = NULL_TREE
;
6498 vec_safe_push (inputs
, link
);
6501 link_next
= NULL_TREE
;
6502 for (link
= ASM_CLOBBERS (expr
); link
; ++i
, link
= link_next
)
6504 link_next
= TREE_CHAIN (link
);
6505 TREE_CHAIN (link
) = NULL_TREE
;
6506 vec_safe_push (clobbers
, link
);
6509 link_next
= NULL_TREE
;
6510 for (link
= ASM_LABELS (expr
); link
; ++i
, link
= link_next
)
6512 link_next
= TREE_CHAIN (link
);
6513 TREE_CHAIN (link
) = NULL_TREE
;
6514 vec_safe_push (labels
, link
);
6517 /* Do not add ASMs with errors to the gimple IL stream. */
6518 if (ret
!= GS_ERROR
)
6520 stmt
= gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr
)),
6521 inputs
, outputs
, clobbers
, labels
);
6523 gimple_asm_set_volatile (stmt
, ASM_VOLATILE_P (expr
) || noutputs
== 0);
6524 gimple_asm_set_input (stmt
, ASM_INPUT_P (expr
));
6525 gimple_asm_set_inline (stmt
, ASM_INLINE_P (expr
));
6527 gimplify_seq_add_stmt (pre_p
, stmt
);
6533 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
6534 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
6535 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
6536 return to this function.
6538 FIXME should we complexify the prequeue handling instead? Or use flags
6539 for all the cleanups and let the optimizer tighten them up? The current
6540 code seems pretty fragile; it will break on a cleanup within any
6541 non-conditional nesting. But any such nesting would be broken, anyway;
6542 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
6543 and continues out of it. We can do that at the RTL level, though, so
6544 having an optimizer to tighten up try/finally regions would be a Good
6547 static enum gimplify_status
6548 gimplify_cleanup_point_expr (tree
*expr_p
, gimple_seq
*pre_p
)
6550 gimple_stmt_iterator iter
;
6551 gimple_seq body_sequence
= NULL
;
6553 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
6555 /* We only care about the number of conditions between the innermost
6556 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
6557 any cleanups collected outside the CLEANUP_POINT_EXPR. */
6558 int old_conds
= gimplify_ctxp
->conditions
;
6559 gimple_seq old_cleanups
= gimplify_ctxp
->conditional_cleanups
;
6560 bool old_in_cleanup_point_expr
= gimplify_ctxp
->in_cleanup_point_expr
;
6561 gimplify_ctxp
->conditions
= 0;
6562 gimplify_ctxp
->conditional_cleanups
= NULL
;
6563 gimplify_ctxp
->in_cleanup_point_expr
= true;
6565 gimplify_stmt (&TREE_OPERAND (*expr_p
, 0), &body_sequence
);
6567 gimplify_ctxp
->conditions
= old_conds
;
6568 gimplify_ctxp
->conditional_cleanups
= old_cleanups
;
6569 gimplify_ctxp
->in_cleanup_point_expr
= old_in_cleanup_point_expr
;
6571 for (iter
= gsi_start (body_sequence
); !gsi_end_p (iter
); )
6573 gimple
*wce
= gsi_stmt (iter
);
6575 if (gimple_code (wce
) == GIMPLE_WITH_CLEANUP_EXPR
)
6577 if (gsi_one_before_end_p (iter
))
6579 /* Note that gsi_insert_seq_before and gsi_remove do not
6580 scan operands, unlike some other sequence mutators. */
6581 if (!gimple_wce_cleanup_eh_only (wce
))
6582 gsi_insert_seq_before_without_update (&iter
,
6583 gimple_wce_cleanup (wce
),
6585 gsi_remove (&iter
, true);
6592 enum gimple_try_flags kind
;
6594 if (gimple_wce_cleanup_eh_only (wce
))
6595 kind
= GIMPLE_TRY_CATCH
;
6597 kind
= GIMPLE_TRY_FINALLY
;
6598 seq
= gsi_split_seq_after (iter
);
6600 gtry
= gimple_build_try (seq
, gimple_wce_cleanup (wce
), kind
);
6601 /* Do not use gsi_replace here, as it may scan operands.
6602 We want to do a simple structural modification only. */
6603 gsi_set_stmt (&iter
, gtry
);
6604 iter
= gsi_start (gtry
->eval
);
6611 gimplify_seq_add_seq (pre_p
, body_sequence
);
6624 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
6625 is the cleanup action required. EH_ONLY is true if the cleanup should
6626 only be executed if an exception is thrown, not on normal exit.
6627 If FORCE_UNCOND is true perform the cleanup unconditionally; this is
6628 only valid for clobbers. */
6631 gimple_push_cleanup (tree var
, tree cleanup
, bool eh_only
, gimple_seq
*pre_p
,
6632 bool force_uncond
= false)
6635 gimple_seq cleanup_stmts
= NULL
;
6637 /* Errors can result in improperly nested cleanups. Which results in
6638 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
6642 if (gimple_conditional_context ())
6644 /* If we're in a conditional context, this is more complex. We only
6645 want to run the cleanup if we actually ran the initialization that
6646 necessitates it, but we want to run it after the end of the
6647 conditional context. So we wrap the try/finally around the
6648 condition and use a flag to determine whether or not to actually
6649 run the destructor. Thus
6653 becomes (approximately)
6657 if (test) { A::A(temp); flag = 1; val = f(temp); }
6660 if (flag) A::~A(temp);
6666 gimplify_stmt (&cleanup
, &cleanup_stmts
);
6667 wce
= gimple_build_wce (cleanup_stmts
);
6668 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
6672 tree flag
= create_tmp_var (boolean_type_node
, "cleanup");
6673 gassign
*ffalse
= gimple_build_assign (flag
, boolean_false_node
);
6674 gassign
*ftrue
= gimple_build_assign (flag
, boolean_true_node
);
6676 cleanup
= build3 (COND_EXPR
, void_type_node
, flag
, cleanup
, NULL
);
6677 gimplify_stmt (&cleanup
, &cleanup_stmts
);
6678 wce
= gimple_build_wce (cleanup_stmts
);
6680 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, ffalse
);
6681 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
6682 gimplify_seq_add_stmt (pre_p
, ftrue
);
6684 /* Because of this manipulation, and the EH edges that jump
6685 threading cannot redirect, the temporary (VAR) will appear
6686 to be used uninitialized. Don't warn. */
6687 TREE_NO_WARNING (var
) = 1;
6692 gimplify_stmt (&cleanup
, &cleanup_stmts
);
6693 wce
= gimple_build_wce (cleanup_stmts
);
6694 gimple_wce_set_cleanup_eh_only (wce
, eh_only
);
6695 gimplify_seq_add_stmt (pre_p
, wce
);
6699 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
6701 static enum gimplify_status
6702 gimplify_target_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
6704 tree targ
= *expr_p
;
6705 tree temp
= TARGET_EXPR_SLOT (targ
);
6706 tree init
= TARGET_EXPR_INITIAL (targ
);
6707 enum gimplify_status ret
;
6709 bool unpoison_empty_seq
= false;
6710 gimple_stmt_iterator unpoison_it
;
6714 tree cleanup
= NULL_TREE
;
6716 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
6717 to the temps list. Handle also variable length TARGET_EXPRs. */
6718 if (!poly_int_tree_p (DECL_SIZE (temp
)))
6720 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp
)))
6721 gimplify_type_sizes (TREE_TYPE (temp
), pre_p
);
6722 gimplify_vla_decl (temp
, pre_p
);
6726 /* Save location where we need to place unpoisoning. It's possible
6727 that a variable will be converted to needs_to_live_in_memory. */
6728 unpoison_it
= gsi_last (*pre_p
);
6729 unpoison_empty_seq
= gsi_end_p (unpoison_it
);
6731 gimple_add_tmp_var (temp
);
6734 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
6735 expression is supposed to initialize the slot. */
6736 if (VOID_TYPE_P (TREE_TYPE (init
)))
6737 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
6740 tree init_expr
= build2 (INIT_EXPR
, void_type_node
, temp
, init
);
6742 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
6744 ggc_free (init_expr
);
6746 if (ret
== GS_ERROR
)
6748 /* PR c++/28266 Make sure this is expanded only once. */
6749 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
6753 gimplify_and_add (init
, pre_p
);
6755 /* If needed, push the cleanup for the temp. */
6756 if (TARGET_EXPR_CLEANUP (targ
))
6758 if (CLEANUP_EH_ONLY (targ
))
6759 gimple_push_cleanup (temp
, TARGET_EXPR_CLEANUP (targ
),
6760 CLEANUP_EH_ONLY (targ
), pre_p
);
6762 cleanup
= TARGET_EXPR_CLEANUP (targ
);
6765 /* Add a clobber for the temporary going out of scope, like
6766 gimplify_bind_expr. */
6767 if (gimplify_ctxp
->in_cleanup_point_expr
6768 && needs_to_live_in_memory (temp
))
6770 if (flag_stack_reuse
== SR_ALL
)
6772 tree clobber
= build_clobber (TREE_TYPE (temp
));
6773 clobber
= build2 (MODIFY_EXPR
, TREE_TYPE (temp
), temp
, clobber
);
6774 gimple_push_cleanup (temp
, clobber
, false, pre_p
, true);
6776 if (asan_poisoned_variables
6777 && DECL_ALIGN (temp
) <= MAX_SUPPORTED_STACK_ALIGNMENT
6778 && !TREE_STATIC (temp
)
6779 && dbg_cnt (asan_use_after_scope
)
6780 && !gimplify_omp_ctxp
)
6782 tree asan_cleanup
= build_asan_poison_call_expr (temp
);
6785 if (unpoison_empty_seq
)
6786 unpoison_it
= gsi_start (*pre_p
);
6788 asan_poison_variable (temp
, false, &unpoison_it
,
6789 unpoison_empty_seq
);
6790 gimple_push_cleanup (temp
, asan_cleanup
, false, pre_p
);
6795 gimple_push_cleanup (temp
, cleanup
, false, pre_p
);
6797 /* Only expand this once. */
6798 TREE_OPERAND (targ
, 3) = init
;
6799 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
6802 /* We should have expanded this before. */
6803 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp
));
6809 /* Gimplification of expression trees. */
6811 /* Gimplify an expression which appears at statement context. The
6812 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
6813 NULL, a new sequence is allocated.
6815 Return true if we actually added a statement to the queue. */
6818 gimplify_stmt (tree
*stmt_p
, gimple_seq
*seq_p
)
6820 gimple_seq_node last
;
6822 last
= gimple_seq_last (*seq_p
);
6823 gimplify_expr (stmt_p
, seq_p
, NULL
, is_gimple_stmt
, fb_none
);
6824 return last
!= gimple_seq_last (*seq_p
);
6827 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
6828 to CTX. If entries already exist, force them to be some flavor of private.
6829 If there is no enclosing parallel, do nothing. */
6832 omp_firstprivatize_variable (struct gimplify_omp_ctx
*ctx
, tree decl
)
6836 if (decl
== NULL
|| !DECL_P (decl
) || ctx
->region_type
== ORT_NONE
)
6841 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
6844 if (n
->value
& GOVD_SHARED
)
6845 n
->value
= GOVD_FIRSTPRIVATE
| (n
->value
& GOVD_SEEN
);
6846 else if (n
->value
& GOVD_MAP
)
6847 n
->value
|= GOVD_MAP_TO_ONLY
;
6851 else if ((ctx
->region_type
& ORT_TARGET
) != 0)
6853 if (ctx
->defaultmap
[GDMK_SCALAR
] & GOVD_FIRSTPRIVATE
)
6854 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
6856 omp_add_variable (ctx
, decl
, GOVD_MAP
| GOVD_MAP_TO_ONLY
);
6858 else if (ctx
->region_type
!= ORT_WORKSHARE
6859 && ctx
->region_type
!= ORT_TASKGROUP
6860 && ctx
->region_type
!= ORT_SIMD
6861 && ctx
->region_type
!= ORT_ACC
6862 && !(ctx
->region_type
& ORT_TARGET_DATA
))
6863 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
6865 ctx
= ctx
->outer_context
;
6870 /* Similarly for each of the type sizes of TYPE. */
6873 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx
*ctx
, tree type
)
6875 if (type
== NULL
|| type
== error_mark_node
)
6877 type
= TYPE_MAIN_VARIANT (type
);
6879 if (ctx
->privatized_types
->add (type
))
6882 switch (TREE_CODE (type
))
6888 case FIXED_POINT_TYPE
:
6889 omp_firstprivatize_variable (ctx
, TYPE_MIN_VALUE (type
));
6890 omp_firstprivatize_variable (ctx
, TYPE_MAX_VALUE (type
));
6894 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
6895 omp_firstprivatize_type_sizes (ctx
, TYPE_DOMAIN (type
));
6900 case QUAL_UNION_TYPE
:
6903 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
6904 if (TREE_CODE (field
) == FIELD_DECL
)
6906 omp_firstprivatize_variable (ctx
, DECL_FIELD_OFFSET (field
));
6907 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (field
));
6913 case REFERENCE_TYPE
:
6914 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
6921 omp_firstprivatize_variable (ctx
, TYPE_SIZE (type
));
6922 omp_firstprivatize_variable (ctx
, TYPE_SIZE_UNIT (type
));
6923 lang_hooks
.types
.omp_firstprivatize_type_sizes (ctx
, type
);
6926 /* Add an entry for DECL in the OMP context CTX with FLAGS. */
6929 omp_add_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned int flags
)
6932 unsigned int nflags
;
6935 if (error_operand_p (decl
) || ctx
->region_type
== ORT_NONE
)
6938 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
6939 there are constructors involved somewhere. Exception is a shared clause,
6940 there is nothing privatized in that case. */
6941 if ((flags
& GOVD_SHARED
) == 0
6942 && (TREE_ADDRESSABLE (TREE_TYPE (decl
))
6943 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))))
6946 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
6947 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
6949 /* We shouldn't be re-adding the decl with the same data
6951 gcc_assert ((n
->value
& GOVD_DATA_SHARE_CLASS
& flags
) == 0);
6952 nflags
= n
->value
| flags
;
6953 /* The only combination of data sharing classes we should see is
6954 FIRSTPRIVATE and LASTPRIVATE. However, OpenACC permits
6955 reduction variables to be used in data sharing clauses. */
6956 gcc_assert ((ctx
->region_type
& ORT_ACC
) != 0
6957 || ((nflags
& GOVD_DATA_SHARE_CLASS
)
6958 == (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
))
6959 || (flags
& GOVD_DATA_SHARE_CLASS
) == 0);
6964 /* When adding a variable-sized variable, we have to handle all sorts
6965 of additional bits of data: the pointer replacement variable, and
6966 the parameters of the type. */
6967 if (DECL_SIZE (decl
) && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6969 /* Add the pointer replacement variable as PRIVATE if the variable
6970 replacement is private, else FIRSTPRIVATE since we'll need the
6971 address of the original variable either for SHARED, or for the
6972 copy into or out of the context. */
6973 if (!(flags
& GOVD_LOCAL
) && ctx
->region_type
!= ORT_TASKGROUP
)
6975 if (flags
& GOVD_MAP
)
6976 nflags
= GOVD_MAP
| GOVD_MAP_TO_ONLY
| GOVD_EXPLICIT
;
6977 else if (flags
& GOVD_PRIVATE
)
6978 nflags
= GOVD_PRIVATE
;
6979 else if (((ctx
->region_type
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0
6980 && (flags
& GOVD_FIRSTPRIVATE
))
6981 || (ctx
->region_type
== ORT_TARGET_DATA
6982 && (flags
& GOVD_DATA_SHARE_CLASS
) == 0))
6983 nflags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
6985 nflags
= GOVD_FIRSTPRIVATE
;
6986 nflags
|= flags
& GOVD_SEEN
;
6987 t
= DECL_VALUE_EXPR (decl
);
6988 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
6989 t
= TREE_OPERAND (t
, 0);
6990 gcc_assert (DECL_P (t
));
6991 omp_add_variable (ctx
, t
, nflags
);
6994 /* Add all of the variable and type parameters (which should have
6995 been gimplified to a formal temporary) as FIRSTPRIVATE. */
6996 omp_firstprivatize_variable (ctx
, DECL_SIZE_UNIT (decl
));
6997 omp_firstprivatize_variable (ctx
, DECL_SIZE (decl
));
6998 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
7000 /* The variable-sized variable itself is never SHARED, only some form
7001 of PRIVATE. The sharing would take place via the pointer variable
7002 which we remapped above. */
7003 if (flags
& GOVD_SHARED
)
7004 flags
= GOVD_SHARED
| GOVD_DEBUG_PRIVATE
7005 | (flags
& (GOVD_SEEN
| GOVD_EXPLICIT
));
7007 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
7008 alloca statement we generate for the variable, so make sure it
7009 is available. This isn't automatically needed for the SHARED
7010 case, since we won't be allocating local storage then.
7011 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
7012 in this case omp_notice_variable will be called later
7013 on when it is gimplified. */
7014 else if (! (flags
& (GOVD_LOCAL
| GOVD_MAP
))
7015 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl
))))
7016 omp_notice_variable (ctx
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)), true);
7018 else if ((flags
& (GOVD_MAP
| GOVD_LOCAL
)) == 0
7019 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
7021 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
7023 /* Similar to the direct variable sized case above, we'll need the
7024 size of references being privatized. */
7025 if ((flags
& GOVD_SHARED
) == 0)
7027 t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
7029 omp_notice_variable (ctx
, t
, true);
7036 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, flags
);
7038 /* For reductions clauses in OpenACC loop directives, by default create a
7039 copy clause on the enclosing parallel construct for carrying back the
7041 if (ctx
->region_type
== ORT_ACC
&& (flags
& GOVD_REDUCTION
))
7043 struct gimplify_omp_ctx
*outer_ctx
= ctx
->outer_context
;
7046 n
= splay_tree_lookup (outer_ctx
->variables
, (splay_tree_key
)decl
);
7049 /* Ignore local variables and explicitly declared clauses. */
7050 if (n
->value
& (GOVD_LOCAL
| GOVD_EXPLICIT
))
7052 else if (outer_ctx
->region_type
== ORT_ACC_KERNELS
)
7054 /* According to the OpenACC spec, such a reduction variable
7055 should already have a copy map on a kernels construct,
7056 verify that here. */
7057 gcc_assert (!(n
->value
& GOVD_FIRSTPRIVATE
)
7058 && (n
->value
& GOVD_MAP
));
7060 else if (outer_ctx
->region_type
== ORT_ACC_PARALLEL
)
7062 /* Remove firstprivate and make it a copy map. */
7063 n
->value
&= ~GOVD_FIRSTPRIVATE
;
7064 n
->value
|= GOVD_MAP
;
7067 else if (outer_ctx
->region_type
== ORT_ACC_PARALLEL
)
7069 splay_tree_insert (outer_ctx
->variables
, (splay_tree_key
)decl
,
7070 GOVD_MAP
| GOVD_SEEN
);
7073 outer_ctx
= outer_ctx
->outer_context
;
7078 /* Notice a threadprivate variable DECL used in OMP context CTX.
7079 This just prints out diagnostics about threadprivate variable uses
7080 in untied tasks. If DECL2 is non-NULL, prevent this warning
7081 on that variable. */
7084 omp_notice_threadprivate_variable (struct gimplify_omp_ctx
*ctx
, tree decl
,
7088 struct gimplify_omp_ctx
*octx
;
7090 for (octx
= ctx
; octx
; octx
= octx
->outer_context
)
7091 if ((octx
->region_type
& ORT_TARGET
) != 0
7092 || octx
->order_concurrent
)
7094 n
= splay_tree_lookup (octx
->variables
, (splay_tree_key
)decl
);
7097 if (octx
->order_concurrent
)
7099 error ("threadprivate variable %qE used in a region with"
7100 " %<order(concurrent)%> clause", DECL_NAME (decl
));
7101 error_at (octx
->location
, "enclosing region");
7105 error ("threadprivate variable %qE used in target region",
7107 error_at (octx
->location
, "enclosing target region");
7109 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl
, 0);
7112 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl2
, 0);
7115 if (ctx
->region_type
!= ORT_UNTIED_TASK
)
7117 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
7120 error ("threadprivate variable %qE used in untied task",
7122 error_at (ctx
->location
, "enclosing task");
7123 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, 0);
7126 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl2
, 0);
7130 /* Return true if global var DECL is device resident. */
7133 device_resident_p (tree decl
)
7135 tree attr
= lookup_attribute ("oacc declare target", DECL_ATTRIBUTES (decl
));
7140 for (tree t
= TREE_VALUE (attr
); t
; t
= TREE_PURPOSE (t
))
7142 tree c
= TREE_VALUE (t
);
7143 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_DEVICE_RESIDENT
)
7150 /* Return true if DECL has an ACC DECLARE attribute. */
7153 is_oacc_declared (tree decl
)
7155 tree t
= TREE_CODE (decl
) == MEM_REF
? TREE_OPERAND (decl
, 0) : decl
;
7156 tree declared
= lookup_attribute ("oacc declare target", DECL_ATTRIBUTES (t
));
7157 return declared
!= NULL_TREE
;
7160 /* Determine outer default flags for DECL mentioned in an OMP region
7161 but not declared in an enclosing clause.
7163 ??? Some compiler-generated variables (like SAVE_EXPRs) could be
7164 remapped firstprivate instead of shared. To some extent this is
7165 addressed in omp_firstprivatize_type_sizes, but not
7169 omp_default_clause (struct gimplify_omp_ctx
*ctx
, tree decl
,
7170 bool in_code
, unsigned flags
)
7172 enum omp_clause_default_kind default_kind
= ctx
->default_kind
;
7173 enum omp_clause_default_kind kind
;
7175 kind
= lang_hooks
.decls
.omp_predetermined_sharing (decl
);
7176 if (kind
!= OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
7177 default_kind
= kind
;
7178 else if (VAR_P (decl
) && TREE_STATIC (decl
) && DECL_IN_CONSTANT_POOL (decl
))
7179 default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
7181 switch (default_kind
)
7183 case OMP_CLAUSE_DEFAULT_NONE
:
7187 if (ctx
->region_type
& ORT_PARALLEL
)
7189 else if ((ctx
->region_type
& ORT_TASKLOOP
) == ORT_TASKLOOP
)
7191 else if (ctx
->region_type
& ORT_TASK
)
7193 else if (ctx
->region_type
& ORT_TEAMS
)
7198 error ("%qE not specified in enclosing %qs",
7199 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)), rtype
);
7200 error_at (ctx
->location
, "enclosing %qs", rtype
);
7203 case OMP_CLAUSE_DEFAULT_SHARED
:
7204 flags
|= GOVD_SHARED
;
7206 case OMP_CLAUSE_DEFAULT_PRIVATE
:
7207 flags
|= GOVD_PRIVATE
;
7209 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
7210 flags
|= GOVD_FIRSTPRIVATE
;
7212 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
7213 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
7214 gcc_assert ((ctx
->region_type
& ORT_TASK
) != 0);
7215 if (struct gimplify_omp_ctx
*octx
= ctx
->outer_context
)
7217 omp_notice_variable (octx
, decl
, in_code
);
7218 for (; octx
; octx
= octx
->outer_context
)
7222 n2
= splay_tree_lookup (octx
->variables
, (splay_tree_key
) decl
);
7223 if ((octx
->region_type
& (ORT_TARGET_DATA
| ORT_TARGET
)) != 0
7224 && (n2
== NULL
|| (n2
->value
& GOVD_DATA_SHARE_CLASS
) == 0))
7226 if (n2
&& (n2
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
)
7228 flags
|= GOVD_FIRSTPRIVATE
;
7231 if ((octx
->region_type
& (ORT_PARALLEL
| ORT_TEAMS
)) != 0)
7233 flags
|= GOVD_SHARED
;
7239 if (TREE_CODE (decl
) == PARM_DECL
7240 || (!is_global_var (decl
)
7241 && DECL_CONTEXT (decl
) == current_function_decl
))
7242 flags
|= GOVD_FIRSTPRIVATE
;
7244 flags
|= GOVD_SHARED
;
7256 /* Determine outer default flags for DECL mentioned in an OACC region
7257 but not declared in an enclosing clause. */
7260 oacc_default_clause (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned flags
)
7263 bool on_device
= false;
7264 bool is_private
= false;
7265 bool declared
= is_oacc_declared (decl
);
7266 tree type
= TREE_TYPE (decl
);
7268 if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
7269 type
= TREE_TYPE (type
);
7271 /* For Fortran COMMON blocks, only used variables in those blocks are
7272 transfered and remapped. The block itself will have a private clause to
7273 avoid transfering the data twice.
7274 The hook evaluates to false by default. For a variable in Fortran's COMMON
7275 or EQUIVALENCE block, returns 'true' (as we have shared=false) - as only
7276 the variables in such a COMMON/EQUIVALENCE block shall be privatized not
7277 the whole block. For C++ and Fortran, it can also be true under certain
7278 other conditions, if DECL_HAS_VALUE_EXPR. */
7279 if (RECORD_OR_UNION_TYPE_P (type
))
7280 is_private
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, false);
7282 if ((ctx
->region_type
& (ORT_ACC_PARALLEL
| ORT_ACC_KERNELS
)) != 0
7283 && is_global_var (decl
)
7284 && device_resident_p (decl
)
7288 flags
|= GOVD_MAP_TO_ONLY
;
7291 switch (ctx
->region_type
)
7293 case ORT_ACC_KERNELS
:
7297 flags
|= GOVD_FIRSTPRIVATE
;
7298 else if (AGGREGATE_TYPE_P (type
))
7300 /* Aggregates default to 'present_or_copy', or 'present'. */
7301 if (ctx
->default_kind
!= OMP_CLAUSE_DEFAULT_PRESENT
)
7304 flags
|= GOVD_MAP
| GOVD_MAP_FORCE_PRESENT
;
7307 /* Scalars default to 'copy'. */
7308 flags
|= GOVD_MAP
| GOVD_MAP_FORCE
;
7312 case ORT_ACC_PARALLEL
:
7313 case ORT_ACC_SERIAL
:
7314 rkind
= ctx
->region_type
== ORT_ACC_PARALLEL
? "parallel" : "serial";
7317 flags
|= GOVD_FIRSTPRIVATE
;
7318 else if (on_device
|| declared
)
7320 else if (AGGREGATE_TYPE_P (type
))
7322 /* Aggregates default to 'present_or_copy', or 'present'. */
7323 if (ctx
->default_kind
!= OMP_CLAUSE_DEFAULT_PRESENT
)
7326 flags
|= GOVD_MAP
| GOVD_MAP_FORCE_PRESENT
;
7329 /* Scalars default to 'firstprivate'. */
7330 flags
|= GOVD_FIRSTPRIVATE
;
7338 if (DECL_ARTIFICIAL (decl
))
7339 ; /* We can get compiler-generated decls, and should not complain
7341 else if (ctx
->default_kind
== OMP_CLAUSE_DEFAULT_NONE
)
7343 error ("%qE not specified in enclosing OpenACC %qs construct",
7344 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)), rkind
);
7345 inform (ctx
->location
, "enclosing OpenACC %qs construct", rkind
);
7347 else if (ctx
->default_kind
== OMP_CLAUSE_DEFAULT_PRESENT
)
7348 ; /* Handled above. */
7350 gcc_checking_assert (ctx
->default_kind
== OMP_CLAUSE_DEFAULT_SHARED
);
7355 /* Record the fact that DECL was used within the OMP context CTX.
7356 IN_CODE is true when real code uses DECL, and false when we should
7357 merely emit default(none) errors. Return true if DECL is going to
7358 be remapped and thus DECL shouldn't be gimplified into its
7359 DECL_VALUE_EXPR (if any). */
7362 omp_notice_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, bool in_code
)
7365 unsigned flags
= in_code
? GOVD_SEEN
: 0;
7366 bool ret
= false, shared
;
7368 if (error_operand_p (decl
))
7371 if (ctx
->region_type
== ORT_NONE
)
7372 return lang_hooks
.decls
.omp_disregard_value_expr (decl
, false);
7374 if (is_global_var (decl
))
7376 /* Threadprivate variables are predetermined. */
7377 if (DECL_THREAD_LOCAL_P (decl
))
7378 return omp_notice_threadprivate_variable (ctx
, decl
, NULL_TREE
);
7380 if (DECL_HAS_VALUE_EXPR_P (decl
))
7382 if (ctx
->region_type
& ORT_ACC
)
7383 /* For OpenACC, defer expansion of value to avoid transfering
7384 privatized common block data instead of im-/explicitly transfered
7385 variables which are in common blocks. */
7389 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
7391 if (value
&& DECL_P (value
) && DECL_THREAD_LOCAL_P (value
))
7392 return omp_notice_threadprivate_variable (ctx
, decl
, value
);
7396 if (gimplify_omp_ctxp
->outer_context
== NULL
7398 && oacc_get_fn_attrib (current_function_decl
))
7400 location_t loc
= DECL_SOURCE_LOCATION (decl
);
7402 if (lookup_attribute ("omp declare target link",
7403 DECL_ATTRIBUTES (decl
)))
7406 "%qE with %<link%> clause used in %<routine%> function",
7410 else if (!lookup_attribute ("omp declare target",
7411 DECL_ATTRIBUTES (decl
)))
7414 "%qE requires a %<declare%> directive for use "
7415 "in a %<routine%> function", DECL_NAME (decl
));
7421 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
7422 if ((ctx
->region_type
& ORT_TARGET
) != 0)
7424 if (ctx
->region_type
& ORT_ACC
)
7425 /* For OpenACC, as remarked above, defer expansion. */
7430 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
7433 unsigned nflags
= flags
;
7434 if ((ctx
->region_type
& ORT_ACC
) == 0)
7436 bool is_declare_target
= false;
7437 if (is_global_var (decl
)
7438 && varpool_node::get_create (decl
)->offloadable
)
7440 struct gimplify_omp_ctx
*octx
;
7441 for (octx
= ctx
->outer_context
;
7442 octx
; octx
= octx
->outer_context
)
7444 n
= splay_tree_lookup (octx
->variables
,
7445 (splay_tree_key
)decl
);
7447 && (n
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
7448 && (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
7451 is_declare_target
= octx
== NULL
;
7453 if (!is_declare_target
)
7456 if (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
7457 || (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
7458 && (TREE_CODE (TREE_TYPE (TREE_TYPE (decl
)))
7460 gdmk
= GDMK_POINTER
;
7461 else if (lang_hooks
.decls
.omp_scalar_p (decl
))
7464 gdmk
= GDMK_AGGREGATE
;
7465 if (ctx
->defaultmap
[gdmk
] == 0)
7467 tree d
= lang_hooks
.decls
.omp_report_decl (decl
);
7468 error ("%qE not specified in enclosing %<target%>",
7470 error_at (ctx
->location
, "enclosing %<target%>");
7472 else if (ctx
->defaultmap
[gdmk
]
7473 & (GOVD_MAP_0LEN_ARRAY
| GOVD_FIRSTPRIVATE
))
7474 nflags
|= ctx
->defaultmap
[gdmk
];
7477 gcc_assert (ctx
->defaultmap
[gdmk
] & GOVD_MAP
);
7478 nflags
|= ctx
->defaultmap
[gdmk
] & ~GOVD_MAP
;
7483 struct gimplify_omp_ctx
*octx
= ctx
->outer_context
;
7484 if ((ctx
->region_type
& ORT_ACC
) && octx
)
7486 /* Look in outer OpenACC contexts, to see if there's a
7487 data attribute for this variable. */
7488 omp_notice_variable (octx
, decl
, in_code
);
7490 for (; octx
; octx
= octx
->outer_context
)
7492 if (!(octx
->region_type
& (ORT_TARGET_DATA
| ORT_TARGET
)))
7495 = splay_tree_lookup (octx
->variables
,
7496 (splay_tree_key
) decl
);
7499 if (octx
->region_type
== ORT_ACC_HOST_DATA
)
7500 error ("variable %qE declared in enclosing "
7501 "%<host_data%> region", DECL_NAME (decl
));
7503 if (octx
->region_type
== ORT_ACC_DATA
7504 && (n2
->value
& GOVD_MAP_0LEN_ARRAY
))
7505 nflags
|= GOVD_MAP_0LEN_ARRAY
;
7511 if ((nflags
& ~(GOVD_MAP_TO_ONLY
| GOVD_MAP_FROM_ONLY
7512 | GOVD_MAP_ALLOC_ONLY
)) == flags
)
7514 tree type
= TREE_TYPE (decl
);
7516 if (gimplify_omp_ctxp
->target_firstprivatize_array_bases
7517 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
7518 type
= TREE_TYPE (type
);
7519 if (!lang_hooks
.types
.omp_mappable_type (type
))
7521 error ("%qD referenced in target region does not have "
7522 "a mappable type", decl
);
7523 nflags
|= GOVD_MAP
| GOVD_EXPLICIT
;
7527 if ((ctx
->region_type
& ORT_ACC
) != 0)
7528 nflags
= oacc_default_clause (ctx
, decl
, flags
);
7534 omp_add_variable (ctx
, decl
, nflags
);
7538 /* If nothing changed, there's nothing left to do. */
7539 if ((n
->value
& flags
) == flags
)
7549 if (ctx
->region_type
== ORT_WORKSHARE
7550 || ctx
->region_type
== ORT_TASKGROUP
7551 || ctx
->region_type
== ORT_SIMD
7552 || ctx
->region_type
== ORT_ACC
7553 || (ctx
->region_type
& ORT_TARGET_DATA
) != 0)
7556 flags
= omp_default_clause (ctx
, decl
, in_code
, flags
);
7558 if ((flags
& GOVD_PRIVATE
)
7559 && lang_hooks
.decls
.omp_private_outer_ref (decl
))
7560 flags
|= GOVD_PRIVATE_OUTER_REF
;
7562 omp_add_variable (ctx
, decl
, flags
);
7564 shared
= (flags
& GOVD_SHARED
) != 0;
7565 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
7569 if ((n
->value
& (GOVD_SEEN
| GOVD_LOCAL
)) == 0
7570 && (flags
& (GOVD_SEEN
| GOVD_LOCAL
)) == GOVD_SEEN
7571 && DECL_SIZE (decl
))
7573 if (TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
7576 tree t
= DECL_VALUE_EXPR (decl
);
7577 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
7578 t
= TREE_OPERAND (t
, 0);
7579 gcc_assert (DECL_P (t
));
7580 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
7581 n2
->value
|= GOVD_SEEN
;
7583 else if (lang_hooks
.decls
.omp_privatize_by_reference (decl
)
7584 && TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)))
7585 && (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
))))
7589 tree t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
7590 gcc_assert (DECL_P (t
));
7591 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
7593 omp_notice_variable (ctx
, t
, true);
7597 if (ctx
->region_type
& ORT_ACC
)
7598 /* For OpenACC, as remarked above, defer expansion. */
7601 shared
= ((flags
| n
->value
) & GOVD_SHARED
) != 0;
7602 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
7604 /* If nothing changed, there's nothing left to do. */
7605 if ((n
->value
& flags
) == flags
)
7611 /* If the variable is private in the current context, then we don't
7612 need to propagate anything to an outer context. */
7613 if ((flags
& GOVD_PRIVATE
) && !(flags
& GOVD_PRIVATE_OUTER_REF
))
7615 if ((flags
& (GOVD_LINEAR
| GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
7616 == (GOVD_LINEAR
| GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
7618 if ((flags
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
7619 | GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
7620 == (GOVD_LASTPRIVATE
| GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
7622 if (ctx
->outer_context
7623 && omp_notice_variable (ctx
->outer_context
, decl
, in_code
))
7628 /* Verify that DECL is private within CTX. If there's specific information
7629 to the contrary in the innermost scope, generate an error. */
7632 omp_is_private (struct gimplify_omp_ctx
*ctx
, tree decl
, int simd
)
7636 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
7639 if (n
->value
& GOVD_SHARED
)
7641 if (ctx
== gimplify_omp_ctxp
)
7644 error ("iteration variable %qE is predetermined linear",
7647 error ("iteration variable %qE should be private",
7649 n
->value
= GOVD_PRIVATE
;
7655 else if ((n
->value
& GOVD_EXPLICIT
) != 0
7656 && (ctx
== gimplify_omp_ctxp
7657 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
7658 && gimplify_omp_ctxp
->outer_context
== ctx
)))
7660 if ((n
->value
& GOVD_FIRSTPRIVATE
) != 0)
7661 error ("iteration variable %qE should not be firstprivate",
7663 else if ((n
->value
& GOVD_REDUCTION
) != 0)
7664 error ("iteration variable %qE should not be reduction",
7666 else if (simd
!= 1 && (n
->value
& GOVD_LINEAR
) != 0)
7667 error ("iteration variable %qE should not be linear",
7670 return (ctx
== gimplify_omp_ctxp
7671 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
7672 && gimplify_omp_ctxp
->outer_context
== ctx
));
7675 if (ctx
->region_type
!= ORT_WORKSHARE
7676 && ctx
->region_type
!= ORT_TASKGROUP
7677 && ctx
->region_type
!= ORT_SIMD
7678 && ctx
->region_type
!= ORT_ACC
)
7680 else if (ctx
->outer_context
)
7681 return omp_is_private (ctx
->outer_context
, decl
, simd
);
7685 /* Return true if DECL is private within a parallel region
7686 that binds to the current construct's context or in parallel
7687 region's REDUCTION clause. */
7690 omp_check_private (struct gimplify_omp_ctx
*ctx
, tree decl
, bool copyprivate
)
7696 ctx
= ctx
->outer_context
;
7699 if (is_global_var (decl
))
7702 /* References might be private, but might be shared too,
7703 when checking for copyprivate, assume they might be
7704 private, otherwise assume they might be shared. */
7708 if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
7711 /* Treat C++ privatized non-static data members outside
7712 of the privatization the same. */
7713 if (omp_member_access_dummy_var (decl
))
7719 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
7721 if ((ctx
->region_type
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0
7722 && (n
== NULL
|| (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0))
7727 if ((n
->value
& GOVD_LOCAL
) != 0
7728 && omp_member_access_dummy_var (decl
))
7730 return (n
->value
& GOVD_SHARED
) == 0;
7733 while (ctx
->region_type
== ORT_WORKSHARE
7734 || ctx
->region_type
== ORT_TASKGROUP
7735 || ctx
->region_type
== ORT_SIMD
7736 || ctx
->region_type
== ORT_ACC
);
7740 /* Callback for walk_tree to find a DECL_EXPR for the given DECL. */
7743 find_decl_expr (tree
*tp
, int *walk_subtrees
, void *data
)
7747 /* If this node has been visited, unmark it and keep looking. */
7748 if (TREE_CODE (t
) == DECL_EXPR
&& DECL_EXPR_DECL (t
) == (tree
) data
)
7751 if (IS_TYPE_OR_DECL_P (t
))
7756 /* If *LIST_P contains any OpenMP depend clauses with iterators,
7757 lower all the depend clauses by populating corresponding depend
7758 array. Returns 0 if there are no such depend clauses, or
7759 2 if all depend clauses should be removed, 1 otherwise. */
7762 gimplify_omp_depend (tree
*list_p
, gimple_seq
*pre_p
)
7766 size_t n
[4] = { 0, 0, 0, 0 };
7768 tree counts
[4] = { NULL_TREE
, NULL_TREE
, NULL_TREE
, NULL_TREE
};
7769 tree last_iter
= NULL_TREE
, last_count
= NULL_TREE
;
7771 location_t first_loc
= UNKNOWN_LOCATION
;
7773 for (c
= *list_p
; c
; c
= OMP_CLAUSE_CHAIN (c
))
7774 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
)
7776 switch (OMP_CLAUSE_DEPEND_KIND (c
))
7778 case OMP_CLAUSE_DEPEND_IN
:
7781 case OMP_CLAUSE_DEPEND_OUT
:
7782 case OMP_CLAUSE_DEPEND_INOUT
:
7785 case OMP_CLAUSE_DEPEND_MUTEXINOUTSET
:
7788 case OMP_CLAUSE_DEPEND_DEPOBJ
:
7791 case OMP_CLAUSE_DEPEND_SOURCE
:
7792 case OMP_CLAUSE_DEPEND_SINK
:
7797 tree t
= OMP_CLAUSE_DECL (c
);
7798 if (first_loc
== UNKNOWN_LOCATION
)
7799 first_loc
= OMP_CLAUSE_LOCATION (c
);
7800 if (TREE_CODE (t
) == TREE_LIST
7802 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
7804 if (TREE_PURPOSE (t
) != last_iter
)
7806 tree tcnt
= size_one_node
;
7807 for (tree it
= TREE_PURPOSE (t
); it
; it
= TREE_CHAIN (it
))
7809 if (gimplify_expr (&TREE_VEC_ELT (it
, 1), pre_p
, NULL
,
7810 is_gimple_val
, fb_rvalue
) == GS_ERROR
7811 || gimplify_expr (&TREE_VEC_ELT (it
, 2), pre_p
, NULL
,
7812 is_gimple_val
, fb_rvalue
) == GS_ERROR
7813 || gimplify_expr (&TREE_VEC_ELT (it
, 3), pre_p
, NULL
,
7814 is_gimple_val
, fb_rvalue
) == GS_ERROR
7815 || (gimplify_expr (&TREE_VEC_ELT (it
, 4), pre_p
, NULL
,
7816 is_gimple_val
, fb_rvalue
)
7819 tree var
= TREE_VEC_ELT (it
, 0);
7820 tree begin
= TREE_VEC_ELT (it
, 1);
7821 tree end
= TREE_VEC_ELT (it
, 2);
7822 tree step
= TREE_VEC_ELT (it
, 3);
7823 tree orig_step
= TREE_VEC_ELT (it
, 4);
7824 tree type
= TREE_TYPE (var
);
7825 tree stype
= TREE_TYPE (step
);
7826 location_t loc
= DECL_SOURCE_LOCATION (var
);
7828 /* Compute count for this iterator as
7830 ? (begin < end ? (end - begin + (step - 1)) / step : 0)
7831 : (begin > end ? (end - begin + (step + 1)) / step : 0)
7832 and compute product of those for the entire depend
7834 if (POINTER_TYPE_P (type
))
7835 endmbegin
= fold_build2_loc (loc
, POINTER_DIFF_EXPR
,
7838 endmbegin
= fold_build2_loc (loc
, MINUS_EXPR
, type
,
7840 tree stepm1
= fold_build2_loc (loc
, MINUS_EXPR
, stype
,
7842 build_int_cst (stype
, 1));
7843 tree stepp1
= fold_build2_loc (loc
, PLUS_EXPR
, stype
, step
,
7844 build_int_cst (stype
, 1));
7845 tree pos
= fold_build2_loc (loc
, PLUS_EXPR
, stype
,
7846 unshare_expr (endmbegin
),
7848 pos
= fold_build2_loc (loc
, TRUNC_DIV_EXPR
, stype
,
7850 tree neg
= fold_build2_loc (loc
, PLUS_EXPR
, stype
,
7852 if (TYPE_UNSIGNED (stype
))
7854 neg
= fold_build1_loc (loc
, NEGATE_EXPR
, stype
, neg
);
7855 step
= fold_build1_loc (loc
, NEGATE_EXPR
, stype
, step
);
7857 neg
= fold_build2_loc (loc
, TRUNC_DIV_EXPR
, stype
,
7860 tree cond
= fold_build2_loc (loc
, LT_EXPR
,
7863 pos
= fold_build3_loc (loc
, COND_EXPR
, stype
, cond
, pos
,
7864 build_int_cst (stype
, 0));
7865 cond
= fold_build2_loc (loc
, LT_EXPR
, boolean_type_node
,
7867 neg
= fold_build3_loc (loc
, COND_EXPR
, stype
, cond
, neg
,
7868 build_int_cst (stype
, 0));
7869 tree osteptype
= TREE_TYPE (orig_step
);
7870 cond
= fold_build2_loc (loc
, GT_EXPR
, boolean_type_node
,
7872 build_int_cst (osteptype
, 0));
7873 tree cnt
= fold_build3_loc (loc
, COND_EXPR
, stype
,
7875 cnt
= fold_convert_loc (loc
, sizetype
, cnt
);
7876 if (gimplify_expr (&cnt
, pre_p
, NULL
, is_gimple_val
,
7877 fb_rvalue
) == GS_ERROR
)
7879 tcnt
= size_binop_loc (loc
, MULT_EXPR
, tcnt
, cnt
);
7881 if (gimplify_expr (&tcnt
, pre_p
, NULL
, is_gimple_val
,
7882 fb_rvalue
) == GS_ERROR
)
7884 last_iter
= TREE_PURPOSE (t
);
7887 if (counts
[i
] == NULL_TREE
)
7888 counts
[i
] = last_count
;
7890 counts
[i
] = size_binop_loc (OMP_CLAUSE_LOCATION (c
),
7891 PLUS_EXPR
, counts
[i
], last_count
);
7896 for (i
= 0; i
< 4; i
++)
7902 tree total
= size_zero_node
;
7903 for (i
= 0; i
< 4; i
++)
7905 unused
[i
] = counts
[i
] == NULL_TREE
&& n
[i
] == 0;
7906 if (counts
[i
] == NULL_TREE
)
7907 counts
[i
] = size_zero_node
;
7909 counts
[i
] = size_binop (PLUS_EXPR
, counts
[i
], size_int (n
[i
]));
7910 if (gimplify_expr (&counts
[i
], pre_p
, NULL
, is_gimple_val
,
7911 fb_rvalue
) == GS_ERROR
)
7913 total
= size_binop (PLUS_EXPR
, total
, counts
[i
]);
7916 if (gimplify_expr (&total
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7919 bool is_old
= unused
[1] && unused
[3];
7920 tree totalpx
= size_binop (PLUS_EXPR
, unshare_expr (total
),
7921 size_int (is_old
? 1 : 4));
7922 tree type
= build_array_type (ptr_type_node
, build_index_type (totalpx
));
7923 tree array
= create_tmp_var_raw (type
);
7924 TREE_ADDRESSABLE (array
) = 1;
7925 if (!poly_int_tree_p (totalpx
))
7927 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (array
)))
7928 gimplify_type_sizes (TREE_TYPE (array
), pre_p
);
7929 if (gimplify_omp_ctxp
)
7931 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
7933 && (ctx
->region_type
== ORT_WORKSHARE
7934 || ctx
->region_type
== ORT_TASKGROUP
7935 || ctx
->region_type
== ORT_SIMD
7936 || ctx
->region_type
== ORT_ACC
))
7937 ctx
= ctx
->outer_context
;
7939 omp_add_variable (ctx
, array
, GOVD_LOCAL
| GOVD_SEEN
);
7941 gimplify_vla_decl (array
, pre_p
);
7944 gimple_add_tmp_var (array
);
7945 tree r
= build4 (ARRAY_REF
, ptr_type_node
, array
, size_int (0), NULL_TREE
,
7950 tem
= build2 (MODIFY_EXPR
, void_type_node
, r
,
7951 build_int_cst (ptr_type_node
, 0));
7952 gimplify_and_add (tem
, pre_p
);
7953 r
= build4 (ARRAY_REF
, ptr_type_node
, array
, size_int (1), NULL_TREE
,
7956 tem
= build2 (MODIFY_EXPR
, void_type_node
, r
,
7957 fold_convert (ptr_type_node
, total
));
7958 gimplify_and_add (tem
, pre_p
);
7959 for (i
= 1; i
< (is_old
? 2 : 4); i
++)
7961 r
= build4 (ARRAY_REF
, ptr_type_node
, array
, size_int (i
+ !is_old
),
7962 NULL_TREE
, NULL_TREE
);
7963 tem
= build2 (MODIFY_EXPR
, void_type_node
, r
, counts
[i
- 1]);
7964 gimplify_and_add (tem
, pre_p
);
7971 for (i
= 0; i
< 4; i
++)
7973 if (i
&& (i
>= j
|| unused
[i
- 1]))
7975 cnts
[i
] = cnts
[i
- 1];
7978 cnts
[i
] = create_tmp_var (sizetype
);
7980 g
= gimple_build_assign (cnts
[i
], size_int (is_old
? 2 : 5));
7985 t
= size_binop (PLUS_EXPR
, counts
[0], size_int (2));
7987 t
= size_binop (PLUS_EXPR
, cnts
[i
- 1], counts
[i
- 1]);
7988 if (gimplify_expr (&t
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7991 g
= gimple_build_assign (cnts
[i
], t
);
7993 gimple_seq_add_stmt (pre_p
, g
);
7996 last_iter
= NULL_TREE
;
7997 tree last_bind
= NULL_TREE
;
7998 tree
*last_body
= NULL
;
7999 for (c
= *list_p
; c
; c
= OMP_CLAUSE_CHAIN (c
))
8000 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
)
8002 switch (OMP_CLAUSE_DEPEND_KIND (c
))
8004 case OMP_CLAUSE_DEPEND_IN
:
8007 case OMP_CLAUSE_DEPEND_OUT
:
8008 case OMP_CLAUSE_DEPEND_INOUT
:
8011 case OMP_CLAUSE_DEPEND_MUTEXINOUTSET
:
8014 case OMP_CLAUSE_DEPEND_DEPOBJ
:
8017 case OMP_CLAUSE_DEPEND_SOURCE
:
8018 case OMP_CLAUSE_DEPEND_SINK
:
8023 tree t
= OMP_CLAUSE_DECL (c
);
8024 if (TREE_CODE (t
) == TREE_LIST
8026 && TREE_CODE (TREE_PURPOSE (t
)) == TREE_VEC
)
8028 if (TREE_PURPOSE (t
) != last_iter
)
8031 gimplify_and_add (last_bind
, pre_p
);
8032 tree block
= TREE_VEC_ELT (TREE_PURPOSE (t
), 5);
8033 last_bind
= build3 (BIND_EXPR
, void_type_node
,
8034 BLOCK_VARS (block
), NULL
, block
);
8035 TREE_SIDE_EFFECTS (last_bind
) = 1;
8036 SET_EXPR_LOCATION (last_bind
, OMP_CLAUSE_LOCATION (c
));
8037 tree
*p
= &BIND_EXPR_BODY (last_bind
);
8038 for (tree it
= TREE_PURPOSE (t
); it
; it
= TREE_CHAIN (it
))
8040 tree var
= TREE_VEC_ELT (it
, 0);
8041 tree begin
= TREE_VEC_ELT (it
, 1);
8042 tree end
= TREE_VEC_ELT (it
, 2);
8043 tree step
= TREE_VEC_ELT (it
, 3);
8044 tree orig_step
= TREE_VEC_ELT (it
, 4);
8045 tree type
= TREE_TYPE (var
);
8046 location_t loc
= DECL_SOURCE_LOCATION (var
);
8054 if (orig_step > 0) {
8055 if (var < end) goto beg_label;
8057 if (var > end) goto beg_label;
8059 for each iterator, with inner iterators added to
8061 tree beg_label
= create_artificial_label (loc
);
8062 tree cond_label
= NULL_TREE
;
8063 tem
= build2_loc (loc
, MODIFY_EXPR
, void_type_node
,
8065 append_to_statement_list_force (tem
, p
);
8066 tem
= build_and_jump (&cond_label
);
8067 append_to_statement_list_force (tem
, p
);
8068 tem
= build1 (LABEL_EXPR
, void_type_node
, beg_label
);
8069 append_to_statement_list (tem
, p
);
8070 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL_TREE
,
8071 NULL_TREE
, NULL_TREE
);
8072 TREE_SIDE_EFFECTS (bind
) = 1;
8073 SET_EXPR_LOCATION (bind
, loc
);
8074 append_to_statement_list_force (bind
, p
);
8075 if (POINTER_TYPE_P (type
))
8076 tem
= build2_loc (loc
, POINTER_PLUS_EXPR
, type
,
8077 var
, fold_convert_loc (loc
, sizetype
,
8080 tem
= build2_loc (loc
, PLUS_EXPR
, type
, var
, step
);
8081 tem
= build2_loc (loc
, MODIFY_EXPR
, void_type_node
,
8083 append_to_statement_list_force (tem
, p
);
8084 tem
= build1 (LABEL_EXPR
, void_type_node
, cond_label
);
8085 append_to_statement_list (tem
, p
);
8086 tree cond
= fold_build2_loc (loc
, LT_EXPR
,
8090 = fold_build3_loc (loc
, COND_EXPR
, void_type_node
,
8091 cond
, build_and_jump (&beg_label
),
8093 cond
= fold_build2_loc (loc
, GT_EXPR
, boolean_type_node
,
8096 = fold_build3_loc (loc
, COND_EXPR
, void_type_node
,
8097 cond
, build_and_jump (&beg_label
),
8099 tree osteptype
= TREE_TYPE (orig_step
);
8100 cond
= fold_build2_loc (loc
, GT_EXPR
, boolean_type_node
,
8102 build_int_cst (osteptype
, 0));
8103 tem
= fold_build3_loc (loc
, COND_EXPR
, void_type_node
,
8105 append_to_statement_list_force (tem
, p
);
8106 p
= &BIND_EXPR_BODY (bind
);
8110 last_iter
= TREE_PURPOSE (t
);
8111 if (TREE_CODE (TREE_VALUE (t
)) == COMPOUND_EXPR
)
8113 append_to_statement_list (TREE_OPERAND (TREE_VALUE (t
),
8115 TREE_VALUE (t
) = TREE_OPERAND (TREE_VALUE (t
), 1);
8117 if (error_operand_p (TREE_VALUE (t
)))
8119 TREE_VALUE (t
) = build_fold_addr_expr (TREE_VALUE (t
));
8120 r
= build4 (ARRAY_REF
, ptr_type_node
, array
, cnts
[i
],
8121 NULL_TREE
, NULL_TREE
);
8122 tem
= build2_loc (OMP_CLAUSE_LOCATION (c
), MODIFY_EXPR
,
8123 void_type_node
, r
, TREE_VALUE (t
));
8124 append_to_statement_list_force (tem
, last_body
);
8125 tem
= build2_loc (OMP_CLAUSE_LOCATION (c
), MODIFY_EXPR
,
8126 void_type_node
, cnts
[i
],
8127 size_binop (PLUS_EXPR
, cnts
[i
], size_int (1)));
8128 append_to_statement_list_force (tem
, last_body
);
8129 TREE_VALUE (t
) = null_pointer_node
;
8135 gimplify_and_add (last_bind
, pre_p
);
8136 last_bind
= NULL_TREE
;
8138 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == COMPOUND_EXPR
)
8140 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0), pre_p
,
8141 NULL
, is_gimple_val
, fb_rvalue
);
8142 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (OMP_CLAUSE_DECL (c
), 1);
8144 if (error_operand_p (OMP_CLAUSE_DECL (c
)))
8146 OMP_CLAUSE_DECL (c
) = build_fold_addr_expr (OMP_CLAUSE_DECL (c
));
8147 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
, NULL
,
8148 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8150 r
= build4 (ARRAY_REF
, ptr_type_node
, array
, cnts
[i
],
8151 NULL_TREE
, NULL_TREE
);
8152 tem
= build2 (MODIFY_EXPR
, void_type_node
, r
, OMP_CLAUSE_DECL (c
));
8153 gimplify_and_add (tem
, pre_p
);
8154 g
= gimple_build_assign (cnts
[i
], size_binop (PLUS_EXPR
, cnts
[i
],
8156 gimple_seq_add_stmt (pre_p
, g
);
8160 gimplify_and_add (last_bind
, pre_p
);
8161 tree cond
= boolean_false_node
;
8165 cond
= build2_loc (first_loc
, NE_EXPR
, boolean_type_node
, cnts
[0],
8166 size_binop_loc (first_loc
, PLUS_EXPR
, counts
[0],
8169 cond
= build2_loc (first_loc
, TRUTH_OR_EXPR
, boolean_type_node
, cond
,
8170 build2_loc (first_loc
, NE_EXPR
, boolean_type_node
,
8172 size_binop_loc (first_loc
, PLUS_EXPR
,
8178 tree prev
= size_int (5);
8179 for (i
= 0; i
< 4; i
++)
8183 prev
= size_binop_loc (first_loc
, PLUS_EXPR
, counts
[i
], prev
);
8184 cond
= build2_loc (first_loc
, TRUTH_OR_EXPR
, boolean_type_node
, cond
,
8185 build2_loc (first_loc
, NE_EXPR
, boolean_type_node
,
8186 cnts
[i
], unshare_expr (prev
)));
8189 tem
= build3_loc (first_loc
, COND_EXPR
, void_type_node
, cond
,
8190 build_call_expr_loc (first_loc
,
8191 builtin_decl_explicit (BUILT_IN_TRAP
),
8193 gimplify_and_add (tem
, pre_p
);
8194 c
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE_DEPEND
);
8195 OMP_CLAUSE_DEPEND_KIND (c
) = OMP_CLAUSE_DEPEND_LAST
;
8196 OMP_CLAUSE_DECL (c
) = build_fold_addr_expr (array
);
8197 OMP_CLAUSE_CHAIN (c
) = *list_p
;
8202 /* Insert a GOMP_MAP_ALLOC or GOMP_MAP_RELEASE node following a
8203 GOMP_MAP_STRUCT mapping. C is an always_pointer mapping. STRUCT_NODE is
8204 the struct node to insert the new mapping after (when the struct node is
8205 initially created). PREV_NODE is the first of two or three mappings for a
8206 pointer, and is either:
8207 - the node before C, when a pair of mappings is used, e.g. for a C/C++
8209 - not the node before C. This is true when we have a reference-to-pointer
8210 type (with a mapping for the reference and for the pointer), or for
8211 Fortran derived-type mappings with a GOMP_MAP_TO_PSET.
8212 If SCP is non-null, the new node is inserted before *SCP.
8213 if SCP is null, the new node is inserted before PREV_NODE.
8215 - PREV_NODE, if SCP is non-null.
8216 - The newly-created ALLOC or RELEASE node, if SCP is null.
8217 - The second newly-created ALLOC or RELEASE node, if we are mapping a
8218 reference to a pointer. */
8221 insert_struct_comp_map (enum tree_code code
, tree c
, tree struct_node
,
8222 tree prev_node
, tree
*scp
)
8224 enum gomp_map_kind mkind
8225 = (code
== OMP_TARGET_EXIT_DATA
|| code
== OACC_EXIT_DATA
)
8226 ? GOMP_MAP_RELEASE
: GOMP_MAP_ALLOC
;
8228 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
), OMP_CLAUSE_MAP
);
8229 tree cl
= scp
? prev_node
: c2
;
8230 OMP_CLAUSE_SET_MAP_KIND (c2
, mkind
);
8231 OMP_CLAUSE_DECL (c2
) = unshare_expr (OMP_CLAUSE_DECL (c
));
8232 OMP_CLAUSE_CHAIN (c2
) = scp
? *scp
: prev_node
;
8233 if (OMP_CLAUSE_CHAIN (prev_node
) != c
8234 && OMP_CLAUSE_CODE (OMP_CLAUSE_CHAIN (prev_node
)) == OMP_CLAUSE_MAP
8235 && (OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (prev_node
))
8236 == GOMP_MAP_TO_PSET
))
8237 OMP_CLAUSE_SIZE (c2
) = OMP_CLAUSE_SIZE (OMP_CLAUSE_CHAIN (prev_node
));
8239 OMP_CLAUSE_SIZE (c2
) = TYPE_SIZE_UNIT (ptr_type_node
);
8241 OMP_CLAUSE_CHAIN (struct_node
) = c2
;
8243 /* We might need to create an additional mapping if we have a reference to a
8244 pointer (in C++). Don't do this if we have something other than a
8245 GOMP_MAP_ALWAYS_POINTER though, i.e. a GOMP_MAP_TO_PSET. */
8246 if (OMP_CLAUSE_CHAIN (prev_node
) != c
8247 && OMP_CLAUSE_CODE (OMP_CLAUSE_CHAIN (prev_node
)) == OMP_CLAUSE_MAP
8248 && ((OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (prev_node
))
8249 == GOMP_MAP_ALWAYS_POINTER
)
8250 || (OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (prev_node
))
8251 == GOMP_MAP_ATTACH_DETACH
)))
8253 tree c4
= OMP_CLAUSE_CHAIN (prev_node
);
8254 tree c3
= build_omp_clause (OMP_CLAUSE_LOCATION (c
), OMP_CLAUSE_MAP
);
8255 OMP_CLAUSE_SET_MAP_KIND (c3
, mkind
);
8256 OMP_CLAUSE_DECL (c3
) = unshare_expr (OMP_CLAUSE_DECL (c4
));
8257 OMP_CLAUSE_SIZE (c3
) = TYPE_SIZE_UNIT (ptr_type_node
);
8258 OMP_CLAUSE_CHAIN (c3
) = prev_node
;
8260 OMP_CLAUSE_CHAIN (c2
) = c3
;
8271 /* Strip ARRAY_REFS or an indirect ref off BASE, find the containing object,
8272 and set *BITPOSP and *POFFSETP to the bit offset of the access.
8273 If BASE_REF is non-NULL and the containing object is a reference, set
8274 *BASE_REF to that reference before dereferencing the object.
8275 If BASE_REF is NULL, check that the containing object is a COMPONENT_REF or
8276 has array type, else return NULL. */
8279 extract_base_bit_offset (tree base
, tree
*base_ref
, poly_int64
*bitposp
,
8280 poly_offset_int
*poffsetp
)
8283 poly_int64 bitsize
, bitpos
;
8285 int unsignedp
, reversep
, volatilep
= 0;
8286 poly_offset_int poffset
;
8290 *base_ref
= NULL_TREE
;
8292 while (TREE_CODE (base
) == ARRAY_REF
)
8293 base
= TREE_OPERAND (base
, 0);
8295 if (TREE_CODE (base
) == INDIRECT_REF
)
8296 base
= TREE_OPERAND (base
, 0);
8300 if (TREE_CODE (base
) == ARRAY_REF
)
8302 while (TREE_CODE (base
) == ARRAY_REF
)
8303 base
= TREE_OPERAND (base
, 0);
8304 if (TREE_CODE (base
) != COMPONENT_REF
8305 || TREE_CODE (TREE_TYPE (base
)) != ARRAY_TYPE
)
8308 else if (TREE_CODE (base
) == INDIRECT_REF
8309 && TREE_CODE (TREE_OPERAND (base
, 0)) == COMPONENT_REF
8310 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base
, 0)))
8312 base
= TREE_OPERAND (base
, 0);
8315 base
= get_inner_reference (base
, &bitsize
, &bitpos
, &offset
, &mode
,
8316 &unsignedp
, &reversep
, &volatilep
);
8318 tree orig_base
= base
;
8320 if ((TREE_CODE (base
) == INDIRECT_REF
8321 || (TREE_CODE (base
) == MEM_REF
8322 && integer_zerop (TREE_OPERAND (base
, 1))))
8323 && DECL_P (TREE_OPERAND (base
, 0))
8324 && TREE_CODE (TREE_TYPE (TREE_OPERAND (base
, 0))) == REFERENCE_TYPE
)
8325 base
= TREE_OPERAND (base
, 0);
8327 gcc_assert (offset
== NULL_TREE
|| poly_int_tree_p (offset
));
8330 poffset
= wi::to_poly_offset (offset
);
8334 if (maybe_ne (bitpos
, 0))
8335 poffset
+= bits_to_bytes_round_down (bitpos
);
8338 *poffsetp
= poffset
;
8340 /* Set *BASE_REF if BASE was a dereferenced reference variable. */
8341 if (base_ref
&& orig_base
!= base
)
8342 *base_ref
= orig_base
;
8347 /* Scan the OMP clauses in *LIST_P, installing mappings into a new
8348 and previous omp contexts. */
8351 gimplify_scan_omp_clauses (tree
*list_p
, gimple_seq
*pre_p
,
8352 enum omp_region_type region_type
,
8353 enum tree_code code
)
8355 struct gimplify_omp_ctx
*ctx
, *outer_ctx
;
8357 hash_map
<tree
, tree
> *struct_map_to_clause
= NULL
;
8358 hash_set
<tree
> *struct_deref_set
= NULL
;
8359 tree
*prev_list_p
= NULL
, *orig_list_p
= list_p
;
8360 int handled_depend_iterators
= -1;
8363 ctx
= new_omp_context (region_type
);
8365 outer_ctx
= ctx
->outer_context
;
8366 if (code
== OMP_TARGET
)
8368 if (!lang_GNU_Fortran ())
8369 ctx
->defaultmap
[GDMK_POINTER
] = GOVD_MAP
| GOVD_MAP_0LEN_ARRAY
;
8370 ctx
->defaultmap
[GDMK_SCALAR
] = GOVD_FIRSTPRIVATE
;
8372 if (!lang_GNU_Fortran ())
8376 case OMP_TARGET_DATA
:
8377 case OMP_TARGET_ENTER_DATA
:
8378 case OMP_TARGET_EXIT_DATA
:
8380 case OACC_HOST_DATA
:
8383 ctx
->target_firstprivatize_array_bases
= true;
8388 while ((c
= *list_p
) != NULL
)
8390 bool remove
= false;
8391 bool notice_outer
= true;
8392 const char *check_non_private
= NULL
;
8396 switch (OMP_CLAUSE_CODE (c
))
8398 case OMP_CLAUSE_PRIVATE
:
8399 flags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
8400 if (lang_hooks
.decls
.omp_private_outer_ref (OMP_CLAUSE_DECL (c
)))
8402 flags
|= GOVD_PRIVATE_OUTER_REF
;
8403 OMP_CLAUSE_PRIVATE_OUTER_REF (c
) = 1;
8406 notice_outer
= false;
8408 case OMP_CLAUSE_SHARED
:
8409 flags
= GOVD_SHARED
| GOVD_EXPLICIT
;
8411 case OMP_CLAUSE_FIRSTPRIVATE
:
8412 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
8413 check_non_private
= "firstprivate";
8415 case OMP_CLAUSE_LASTPRIVATE
:
8416 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
))
8419 case OMP_DISTRIBUTE
:
8420 error_at (OMP_CLAUSE_LOCATION (c
),
8421 "conditional %<lastprivate%> clause on "
8422 "%qs construct", "distribute");
8423 OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
) = 0;
8426 error_at (OMP_CLAUSE_LOCATION (c
),
8427 "conditional %<lastprivate%> clause on "
8428 "%qs construct", "taskloop");
8429 OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
) = 0;
8434 flags
= GOVD_LASTPRIVATE
| GOVD_SEEN
| GOVD_EXPLICIT
;
8435 if (code
!= OMP_LOOP
)
8436 check_non_private
= "lastprivate";
8437 decl
= OMP_CLAUSE_DECL (c
);
8438 if (error_operand_p (decl
))
8440 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
)
8441 && !lang_hooks
.decls
.omp_scalar_p (decl
))
8443 error_at (OMP_CLAUSE_LOCATION (c
),
8444 "non-scalar variable %qD in conditional "
8445 "%<lastprivate%> clause", decl
);
8446 OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
) = 0;
8448 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
))
8449 flags
|= GOVD_LASTPRIVATE_CONDITIONAL
;
8451 && (outer_ctx
->region_type
== ORT_COMBINED_PARALLEL
8452 || ((outer_ctx
->region_type
& ORT_COMBINED_TEAMS
)
8453 == ORT_COMBINED_TEAMS
))
8454 && splay_tree_lookup (outer_ctx
->variables
,
8455 (splay_tree_key
) decl
) == NULL
)
8457 omp_add_variable (outer_ctx
, decl
, GOVD_SHARED
| GOVD_SEEN
);
8458 if (outer_ctx
->outer_context
)
8459 omp_notice_variable (outer_ctx
->outer_context
, decl
, true);
8462 && (outer_ctx
->region_type
& ORT_TASK
) != 0
8463 && outer_ctx
->combined_loop
8464 && splay_tree_lookup (outer_ctx
->variables
,
8465 (splay_tree_key
) decl
) == NULL
)
8467 omp_add_variable (outer_ctx
, decl
, GOVD_LASTPRIVATE
| GOVD_SEEN
);
8468 if (outer_ctx
->outer_context
)
8469 omp_notice_variable (outer_ctx
->outer_context
, decl
, true);
8472 && (outer_ctx
->region_type
== ORT_WORKSHARE
8473 || outer_ctx
->region_type
== ORT_ACC
)
8474 && outer_ctx
->combined_loop
8475 && splay_tree_lookup (outer_ctx
->variables
,
8476 (splay_tree_key
) decl
) == NULL
8477 && !omp_check_private (outer_ctx
, decl
, false))
8479 omp_add_variable (outer_ctx
, decl
, GOVD_LASTPRIVATE
| GOVD_SEEN
);
8480 if (outer_ctx
->outer_context
8481 && (outer_ctx
->outer_context
->region_type
8482 == ORT_COMBINED_PARALLEL
)
8483 && splay_tree_lookup (outer_ctx
->outer_context
->variables
,
8484 (splay_tree_key
) decl
) == NULL
)
8486 struct gimplify_omp_ctx
*octx
= outer_ctx
->outer_context
;
8487 omp_add_variable (octx
, decl
, GOVD_SHARED
| GOVD_SEEN
);
8488 if (octx
->outer_context
)
8490 octx
= octx
->outer_context
;
8491 if (octx
->region_type
== ORT_WORKSHARE
8492 && octx
->combined_loop
8493 && splay_tree_lookup (octx
->variables
,
8494 (splay_tree_key
) decl
) == NULL
8495 && !omp_check_private (octx
, decl
, false))
8497 omp_add_variable (octx
, decl
,
8498 GOVD_LASTPRIVATE
| GOVD_SEEN
);
8499 octx
= octx
->outer_context
;
8501 && ((octx
->region_type
& ORT_COMBINED_TEAMS
)
8502 == ORT_COMBINED_TEAMS
)
8503 && (splay_tree_lookup (octx
->variables
,
8504 (splay_tree_key
) decl
)
8507 omp_add_variable (octx
, decl
,
8508 GOVD_SHARED
| GOVD_SEEN
);
8509 octx
= octx
->outer_context
;
8513 omp_notice_variable (octx
, decl
, true);
8516 else if (outer_ctx
->outer_context
)
8517 omp_notice_variable (outer_ctx
->outer_context
, decl
, true);
8520 case OMP_CLAUSE_REDUCTION
:
8521 if (OMP_CLAUSE_REDUCTION_TASK (c
))
8523 if (region_type
== ORT_WORKSHARE
)
8526 nowait
= omp_find_clause (*list_p
,
8527 OMP_CLAUSE_NOWAIT
) != NULL_TREE
;
8529 && (outer_ctx
== NULL
8530 || outer_ctx
->region_type
!= ORT_COMBINED_PARALLEL
))
8532 error_at (OMP_CLAUSE_LOCATION (c
),
8533 "%<task%> reduction modifier on a construct "
8534 "with a %<nowait%> clause");
8535 OMP_CLAUSE_REDUCTION_TASK (c
) = 0;
8538 else if ((region_type
& ORT_PARALLEL
) != ORT_PARALLEL
)
8540 error_at (OMP_CLAUSE_LOCATION (c
),
8541 "invalid %<task%> reduction modifier on construct "
8542 "other than %<parallel%>, %<for%> or %<sections%>");
8543 OMP_CLAUSE_REDUCTION_TASK (c
) = 0;
8546 if (OMP_CLAUSE_REDUCTION_INSCAN (c
))
8550 error_at (OMP_CLAUSE_LOCATION (c
),
8551 "%<inscan%> %<reduction%> clause on "
8552 "%qs construct", "sections");
8553 OMP_CLAUSE_REDUCTION_INSCAN (c
) = 0;
8556 error_at (OMP_CLAUSE_LOCATION (c
),
8557 "%<inscan%> %<reduction%> clause on "
8558 "%qs construct", "parallel");
8559 OMP_CLAUSE_REDUCTION_INSCAN (c
) = 0;
8562 error_at (OMP_CLAUSE_LOCATION (c
),
8563 "%<inscan%> %<reduction%> clause on "
8564 "%qs construct", "teams");
8565 OMP_CLAUSE_REDUCTION_INSCAN (c
) = 0;
8568 error_at (OMP_CLAUSE_LOCATION (c
),
8569 "%<inscan%> %<reduction%> clause on "
8570 "%qs construct", "taskloop");
8571 OMP_CLAUSE_REDUCTION_INSCAN (c
) = 0;
8577 case OMP_CLAUSE_IN_REDUCTION
:
8578 case OMP_CLAUSE_TASK_REDUCTION
:
8579 flags
= GOVD_REDUCTION
| GOVD_SEEN
| GOVD_EXPLICIT
;
8580 /* OpenACC permits reductions on private variables. */
8581 if (!(region_type
& ORT_ACC
)
8582 /* taskgroup is actually not a worksharing region. */
8583 && code
!= OMP_TASKGROUP
)
8584 check_non_private
= omp_clause_code_name
[OMP_CLAUSE_CODE (c
)];
8585 decl
= OMP_CLAUSE_DECL (c
);
8586 if (TREE_CODE (decl
) == MEM_REF
)
8588 tree type
= TREE_TYPE (decl
);
8589 if (gimplify_expr (&TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), pre_p
,
8590 NULL
, is_gimple_val
, fb_rvalue
, false)
8596 tree v
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
8599 omp_firstprivatize_variable (ctx
, v
);
8600 omp_notice_variable (ctx
, v
, true);
8602 decl
= TREE_OPERAND (decl
, 0);
8603 if (TREE_CODE (decl
) == POINTER_PLUS_EXPR
)
8605 if (gimplify_expr (&TREE_OPERAND (decl
, 1), pre_p
,
8606 NULL
, is_gimple_val
, fb_rvalue
, false)
8612 v
= TREE_OPERAND (decl
, 1);
8615 omp_firstprivatize_variable (ctx
, v
);
8616 omp_notice_variable (ctx
, v
, true);
8618 decl
= TREE_OPERAND (decl
, 0);
8620 if (TREE_CODE (decl
) == ADDR_EXPR
8621 || TREE_CODE (decl
) == INDIRECT_REF
)
8622 decl
= TREE_OPERAND (decl
, 0);
8625 case OMP_CLAUSE_LINEAR
:
8626 if (gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
), pre_p
, NULL
,
8627 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8634 if (code
== OMP_SIMD
8635 && !OMP_CLAUSE_LINEAR_NO_COPYIN (c
))
8637 struct gimplify_omp_ctx
*octx
= outer_ctx
;
8639 && octx
->region_type
== ORT_WORKSHARE
8640 && octx
->combined_loop
8641 && !octx
->distribute
)
8643 if (octx
->outer_context
8644 && (octx
->outer_context
->region_type
8645 == ORT_COMBINED_PARALLEL
))
8646 octx
= octx
->outer_context
->outer_context
;
8648 octx
= octx
->outer_context
;
8651 && octx
->region_type
== ORT_WORKSHARE
8652 && octx
->combined_loop
8653 && octx
->distribute
)
8655 error_at (OMP_CLAUSE_LOCATION (c
),
8656 "%<linear%> clause for variable other than "
8657 "loop iterator specified on construct "
8658 "combined with %<distribute%>");
8663 /* For combined #pragma omp parallel for simd, need to put
8664 lastprivate and perhaps firstprivate too on the
8665 parallel. Similarly for #pragma omp for simd. */
8666 struct gimplify_omp_ctx
*octx
= outer_ctx
;
8670 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
8671 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
8673 decl
= OMP_CLAUSE_DECL (c
);
8674 if (error_operand_p (decl
))
8680 if (!OMP_CLAUSE_LINEAR_NO_COPYIN (c
))
8681 flags
|= GOVD_FIRSTPRIVATE
;
8682 if (!OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
8683 flags
|= GOVD_LASTPRIVATE
;
8685 && octx
->region_type
== ORT_WORKSHARE
8686 && octx
->combined_loop
)
8688 if (octx
->outer_context
8689 && (octx
->outer_context
->region_type
8690 == ORT_COMBINED_PARALLEL
))
8691 octx
= octx
->outer_context
;
8692 else if (omp_check_private (octx
, decl
, false))
8696 && (octx
->region_type
& ORT_TASK
) != 0
8697 && octx
->combined_loop
)
8700 && octx
->region_type
== ORT_COMBINED_PARALLEL
8701 && ctx
->region_type
== ORT_WORKSHARE
8702 && octx
== outer_ctx
)
8703 flags
= GOVD_SEEN
| GOVD_SHARED
;
8705 && ((octx
->region_type
& ORT_COMBINED_TEAMS
)
8706 == ORT_COMBINED_TEAMS
))
8707 flags
= GOVD_SEEN
| GOVD_SHARED
;
8709 && octx
->region_type
== ORT_COMBINED_TARGET
)
8711 flags
&= ~GOVD_LASTPRIVATE
;
8712 if (flags
== GOVD_SEEN
)
8718 = splay_tree_lookup (octx
->variables
,
8719 (splay_tree_key
) decl
);
8720 if (on
&& (on
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
8725 omp_add_variable (octx
, decl
, flags
);
8726 if (octx
->outer_context
== NULL
)
8728 octx
= octx
->outer_context
;
8733 && (!OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
8734 || !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)))
8735 omp_notice_variable (octx
, decl
, true);
8737 flags
= GOVD_LINEAR
| GOVD_EXPLICIT
;
8738 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
8739 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
8741 notice_outer
= false;
8742 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
8746 case OMP_CLAUSE_MAP
:
8747 decl
= OMP_CLAUSE_DECL (c
);
8748 if (error_operand_p (decl
))
8755 if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
8758 case OMP_TARGET_DATA
:
8759 case OMP_TARGET_ENTER_DATA
:
8760 case OMP_TARGET_EXIT_DATA
:
8761 case OACC_HOST_DATA
:
8762 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
8763 || (OMP_CLAUSE_MAP_KIND (c
)
8764 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
8765 /* For target {,enter ,exit }data only the array slice is
8766 mapped, but not the pointer to it. */
8769 case OACC_ENTER_DATA
:
8770 case OACC_EXIT_DATA
:
8771 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
8772 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_TO_PSET
8773 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
8774 || (OMP_CLAUSE_MAP_KIND (c
)
8775 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
8781 /* For Fortran, not only the pointer to the data is mapped but also
8782 the address of the pointer, the array descriptor etc.; for
8783 'exit data' - and in particular for 'delete:' - having an 'alloc:'
8784 does not make sense. Likewise, for 'update' only transferring the
8785 data itself is needed as the rest has been handled in previous
8787 if ((code
== OMP_TARGET_EXIT_DATA
|| code
== OMP_TARGET_UPDATE
)
8788 && (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
8789 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_TO_PSET
))
8794 if (DECL_P (decl
) && outer_ctx
&& (region_type
& ORT_ACC
))
8796 struct gimplify_omp_ctx
*octx
;
8797 for (octx
= outer_ctx
; octx
; octx
= octx
->outer_context
)
8799 if (octx
->region_type
!= ORT_ACC_HOST_DATA
)
8802 = splay_tree_lookup (octx
->variables
,
8803 (splay_tree_key
) decl
);
8805 error_at (OMP_CLAUSE_LOCATION (c
), "variable %qE "
8806 "declared in enclosing %<host_data%> region",
8810 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
8811 OMP_CLAUSE_SIZE (c
) = DECL_P (decl
) ? DECL_SIZE_UNIT (decl
)
8812 : TYPE_SIZE_UNIT (TREE_TYPE (decl
));
8813 if (gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
8814 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8819 else if ((OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
8820 || (OMP_CLAUSE_MAP_KIND (c
)
8821 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
8822 && TREE_CODE (OMP_CLAUSE_SIZE (c
)) != INTEGER_CST
)
8825 = get_initialized_tmp_var (OMP_CLAUSE_SIZE (c
), pre_p
, NULL
,
8827 omp_add_variable (ctx
, OMP_CLAUSE_SIZE (c
),
8828 GOVD_FIRSTPRIVATE
| GOVD_SEEN
);
8833 if (TREE_CODE (d
) == ARRAY_REF
)
8835 while (TREE_CODE (d
) == ARRAY_REF
)
8836 d
= TREE_OPERAND (d
, 0);
8837 if (TREE_CODE (d
) == COMPONENT_REF
8838 && TREE_CODE (TREE_TYPE (d
)) == ARRAY_TYPE
)
8841 pd
= &OMP_CLAUSE_DECL (c
);
8843 && TREE_CODE (decl
) == INDIRECT_REF
8844 && TREE_CODE (TREE_OPERAND (decl
, 0)) == COMPONENT_REF
8845 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl
, 0)))
8848 pd
= &TREE_OPERAND (decl
, 0);
8849 decl
= TREE_OPERAND (decl
, 0);
8851 bool indir_p
= false;
8852 tree orig_decl
= decl
;
8853 tree decl_ref
= NULL_TREE
;
8854 if ((region_type
& ORT_ACC
) != 0
8855 && TREE_CODE (*pd
) == COMPONENT_REF
8856 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ATTACH_DETACH
8857 && code
!= OACC_UPDATE
)
8859 while (TREE_CODE (decl
) == COMPONENT_REF
)
8861 decl
= TREE_OPERAND (decl
, 0);
8862 if ((TREE_CODE (decl
) == MEM_REF
8863 && integer_zerop (TREE_OPERAND (decl
, 1)))
8864 || INDIRECT_REF_P (decl
))
8867 decl
= TREE_OPERAND (decl
, 0);
8869 if (TREE_CODE (decl
) == INDIRECT_REF
8870 && DECL_P (TREE_OPERAND (decl
, 0))
8871 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl
, 0)))
8875 decl
= TREE_OPERAND (decl
, 0);
8879 else if (TREE_CODE (decl
) == COMPONENT_REF
)
8881 while (TREE_CODE (decl
) == COMPONENT_REF
)
8882 decl
= TREE_OPERAND (decl
, 0);
8883 if (TREE_CODE (decl
) == INDIRECT_REF
8884 && DECL_P (TREE_OPERAND (decl
, 0))
8885 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl
, 0)))
8887 decl
= TREE_OPERAND (decl
, 0);
8889 if (decl
!= orig_decl
&& DECL_P (decl
) && indir_p
)
8891 gomp_map_kind k
= (code
== OACC_EXIT_DATA
) ? GOMP_MAP_DETACH
8893 /* We have a dereference of a struct member. Make this an
8894 attach/detach operation, and ensure the base pointer is
8895 mapped as a FIRSTPRIVATE_POINTER. */
8896 OMP_CLAUSE_SET_MAP_KIND (c
, k
);
8897 flags
= GOVD_MAP
| GOVD_SEEN
| GOVD_EXPLICIT
;
8898 tree next_clause
= OMP_CLAUSE_CHAIN (c
);
8899 if (k
== GOMP_MAP_ATTACH
8900 && code
!= OACC_ENTER_DATA
8902 || (OMP_CLAUSE_CODE (next_clause
) != OMP_CLAUSE_MAP
)
8903 || (OMP_CLAUSE_MAP_KIND (next_clause
)
8904 != GOMP_MAP_POINTER
)
8905 || OMP_CLAUSE_DECL (next_clause
) != decl
)
8906 && (!struct_deref_set
8907 || !struct_deref_set
->contains (decl
)))
8909 if (!struct_deref_set
)
8910 struct_deref_set
= new hash_set
<tree
> ();
8911 /* As well as the attach, we also need a
8912 FIRSTPRIVATE_POINTER clause to properly map the
8913 pointer to the struct base. */
8914 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8916 OMP_CLAUSE_SET_MAP_KIND (c2
, GOMP_MAP_ALLOC
);
8917 OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (c2
)
8920 = build_int_cst (build_pointer_type (char_type_node
),
8922 OMP_CLAUSE_DECL (c2
)
8923 = build2 (MEM_REF
, char_type_node
,
8924 decl_ref
? decl_ref
: decl
, charptr_zero
);
8925 OMP_CLAUSE_SIZE (c2
) = size_zero_node
;
8926 tree c3
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8928 OMP_CLAUSE_SET_MAP_KIND (c3
,
8929 GOMP_MAP_FIRSTPRIVATE_POINTER
);
8930 OMP_CLAUSE_DECL (c3
) = decl
;
8931 OMP_CLAUSE_SIZE (c3
) = size_zero_node
;
8932 tree mapgrp
= *prev_list_p
;
8934 OMP_CLAUSE_CHAIN (c3
) = mapgrp
;
8935 OMP_CLAUSE_CHAIN (c2
) = c3
;
8937 struct_deref_set
->add (decl
);
8941 /* An "attach/detach" operation on an update directive should
8942 behave as a GOMP_MAP_ALWAYS_POINTER. Beware that
8943 unlike attach or detach map kinds, GOMP_MAP_ALWAYS_POINTER
8944 depends on the previous mapping. */
8945 if (code
== OACC_UPDATE
8946 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ATTACH_DETACH
)
8947 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_ALWAYS_POINTER
);
8948 if (gimplify_expr (pd
, pre_p
, NULL
, is_gimple_lvalue
, fb_lvalue
)
8955 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_TO_PSET
8956 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_ATTACH
8957 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_DETACH
8958 && code
!= OACC_UPDATE
)
8960 if (error_operand_p (decl
))
8966 tree stype
= TREE_TYPE (decl
);
8967 if (TREE_CODE (stype
) == REFERENCE_TYPE
)
8968 stype
= TREE_TYPE (stype
);
8969 if (TYPE_SIZE_UNIT (stype
) == NULL
8970 || TREE_CODE (TYPE_SIZE_UNIT (stype
)) != INTEGER_CST
)
8972 error_at (OMP_CLAUSE_LOCATION (c
),
8973 "mapping field %qE of variable length "
8974 "structure", OMP_CLAUSE_DECL (c
));
8979 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_POINTER
8980 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ATTACH_DETACH
)
8982 /* Error recovery. */
8983 if (prev_list_p
== NULL
)
8988 if (OMP_CLAUSE_CHAIN (*prev_list_p
) != c
)
8990 tree ch
= OMP_CLAUSE_CHAIN (*prev_list_p
);
8991 if (ch
== NULL_TREE
|| OMP_CLAUSE_CHAIN (ch
) != c
)
8999 poly_offset_int offset1
;
9004 = extract_base_bit_offset (OMP_CLAUSE_DECL (c
), &base_ref
,
9005 &bitpos1
, &offset1
);
9007 gcc_assert (base
== decl
);
9010 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
9011 bool ptr
= (OMP_CLAUSE_MAP_KIND (c
)
9012 == GOMP_MAP_ALWAYS_POINTER
);
9013 bool attach_detach
= (OMP_CLAUSE_MAP_KIND (c
)
9014 == GOMP_MAP_ATTACH_DETACH
);
9015 bool attach
= OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ATTACH
9016 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_DETACH
;
9017 bool has_attachments
= false;
9018 /* For OpenACC, pointers in structs should trigger an
9020 if (attach_detach
&& (region_type
& ORT_ACC
) != 0)
9022 /* Turn a GOMP_MAP_ATTACH_DETACH clause into a
9023 GOMP_MAP_ATTACH or GOMP_MAP_DETACH clause after we
9024 have detected a case that needs a GOMP_MAP_STRUCT
9027 = (code
== OACC_EXIT_DATA
) ? GOMP_MAP_DETACH
9029 OMP_CLAUSE_SET_MAP_KIND (c
, k
);
9030 has_attachments
= true;
9032 if (n
== NULL
|| (n
->value
& GOVD_MAP
) == 0)
9034 tree l
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
9036 gomp_map_kind k
= attach
? GOMP_MAP_FORCE_PRESENT
9039 OMP_CLAUSE_SET_MAP_KIND (l
, k
);
9041 OMP_CLAUSE_DECL (l
) = unshare_expr (base_ref
);
9043 OMP_CLAUSE_DECL (l
) = decl
;
9047 : DECL_P (OMP_CLAUSE_DECL (l
))
9048 ? DECL_SIZE_UNIT (OMP_CLAUSE_DECL (l
))
9049 : TYPE_SIZE_UNIT (TREE_TYPE (OMP_CLAUSE_DECL (l
))));
9050 if (struct_map_to_clause
== NULL
)
9051 struct_map_to_clause
= new hash_map
<tree
, tree
>;
9052 struct_map_to_clause
->put (decl
, l
);
9053 if (ptr
|| attach_detach
)
9055 insert_struct_comp_map (code
, c
, l
, *prev_list_p
,
9062 OMP_CLAUSE_CHAIN (l
) = c
;
9064 list_p
= &OMP_CLAUSE_CHAIN (l
);
9066 if (base_ref
&& code
== OMP_TARGET
)
9068 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
9070 enum gomp_map_kind mkind
9071 = GOMP_MAP_FIRSTPRIVATE_REFERENCE
;
9072 OMP_CLAUSE_SET_MAP_KIND (c2
, mkind
);
9073 OMP_CLAUSE_DECL (c2
) = decl
;
9074 OMP_CLAUSE_SIZE (c2
) = size_zero_node
;
9075 OMP_CLAUSE_CHAIN (c2
) = OMP_CLAUSE_CHAIN (l
);
9076 OMP_CLAUSE_CHAIN (l
) = c2
;
9078 flags
= GOVD_MAP
| GOVD_EXPLICIT
;
9079 if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c
))
9083 if (has_attachments
)
9084 flags
|= GOVD_MAP_HAS_ATTACHMENTS
;
9087 else if (struct_map_to_clause
)
9089 tree
*osc
= struct_map_to_clause
->get (decl
);
9090 tree
*sc
= NULL
, *scp
= NULL
;
9091 if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c
))
9094 n
->value
|= GOVD_SEEN
;
9095 sc
= &OMP_CLAUSE_CHAIN (*osc
);
9097 && (OMP_CLAUSE_MAP_KIND (*sc
)
9098 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
9099 sc
= &OMP_CLAUSE_CHAIN (*sc
);
9100 /* Here "prev_list_p" is the end of the inserted
9101 alloc/release nodes after the struct node, OSC. */
9102 for (; *sc
!= c
; sc
= &OMP_CLAUSE_CHAIN (*sc
))
9103 if ((ptr
|| attach_detach
) && sc
== prev_list_p
)
9105 else if (TREE_CODE (OMP_CLAUSE_DECL (*sc
))
9107 && (TREE_CODE (OMP_CLAUSE_DECL (*sc
))
9109 && (TREE_CODE (OMP_CLAUSE_DECL (*sc
))
9114 tree sc_decl
= OMP_CLAUSE_DECL (*sc
);
9115 poly_offset_int offsetn
;
9118 = extract_base_bit_offset (sc_decl
, NULL
,
9119 &bitposn
, &offsetn
);
9124 tree d1
= OMP_CLAUSE_DECL (*sc
);
9125 tree d2
= OMP_CLAUSE_DECL (c
);
9126 while (TREE_CODE (d1
) == ARRAY_REF
)
9127 d1
= TREE_OPERAND (d1
, 0);
9128 while (TREE_CODE (d2
) == ARRAY_REF
)
9129 d2
= TREE_OPERAND (d2
, 0);
9130 if (TREE_CODE (d1
) == INDIRECT_REF
)
9131 d1
= TREE_OPERAND (d1
, 0);
9132 if (TREE_CODE (d2
) == INDIRECT_REF
)
9133 d2
= TREE_OPERAND (d2
, 0);
9134 while (TREE_CODE (d1
) == COMPONENT_REF
)
9135 if (TREE_CODE (d2
) == COMPONENT_REF
9136 && TREE_OPERAND (d1
, 1)
9137 == TREE_OPERAND (d2
, 1))
9139 d1
= TREE_OPERAND (d1
, 0);
9140 d2
= TREE_OPERAND (d2
, 0);
9146 error_at (OMP_CLAUSE_LOCATION (c
),
9147 "%qE appears more than once in map "
9148 "clauses", OMP_CLAUSE_DECL (c
));
9152 if (maybe_lt (offset1
, offsetn
)
9153 || (known_eq (offset1
, offsetn
)
9154 && maybe_lt (bitpos1
, bitposn
)))
9156 if (ptr
|| attach_detach
)
9165 OMP_CLAUSE_SIZE (*osc
)
9166 = size_binop (PLUS_EXPR
, OMP_CLAUSE_SIZE (*osc
),
9168 if (ptr
|| attach_detach
)
9170 tree cl
= insert_struct_comp_map (code
, c
, NULL
,
9172 if (sc
== prev_list_p
)
9179 *prev_list_p
= OMP_CLAUSE_CHAIN (c
);
9180 list_p
= prev_list_p
;
9182 OMP_CLAUSE_CHAIN (c
) = *sc
;
9189 *list_p
= OMP_CLAUSE_CHAIN (c
);
9190 OMP_CLAUSE_CHAIN (c
) = *sc
;
9197 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_ALWAYS_POINTER
9198 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_ATTACH_DETACH
9199 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_TO_PSET
9200 && OMP_CLAUSE_CHAIN (c
)
9201 && OMP_CLAUSE_CODE (OMP_CLAUSE_CHAIN (c
)) == OMP_CLAUSE_MAP
9202 && ((OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (c
))
9203 == GOMP_MAP_ALWAYS_POINTER
)
9204 || (OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (c
))
9205 == GOMP_MAP_ATTACH_DETACH
)
9206 || (OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (c
))
9207 == GOMP_MAP_TO_PSET
)))
9208 prev_list_p
= list_p
;
9212 flags
= GOVD_MAP
| GOVD_EXPLICIT
;
9213 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_TO
9214 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_TOFROM
)
9215 flags
|= GOVD_MAP_ALWAYS_TO
;
9218 case OMP_CLAUSE_DEPEND
:
9219 if (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
)
9221 tree deps
= OMP_CLAUSE_DECL (c
);
9222 while (deps
&& TREE_CODE (deps
) == TREE_LIST
)
9224 if (TREE_CODE (TREE_PURPOSE (deps
)) == TRUNC_DIV_EXPR
9225 && DECL_P (TREE_OPERAND (TREE_PURPOSE (deps
), 1)))
9226 gimplify_expr (&TREE_OPERAND (TREE_PURPOSE (deps
), 1),
9227 pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
9228 deps
= TREE_CHAIN (deps
);
9232 else if (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SOURCE
)
9234 if (handled_depend_iterators
== -1)
9235 handled_depend_iterators
= gimplify_omp_depend (list_p
, pre_p
);
9236 if (handled_depend_iterators
)
9238 if (handled_depend_iterators
== 2)
9242 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == COMPOUND_EXPR
)
9244 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0), pre_p
,
9245 NULL
, is_gimple_val
, fb_rvalue
);
9246 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (OMP_CLAUSE_DECL (c
), 1);
9248 if (error_operand_p (OMP_CLAUSE_DECL (c
)))
9253 OMP_CLAUSE_DECL (c
) = build_fold_addr_expr (OMP_CLAUSE_DECL (c
));
9254 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
, NULL
,
9255 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
9263 case OMP_CLAUSE_FROM
:
9264 case OMP_CLAUSE__CACHE_
:
9265 decl
= OMP_CLAUSE_DECL (c
);
9266 if (error_operand_p (decl
))
9271 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
9272 OMP_CLAUSE_SIZE (c
) = DECL_P (decl
) ? DECL_SIZE_UNIT (decl
)
9273 : TYPE_SIZE_UNIT (TREE_TYPE (decl
));
9274 if (gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
9275 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
9282 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
,
9283 NULL
, is_gimple_lvalue
, fb_lvalue
)
9293 case OMP_CLAUSE_USE_DEVICE_PTR
:
9294 case OMP_CLAUSE_USE_DEVICE_ADDR
:
9295 flags
= GOVD_EXPLICIT
;
9298 case OMP_CLAUSE_IS_DEVICE_PTR
:
9299 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
9303 decl
= OMP_CLAUSE_DECL (c
);
9305 if (error_operand_p (decl
))
9310 if (DECL_NAME (decl
) == NULL_TREE
&& (flags
& GOVD_SHARED
) == 0)
9312 tree t
= omp_member_access_dummy_var (decl
);
9315 tree v
= DECL_VALUE_EXPR (decl
);
9316 DECL_NAME (decl
) = DECL_NAME (TREE_OPERAND (v
, 1));
9318 omp_notice_variable (outer_ctx
, t
, true);
9321 if (code
== OACC_DATA
9322 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
9323 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
)
9324 flags
|= GOVD_MAP_0LEN_ARRAY
;
9325 omp_add_variable (ctx
, decl
, flags
);
9326 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
9327 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_IN_REDUCTION
9328 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TASK_REDUCTION
)
9329 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
9331 omp_add_variable (ctx
, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
),
9332 GOVD_LOCAL
| GOVD_SEEN
);
9333 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
)
9334 && walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c
),
9336 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
),
9338 omp_add_variable (ctx
,
9339 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
),
9340 GOVD_LOCAL
| GOVD_SEEN
);
9341 gimplify_omp_ctxp
= ctx
;
9342 push_gimplify_context ();
9344 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
9345 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
9347 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c
),
9348 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
9349 pop_gimplify_context
9350 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
)));
9351 push_gimplify_context ();
9352 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c
),
9353 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
9354 pop_gimplify_context
9355 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
)));
9356 OMP_CLAUSE_REDUCTION_INIT (c
) = NULL_TREE
;
9357 OMP_CLAUSE_REDUCTION_MERGE (c
) = NULL_TREE
;
9359 gimplify_omp_ctxp
= outer_ctx
;
9361 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
9362 && OMP_CLAUSE_LASTPRIVATE_STMT (c
))
9364 gimplify_omp_ctxp
= ctx
;
9365 push_gimplify_context ();
9366 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c
)) != BIND_EXPR
)
9368 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
9370 TREE_SIDE_EFFECTS (bind
) = 1;
9371 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LASTPRIVATE_STMT (c
);
9372 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = bind
;
9374 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c
),
9375 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
9376 pop_gimplify_context
9377 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
)));
9378 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = NULL_TREE
;
9380 gimplify_omp_ctxp
= outer_ctx
;
9382 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
9383 && OMP_CLAUSE_LINEAR_STMT (c
))
9385 gimplify_omp_ctxp
= ctx
;
9386 push_gimplify_context ();
9387 if (TREE_CODE (OMP_CLAUSE_LINEAR_STMT (c
)) != BIND_EXPR
)
9389 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
9391 TREE_SIDE_EFFECTS (bind
) = 1;
9392 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LINEAR_STMT (c
);
9393 OMP_CLAUSE_LINEAR_STMT (c
) = bind
;
9395 gimplify_and_add (OMP_CLAUSE_LINEAR_STMT (c
),
9396 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
));
9397 pop_gimplify_context
9398 (gimple_seq_first_stmt (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
)));
9399 OMP_CLAUSE_LINEAR_STMT (c
) = NULL_TREE
;
9401 gimplify_omp_ctxp
= outer_ctx
;
9407 case OMP_CLAUSE_COPYIN
:
9408 case OMP_CLAUSE_COPYPRIVATE
:
9409 decl
= OMP_CLAUSE_DECL (c
);
9410 if (error_operand_p (decl
))
9415 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_COPYPRIVATE
9417 && !omp_check_private (ctx
, decl
, true))
9420 if (is_global_var (decl
))
9422 if (DECL_THREAD_LOCAL_P (decl
))
9424 else if (DECL_HAS_VALUE_EXPR_P (decl
))
9426 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
9430 && DECL_THREAD_LOCAL_P (value
))
9435 error_at (OMP_CLAUSE_LOCATION (c
),
9436 "copyprivate variable %qE is not threadprivate"
9437 " or private in outer context", DECL_NAME (decl
));
9440 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
9441 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
9442 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
9444 && ((region_type
& ORT_TASKLOOP
) == ORT_TASKLOOP
9445 || (region_type
== ORT_WORKSHARE
9446 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
9447 && (OMP_CLAUSE_REDUCTION_INSCAN (c
)
9448 || code
== OMP_LOOP
)))
9449 && (outer_ctx
->region_type
== ORT_COMBINED_PARALLEL
9450 || (code
== OMP_LOOP
9451 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
9452 && ((outer_ctx
->region_type
& ORT_COMBINED_TEAMS
)
9453 == ORT_COMBINED_TEAMS
))))
9456 = splay_tree_lookup (outer_ctx
->variables
,
9457 (splay_tree_key
)decl
);
9458 if (on
== NULL
|| (on
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
9460 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
9461 && TREE_CODE (OMP_CLAUSE_DECL (c
)) == MEM_REF
9462 && (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
9463 || (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
9464 && (TREE_CODE (TREE_TYPE (TREE_TYPE (decl
)))
9466 omp_firstprivatize_variable (outer_ctx
, decl
);
9469 omp_add_variable (outer_ctx
, decl
,
9470 GOVD_SEEN
| GOVD_SHARED
);
9471 if (outer_ctx
->outer_context
)
9472 omp_notice_variable (outer_ctx
->outer_context
, decl
,
9478 omp_notice_variable (outer_ctx
, decl
, true);
9479 if (check_non_private
9480 && region_type
== ORT_WORKSHARE
9481 && (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_REDUCTION
9482 || decl
== OMP_CLAUSE_DECL (c
)
9483 || (TREE_CODE (OMP_CLAUSE_DECL (c
)) == MEM_REF
9484 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0))
9486 || (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0))
9487 == POINTER_PLUS_EXPR
9488 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND
9489 (OMP_CLAUSE_DECL (c
), 0), 0))
9491 && omp_check_private (ctx
, decl
, false))
9493 error ("%s variable %qE is private in outer context",
9494 check_non_private
, DECL_NAME (decl
));
9500 if (OMP_CLAUSE_IF_MODIFIER (c
) != ERROR_MARK
9501 && OMP_CLAUSE_IF_MODIFIER (c
) != code
)
9504 for (int i
= 0; i
< 2; i
++)
9505 switch (i
? OMP_CLAUSE_IF_MODIFIER (c
) : code
)
9507 case VOID_CST
: p
[i
] = "cancel"; break;
9508 case OMP_PARALLEL
: p
[i
] = "parallel"; break;
9509 case OMP_SIMD
: p
[i
] = "simd"; break;
9510 case OMP_TASK
: p
[i
] = "task"; break;
9511 case OMP_TASKLOOP
: p
[i
] = "taskloop"; break;
9512 case OMP_TARGET_DATA
: p
[i
] = "target data"; break;
9513 case OMP_TARGET
: p
[i
] = "target"; break;
9514 case OMP_TARGET_UPDATE
: p
[i
] = "target update"; break;
9515 case OMP_TARGET_ENTER_DATA
:
9516 p
[i
] = "target enter data"; break;
9517 case OMP_TARGET_EXIT_DATA
: p
[i
] = "target exit data"; break;
9518 default: gcc_unreachable ();
9520 error_at (OMP_CLAUSE_LOCATION (c
),
9521 "expected %qs %<if%> clause modifier rather than %qs",
9527 case OMP_CLAUSE_FINAL
:
9528 OMP_CLAUSE_OPERAND (c
, 0)
9529 = gimple_boolify (OMP_CLAUSE_OPERAND (c
, 0));
9532 case OMP_CLAUSE_SCHEDULE
:
9533 case OMP_CLAUSE_NUM_THREADS
:
9534 case OMP_CLAUSE_NUM_TEAMS
:
9535 case OMP_CLAUSE_THREAD_LIMIT
:
9536 case OMP_CLAUSE_DIST_SCHEDULE
:
9537 case OMP_CLAUSE_DEVICE
:
9538 case OMP_CLAUSE_PRIORITY
:
9539 case OMP_CLAUSE_GRAINSIZE
:
9540 case OMP_CLAUSE_NUM_TASKS
:
9541 case OMP_CLAUSE_HINT
:
9542 case OMP_CLAUSE_ASYNC
:
9543 case OMP_CLAUSE_WAIT
:
9544 case OMP_CLAUSE_NUM_GANGS
:
9545 case OMP_CLAUSE_NUM_WORKERS
:
9546 case OMP_CLAUSE_VECTOR_LENGTH
:
9547 case OMP_CLAUSE_WORKER
:
9548 case OMP_CLAUSE_VECTOR
:
9549 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
9550 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
9554 case OMP_CLAUSE_GANG
:
9555 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
9556 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
9558 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 1), pre_p
, NULL
,
9559 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
9563 case OMP_CLAUSE_NOWAIT
:
9567 case OMP_CLAUSE_ORDERED
:
9568 case OMP_CLAUSE_UNTIED
:
9569 case OMP_CLAUSE_COLLAPSE
:
9570 case OMP_CLAUSE_TILE
:
9571 case OMP_CLAUSE_AUTO
:
9572 case OMP_CLAUSE_SEQ
:
9573 case OMP_CLAUSE_INDEPENDENT
:
9574 case OMP_CLAUSE_MERGEABLE
:
9575 case OMP_CLAUSE_PROC_BIND
:
9576 case OMP_CLAUSE_SAFELEN
:
9577 case OMP_CLAUSE_SIMDLEN
:
9578 case OMP_CLAUSE_NOGROUP
:
9579 case OMP_CLAUSE_THREADS
:
9580 case OMP_CLAUSE_SIMD
:
9581 case OMP_CLAUSE_BIND
:
9582 case OMP_CLAUSE_IF_PRESENT
:
9583 case OMP_CLAUSE_FINALIZE
:
9586 case OMP_CLAUSE_ORDER
:
9587 ctx
->order_concurrent
= true;
9590 case OMP_CLAUSE_DEFAULTMAP
:
9591 enum gimplify_defaultmap_kind gdmkmin
, gdmkmax
;
9592 switch (OMP_CLAUSE_DEFAULTMAP_CATEGORY (c
))
9594 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED
:
9595 gdmkmin
= GDMK_SCALAR
;
9596 gdmkmax
= GDMK_POINTER
;
9598 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR
:
9599 gdmkmin
= gdmkmax
= GDMK_SCALAR
;
9601 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE
:
9602 gdmkmin
= gdmkmax
= GDMK_AGGREGATE
;
9604 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE
:
9605 gdmkmin
= gdmkmax
= GDMK_ALLOCATABLE
;
9607 case OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER
:
9608 gdmkmin
= gdmkmax
= GDMK_POINTER
;
9613 for (int gdmk
= gdmkmin
; gdmk
<= gdmkmax
; gdmk
++)
9614 switch (OMP_CLAUSE_DEFAULTMAP_BEHAVIOR (c
))
9616 case OMP_CLAUSE_DEFAULTMAP_ALLOC
:
9617 ctx
->defaultmap
[gdmk
] = GOVD_MAP
| GOVD_MAP_ALLOC_ONLY
;
9619 case OMP_CLAUSE_DEFAULTMAP_TO
:
9620 ctx
->defaultmap
[gdmk
] = GOVD_MAP
| GOVD_MAP_TO_ONLY
;
9622 case OMP_CLAUSE_DEFAULTMAP_FROM
:
9623 ctx
->defaultmap
[gdmk
] = GOVD_MAP
| GOVD_MAP_FROM_ONLY
;
9625 case OMP_CLAUSE_DEFAULTMAP_TOFROM
:
9626 ctx
->defaultmap
[gdmk
] = GOVD_MAP
;
9628 case OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE
:
9629 ctx
->defaultmap
[gdmk
] = GOVD_FIRSTPRIVATE
;
9631 case OMP_CLAUSE_DEFAULTMAP_NONE
:
9632 ctx
->defaultmap
[gdmk
] = 0;
9634 case OMP_CLAUSE_DEFAULTMAP_DEFAULT
:
9638 ctx
->defaultmap
[gdmk
] = GOVD_FIRSTPRIVATE
;
9640 case GDMK_AGGREGATE
:
9641 case GDMK_ALLOCATABLE
:
9642 ctx
->defaultmap
[gdmk
] = GOVD_MAP
;
9645 ctx
->defaultmap
[gdmk
] = GOVD_MAP
| GOVD_MAP_0LEN_ARRAY
;
9656 case OMP_CLAUSE_ALIGNED
:
9657 decl
= OMP_CLAUSE_DECL (c
);
9658 if (error_operand_p (decl
))
9663 if (gimplify_expr (&OMP_CLAUSE_ALIGNED_ALIGNMENT (c
), pre_p
, NULL
,
9664 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
9669 if (!is_global_var (decl
)
9670 && TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
9671 omp_add_variable (ctx
, decl
, GOVD_ALIGNED
);
9674 case OMP_CLAUSE_NONTEMPORAL
:
9675 decl
= OMP_CLAUSE_DECL (c
);
9676 if (error_operand_p (decl
))
9681 omp_add_variable (ctx
, decl
, GOVD_NONTEMPORAL
);
9684 case OMP_CLAUSE_DEFAULT
:
9685 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
9688 case OMP_CLAUSE_INCLUSIVE
:
9689 case OMP_CLAUSE_EXCLUSIVE
:
9690 decl
= OMP_CLAUSE_DECL (c
);
9692 splay_tree_node n
= splay_tree_lookup (outer_ctx
->variables
,
9693 (splay_tree_key
) decl
);
9694 if (n
== NULL
|| (n
->value
& GOVD_REDUCTION
) == 0)
9696 error_at (OMP_CLAUSE_LOCATION (c
),
9697 "%qD specified in %qs clause but not in %<inscan%> "
9698 "%<reduction%> clause on the containing construct",
9699 decl
, omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
9704 n
->value
|= GOVD_REDUCTION_INSCAN
;
9705 if (outer_ctx
->region_type
== ORT_SIMD
9706 && outer_ctx
->outer_context
9707 && outer_ctx
->outer_context
->region_type
== ORT_WORKSHARE
)
9709 n
= splay_tree_lookup (outer_ctx
->outer_context
->variables
,
9710 (splay_tree_key
) decl
);
9711 if (n
&& (n
->value
& GOVD_REDUCTION
) != 0)
9712 n
->value
|= GOVD_REDUCTION_INSCAN
;
9722 if (code
== OACC_DATA
9723 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
9724 && (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
9725 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
9728 *list_p
= OMP_CLAUSE_CHAIN (c
);
9730 list_p
= &OMP_CLAUSE_CHAIN (c
);
9733 ctx
->clauses
= *orig_list_p
;
9734 gimplify_omp_ctxp
= ctx
;
9735 if (struct_map_to_clause
)
9736 delete struct_map_to_clause
;
9737 if (struct_deref_set
)
9738 delete struct_deref_set
;
9741 /* Return true if DECL is a candidate for shared to firstprivate
9742 optimization. We only consider non-addressable scalars, not
9743 too big, and not references. */
9746 omp_shared_to_firstprivate_optimizable_decl_p (tree decl
)
9748 if (TREE_ADDRESSABLE (decl
))
9750 tree type
= TREE_TYPE (decl
);
9751 if (!is_gimple_reg_type (type
)
9752 || TREE_CODE (type
) == REFERENCE_TYPE
9753 || TREE_ADDRESSABLE (type
))
9755 /* Don't optimize too large decls, as each thread/task will have
9757 HOST_WIDE_INT len
= int_size_in_bytes (type
);
9758 if (len
== -1 || len
> 4 * POINTER_SIZE
/ BITS_PER_UNIT
)
9760 if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
9765 /* Helper function of omp_find_stores_op and gimplify_adjust_omp_clauses*.
9766 For omp_shared_to_firstprivate_optimizable_decl_p decl mark it as
9767 GOVD_WRITTEN in outer contexts. */
9770 omp_mark_stores (struct gimplify_omp_ctx
*ctx
, tree decl
)
9772 for (; ctx
; ctx
= ctx
->outer_context
)
9774 splay_tree_node n
= splay_tree_lookup (ctx
->variables
,
9775 (splay_tree_key
) decl
);
9778 else if (n
->value
& GOVD_SHARED
)
9780 n
->value
|= GOVD_WRITTEN
;
9783 else if (n
->value
& GOVD_DATA_SHARE_CLASS
)
9788 /* Helper callback for walk_gimple_seq to discover possible stores
9789 to omp_shared_to_firstprivate_optimizable_decl_p decls and set
9790 GOVD_WRITTEN if they are GOVD_SHARED in some outer context
9794 omp_find_stores_op (tree
*tp
, int *walk_subtrees
, void *data
)
9796 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
9805 if (handled_component_p (op
))
9806 op
= TREE_OPERAND (op
, 0);
9807 else if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
9808 && TREE_CODE (TREE_OPERAND (op
, 0)) == ADDR_EXPR
)
9809 op
= TREE_OPERAND (TREE_OPERAND (op
, 0), 0);
9814 if (!DECL_P (op
) || !omp_shared_to_firstprivate_optimizable_decl_p (op
))
9817 omp_mark_stores (gimplify_omp_ctxp
, op
);
9821 /* Helper callback for walk_gimple_seq to discover possible stores
9822 to omp_shared_to_firstprivate_optimizable_decl_p decls and set
9823 GOVD_WRITTEN if they are GOVD_SHARED in some outer context
9827 omp_find_stores_stmt (gimple_stmt_iterator
*gsi_p
,
9828 bool *handled_ops_p
,
9829 struct walk_stmt_info
*wi
)
9831 gimple
*stmt
= gsi_stmt (*gsi_p
);
9832 switch (gimple_code (stmt
))
9834 /* Don't recurse on OpenMP constructs for which
9835 gimplify_adjust_omp_clauses already handled the bodies,
9836 except handle gimple_omp_for_pre_body. */
9837 case GIMPLE_OMP_FOR
:
9838 *handled_ops_p
= true;
9839 if (gimple_omp_for_pre_body (stmt
))
9840 walk_gimple_seq (gimple_omp_for_pre_body (stmt
),
9841 omp_find_stores_stmt
, omp_find_stores_op
, wi
);
9843 case GIMPLE_OMP_PARALLEL
:
9844 case GIMPLE_OMP_TASK
:
9845 case GIMPLE_OMP_SECTIONS
:
9846 case GIMPLE_OMP_SINGLE
:
9847 case GIMPLE_OMP_TARGET
:
9848 case GIMPLE_OMP_TEAMS
:
9849 case GIMPLE_OMP_CRITICAL
:
9850 *handled_ops_p
= true;
9858 struct gimplify_adjust_omp_clauses_data
9864 /* For all variables that were not actually used within the context,
9865 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
9868 gimplify_adjust_omp_clauses_1 (splay_tree_node n
, void *data
)
9870 tree
*list_p
= ((struct gimplify_adjust_omp_clauses_data
*) data
)->list_p
;
9872 = ((struct gimplify_adjust_omp_clauses_data
*) data
)->pre_p
;
9873 tree decl
= (tree
) n
->key
;
9874 unsigned flags
= n
->value
;
9875 enum omp_clause_code code
;
9879 if (gimplify_omp_ctxp
->region_type
== ORT_COMBINED_PARALLEL
9880 && (flags
& GOVD_LASTPRIVATE_CONDITIONAL
) != 0)
9881 flags
= GOVD_SHARED
| GOVD_SEEN
| GOVD_WRITTEN
;
9882 if (flags
& (GOVD_EXPLICIT
| GOVD_LOCAL
))
9884 if ((flags
& GOVD_SEEN
) == 0)
9886 if ((flags
& GOVD_MAP_HAS_ATTACHMENTS
) != 0)
9888 if (flags
& GOVD_DEBUG_PRIVATE
)
9890 gcc_assert ((flags
& GOVD_DATA_SHARE_CLASS
) == GOVD_SHARED
);
9891 private_debug
= true;
9893 else if (flags
& GOVD_MAP
)
9894 private_debug
= false;
9897 = lang_hooks
.decls
.omp_private_debug_clause (decl
,
9898 !!(flags
& GOVD_SHARED
));
9900 code
= OMP_CLAUSE_PRIVATE
;
9901 else if (flags
& GOVD_MAP
)
9903 code
= OMP_CLAUSE_MAP
;
9904 if ((gimplify_omp_ctxp
->region_type
& ORT_ACC
) == 0
9905 && TYPE_ATOMIC (strip_array_types (TREE_TYPE (decl
))))
9907 error ("%<_Atomic%> %qD in implicit %<map%> clause", decl
);
9911 && DECL_IN_CONSTANT_POOL (decl
)
9912 && !lookup_attribute ("omp declare target",
9913 DECL_ATTRIBUTES (decl
)))
9915 tree id
= get_identifier ("omp declare target");
9916 DECL_ATTRIBUTES (decl
)
9917 = tree_cons (id
, NULL_TREE
, DECL_ATTRIBUTES (decl
));
9918 varpool_node
*node
= varpool_node::get (decl
);
9921 node
->offloadable
= 1;
9922 if (ENABLE_OFFLOADING
)
9923 g
->have_offload
= true;
9927 else if (flags
& GOVD_SHARED
)
9929 if (is_global_var (decl
))
9931 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
9935 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9936 if (on
&& (on
->value
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
9937 | GOVD_PRIVATE
| GOVD_REDUCTION
9938 | GOVD_LINEAR
| GOVD_MAP
)) != 0)
9940 ctx
= ctx
->outer_context
;
9945 code
= OMP_CLAUSE_SHARED
;
9947 else if (flags
& GOVD_PRIVATE
)
9948 code
= OMP_CLAUSE_PRIVATE
;
9949 else if (flags
& GOVD_FIRSTPRIVATE
)
9951 code
= OMP_CLAUSE_FIRSTPRIVATE
;
9952 if ((gimplify_omp_ctxp
->region_type
& ORT_TARGET
)
9953 && (gimplify_omp_ctxp
->region_type
& ORT_ACC
) == 0
9954 && TYPE_ATOMIC (strip_array_types (TREE_TYPE (decl
))))
9956 error ("%<_Atomic%> %qD in implicit %<firstprivate%> clause on "
9957 "%<target%> construct", decl
);
9961 else if (flags
& GOVD_LASTPRIVATE
)
9962 code
= OMP_CLAUSE_LASTPRIVATE
;
9963 else if (flags
& (GOVD_ALIGNED
| GOVD_NONTEMPORAL
))
9965 else if (flags
& GOVD_CONDTEMP
)
9967 code
= OMP_CLAUSE__CONDTEMP_
;
9968 gimple_add_tmp_var (decl
);
9973 if (((flags
& GOVD_LASTPRIVATE
)
9974 || (code
== OMP_CLAUSE_SHARED
&& (flags
& GOVD_WRITTEN
)))
9975 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
9976 omp_mark_stores (gimplify_omp_ctxp
->outer_context
, decl
);
9978 tree chain
= *list_p
;
9979 clause
= build_omp_clause (input_location
, code
);
9980 OMP_CLAUSE_DECL (clause
) = decl
;
9981 OMP_CLAUSE_CHAIN (clause
) = chain
;
9983 OMP_CLAUSE_PRIVATE_DEBUG (clause
) = 1;
9984 else if (code
== OMP_CLAUSE_PRIVATE
&& (flags
& GOVD_PRIVATE_OUTER_REF
))
9985 OMP_CLAUSE_PRIVATE_OUTER_REF (clause
) = 1;
9986 else if (code
== OMP_CLAUSE_SHARED
9987 && (flags
& GOVD_WRITTEN
) == 0
9988 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
9989 OMP_CLAUSE_SHARED_READONLY (clause
) = 1;
9990 else if (code
== OMP_CLAUSE_FIRSTPRIVATE
&& (flags
& GOVD_EXPLICIT
) == 0)
9991 OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT (clause
) = 1;
9992 else if (code
== OMP_CLAUSE_MAP
&& (flags
& GOVD_MAP_0LEN_ARRAY
) != 0)
9994 tree nc
= build_omp_clause (input_location
, OMP_CLAUSE_MAP
);
9995 OMP_CLAUSE_DECL (nc
) = decl
;
9996 if (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
9997 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == POINTER_TYPE
)
9998 OMP_CLAUSE_DECL (clause
)
9999 = build_simple_mem_ref_loc (input_location
, decl
);
10000 OMP_CLAUSE_DECL (clause
)
10001 = build2 (MEM_REF
, char_type_node
, OMP_CLAUSE_DECL (clause
),
10002 build_int_cst (build_pointer_type (char_type_node
), 0));
10003 OMP_CLAUSE_SIZE (clause
) = size_zero_node
;
10004 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
10005 OMP_CLAUSE_SET_MAP_KIND (clause
, GOMP_MAP_ALLOC
);
10006 OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (clause
) = 1;
10007 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_FIRSTPRIVATE_POINTER
);
10008 OMP_CLAUSE_CHAIN (nc
) = chain
;
10009 OMP_CLAUSE_CHAIN (clause
) = nc
;
10010 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
10011 gimplify_omp_ctxp
= ctx
->outer_context
;
10012 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (clause
), 0),
10013 pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
10014 gimplify_omp_ctxp
= ctx
;
10016 else if (code
== OMP_CLAUSE_MAP
)
10019 /* Not all combinations of these GOVD_MAP flags are actually valid. */
10020 switch (flags
& (GOVD_MAP_TO_ONLY
10022 | GOVD_MAP_FORCE_PRESENT
10023 | GOVD_MAP_ALLOC_ONLY
10024 | GOVD_MAP_FROM_ONLY
))
10027 kind
= GOMP_MAP_TOFROM
;
10029 case GOVD_MAP_FORCE
:
10030 kind
= GOMP_MAP_TOFROM
| GOMP_MAP_FLAG_FORCE
;
10032 case GOVD_MAP_TO_ONLY
:
10033 kind
= GOMP_MAP_TO
;
10035 case GOVD_MAP_FROM_ONLY
:
10036 kind
= GOMP_MAP_FROM
;
10038 case GOVD_MAP_ALLOC_ONLY
:
10039 kind
= GOMP_MAP_ALLOC
;
10041 case GOVD_MAP_TO_ONLY
| GOVD_MAP_FORCE
:
10042 kind
= GOMP_MAP_TO
| GOMP_MAP_FLAG_FORCE
;
10044 case GOVD_MAP_FORCE_PRESENT
:
10045 kind
= GOMP_MAP_FORCE_PRESENT
;
10048 gcc_unreachable ();
10050 OMP_CLAUSE_SET_MAP_KIND (clause
, kind
);
10051 if (DECL_SIZE (decl
)
10052 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
10054 tree decl2
= DECL_VALUE_EXPR (decl
);
10055 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
10056 decl2
= TREE_OPERAND (decl2
, 0);
10057 gcc_assert (DECL_P (decl2
));
10058 tree mem
= build_simple_mem_ref (decl2
);
10059 OMP_CLAUSE_DECL (clause
) = mem
;
10060 OMP_CLAUSE_SIZE (clause
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
10061 if (gimplify_omp_ctxp
->outer_context
)
10063 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
10064 omp_notice_variable (ctx
, decl2
, true);
10065 omp_notice_variable (ctx
, OMP_CLAUSE_SIZE (clause
), true);
10067 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
),
10069 OMP_CLAUSE_DECL (nc
) = decl
;
10070 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
10071 if (gimplify_omp_ctxp
->target_firstprivatize_array_bases
)
10072 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_FIRSTPRIVATE_POINTER
);
10074 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_POINTER
);
10075 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (clause
);
10076 OMP_CLAUSE_CHAIN (clause
) = nc
;
10078 else if (gimplify_omp_ctxp
->target_firstprivatize_array_bases
10079 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
10081 OMP_CLAUSE_DECL (clause
) = build_simple_mem_ref (decl
);
10082 OMP_CLAUSE_SIZE (clause
)
10083 = unshare_expr (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
))));
10084 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
10085 gimplify_omp_ctxp
= ctx
->outer_context
;
10086 gimplify_expr (&OMP_CLAUSE_SIZE (clause
),
10087 pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
10088 gimplify_omp_ctxp
= ctx
;
10089 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
),
10091 OMP_CLAUSE_DECL (nc
) = decl
;
10092 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
10093 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_FIRSTPRIVATE_REFERENCE
);
10094 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (clause
);
10095 OMP_CLAUSE_CHAIN (clause
) = nc
;
10098 OMP_CLAUSE_SIZE (clause
) = DECL_SIZE_UNIT (decl
);
10100 if (code
== OMP_CLAUSE_FIRSTPRIVATE
&& (flags
& GOVD_LASTPRIVATE
) != 0)
10102 tree nc
= build_omp_clause (input_location
, OMP_CLAUSE_LASTPRIVATE
);
10103 OMP_CLAUSE_DECL (nc
) = decl
;
10104 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (nc
) = 1;
10105 OMP_CLAUSE_CHAIN (nc
) = chain
;
10106 OMP_CLAUSE_CHAIN (clause
) = nc
;
10107 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
10108 gimplify_omp_ctxp
= ctx
->outer_context
;
10109 lang_hooks
.decls
.omp_finish_clause (nc
, pre_p
);
10110 gimplify_omp_ctxp
= ctx
;
10113 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
10114 gimplify_omp_ctxp
= ctx
->outer_context
;
10115 lang_hooks
.decls
.omp_finish_clause (clause
, pre_p
);
10116 if (gimplify_omp_ctxp
)
10117 for (; clause
!= chain
; clause
= OMP_CLAUSE_CHAIN (clause
))
10118 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
10119 && DECL_P (OMP_CLAUSE_SIZE (clause
)))
10120 omp_notice_variable (gimplify_omp_ctxp
, OMP_CLAUSE_SIZE (clause
),
10122 gimplify_omp_ctxp
= ctx
;
10127 gimplify_adjust_omp_clauses (gimple_seq
*pre_p
, gimple_seq body
, tree
*list_p
,
10128 enum tree_code code
)
10130 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
10131 tree
*orig_list_p
= list_p
;
10133 bool has_inscan_reductions
= false;
10137 struct gimplify_omp_ctx
*octx
;
10138 for (octx
= ctx
; octx
; octx
= octx
->outer_context
)
10139 if ((octx
->region_type
& (ORT_PARALLEL
| ORT_TASK
| ORT_TEAMS
)) != 0)
10143 struct walk_stmt_info wi
;
10144 memset (&wi
, 0, sizeof (wi
));
10145 walk_gimple_seq (body
, omp_find_stores_stmt
,
10146 omp_find_stores_op
, &wi
);
10150 if (ctx
->add_safelen1
)
10152 /* If there are VLAs in the body of simd loop, prevent
10154 gcc_assert (ctx
->region_type
== ORT_SIMD
);
10155 c
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE_SAFELEN
);
10156 OMP_CLAUSE_SAFELEN_EXPR (c
) = integer_one_node
;
10157 OMP_CLAUSE_CHAIN (c
) = *list_p
;
10159 list_p
= &OMP_CLAUSE_CHAIN (c
);
10162 if (ctx
->region_type
== ORT_WORKSHARE
10163 && ctx
->outer_context
10164 && ctx
->outer_context
->region_type
== ORT_COMBINED_PARALLEL
)
10166 for (c
= ctx
->outer_context
->clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
10167 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
10168 && OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
))
10170 decl
= OMP_CLAUSE_DECL (c
);
10172 = splay_tree_lookup (ctx
->outer_context
->variables
,
10173 (splay_tree_key
) decl
);
10174 gcc_checking_assert (!splay_tree_lookup (ctx
->variables
,
10175 (splay_tree_key
) decl
));
10176 omp_add_variable (ctx
, decl
, n
->value
);
10177 tree c2
= copy_node (c
);
10178 OMP_CLAUSE_CHAIN (c2
) = *list_p
;
10180 if ((n
->value
& GOVD_FIRSTPRIVATE
) == 0)
10182 c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
10183 OMP_CLAUSE_FIRSTPRIVATE
);
10184 OMP_CLAUSE_DECL (c2
) = decl
;
10185 OMP_CLAUSE_CHAIN (c2
) = *list_p
;
10189 while ((c
= *list_p
) != NULL
)
10192 bool remove
= false;
10194 switch (OMP_CLAUSE_CODE (c
))
10196 case OMP_CLAUSE_FIRSTPRIVATE
:
10197 if ((ctx
->region_type
& ORT_TARGET
)
10198 && (ctx
->region_type
& ORT_ACC
) == 0
10199 && TYPE_ATOMIC (strip_array_types
10200 (TREE_TYPE (OMP_CLAUSE_DECL (c
)))))
10202 error_at (OMP_CLAUSE_LOCATION (c
),
10203 "%<_Atomic%> %qD in %<firstprivate%> clause on "
10204 "%<target%> construct", OMP_CLAUSE_DECL (c
));
10209 case OMP_CLAUSE_PRIVATE
:
10210 case OMP_CLAUSE_SHARED
:
10211 case OMP_CLAUSE_LINEAR
:
10212 decl
= OMP_CLAUSE_DECL (c
);
10213 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
10214 remove
= !(n
->value
& GOVD_SEEN
);
10215 if ((n
->value
& GOVD_LASTPRIVATE_CONDITIONAL
) != 0
10216 && code
== OMP_PARALLEL
10217 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
)
10221 bool shared
= OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
;
10222 if ((n
->value
& GOVD_DEBUG_PRIVATE
)
10223 || lang_hooks
.decls
.omp_private_debug_clause (decl
, shared
))
10225 gcc_assert ((n
->value
& GOVD_DEBUG_PRIVATE
) == 0
10226 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
10228 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_PRIVATE
);
10229 OMP_CLAUSE_PRIVATE_DEBUG (c
) = 1;
10231 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
10232 && (n
->value
& GOVD_WRITTEN
) == 0
10234 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
10235 OMP_CLAUSE_SHARED_READONLY (c
) = 1;
10236 else if (DECL_P (decl
)
10237 && ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
10238 && (n
->value
& GOVD_WRITTEN
) != 0)
10239 || (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
10240 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)))
10241 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
10242 omp_mark_stores (gimplify_omp_ctxp
->outer_context
, decl
);
10246 case OMP_CLAUSE_LASTPRIVATE
:
10247 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
10248 accurately reflect the presence of a FIRSTPRIVATE clause. */
10249 decl
= OMP_CLAUSE_DECL (c
);
10250 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
10251 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
10252 = (n
->value
& GOVD_FIRSTPRIVATE
) != 0;
10253 if (code
== OMP_DISTRIBUTE
10254 && OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
10257 error_at (OMP_CLAUSE_LOCATION (c
),
10258 "same variable used in %<firstprivate%> and "
10259 "%<lastprivate%> clauses on %<distribute%> "
10263 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
10265 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
10266 omp_mark_stores (gimplify_omp_ctxp
->outer_context
, decl
);
10267 if (OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
) && code
== OMP_PARALLEL
)
10271 case OMP_CLAUSE_ALIGNED
:
10272 decl
= OMP_CLAUSE_DECL (c
);
10273 if (!is_global_var (decl
))
10275 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
10276 remove
= n
== NULL
|| !(n
->value
& GOVD_SEEN
);
10277 if (!remove
&& TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
10279 struct gimplify_omp_ctx
*octx
;
10281 && (n
->value
& (GOVD_DATA_SHARE_CLASS
10282 & ~GOVD_FIRSTPRIVATE
)))
10285 for (octx
= ctx
->outer_context
; octx
;
10286 octx
= octx
->outer_context
)
10288 n
= splay_tree_lookup (octx
->variables
,
10289 (splay_tree_key
) decl
);
10292 if (n
->value
& GOVD_LOCAL
)
10294 /* We have to avoid assigning a shared variable
10295 to itself when trying to add
10296 __builtin_assume_aligned. */
10297 if (n
->value
& GOVD_SHARED
)
10305 else if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
10307 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
10308 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
10313 case OMP_CLAUSE_NONTEMPORAL
:
10314 decl
= OMP_CLAUSE_DECL (c
);
10315 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
10316 remove
= n
== NULL
|| !(n
->value
& GOVD_SEEN
);
10319 case OMP_CLAUSE_MAP
:
10320 if (code
== OMP_TARGET_EXIT_DATA
10321 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_POINTER
)
10326 decl
= OMP_CLAUSE_DECL (c
);
10327 /* Data clauses associated with reductions must be
10328 compatible with present_or_copy. Warn and adjust the clause
10329 if that is not the case. */
10330 if (ctx
->region_type
== ORT_ACC_PARALLEL
10331 || ctx
->region_type
== ORT_ACC_SERIAL
)
10333 tree t
= DECL_P (decl
) ? decl
: TREE_OPERAND (decl
, 0);
10337 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
10339 if (n
&& (n
->value
& GOVD_REDUCTION
))
10341 enum gomp_map_kind kind
= OMP_CLAUSE_MAP_KIND (c
);
10343 OMP_CLAUSE_MAP_IN_REDUCTION (c
) = 1;
10344 if ((kind
& GOMP_MAP_TOFROM
) != GOMP_MAP_TOFROM
10345 && kind
!= GOMP_MAP_FORCE_PRESENT
10346 && kind
!= GOMP_MAP_POINTER
)
10348 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
10349 "incompatible data clause with reduction "
10350 "on %qE; promoting to %<present_or_copy%>",
10352 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_TOFROM
);
10356 if (!DECL_P (decl
))
10358 if ((ctx
->region_type
& ORT_TARGET
) != 0
10359 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
)
10361 if (TREE_CODE (decl
) == INDIRECT_REF
10362 && TREE_CODE (TREE_OPERAND (decl
, 0)) == COMPONENT_REF
10363 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl
, 0)))
10364 == REFERENCE_TYPE
))
10365 decl
= TREE_OPERAND (decl
, 0);
10366 if (TREE_CODE (decl
) == COMPONENT_REF
)
10368 while (TREE_CODE (decl
) == COMPONENT_REF
)
10369 decl
= TREE_OPERAND (decl
, 0);
10372 n
= splay_tree_lookup (ctx
->variables
,
10373 (splay_tree_key
) decl
);
10374 if (!(n
->value
& GOVD_SEEN
))
10381 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
10382 if ((ctx
->region_type
& ORT_TARGET
) != 0
10383 && !(n
->value
& GOVD_SEEN
)
10384 && GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c
)) == 0
10385 && (!is_global_var (decl
)
10386 || !lookup_attribute ("omp declare target link",
10387 DECL_ATTRIBUTES (decl
))))
10390 /* For struct element mapping, if struct is never referenced
10391 in target block and none of the mapping has always modifier,
10392 remove all the struct element mappings, which immediately
10393 follow the GOMP_MAP_STRUCT map clause. */
10394 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_STRUCT
)
10396 HOST_WIDE_INT cnt
= tree_to_shwi (OMP_CLAUSE_SIZE (c
));
10398 OMP_CLAUSE_CHAIN (c
)
10399 = OMP_CLAUSE_CHAIN (OMP_CLAUSE_CHAIN (c
));
10402 else if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_STRUCT
10403 && code
== OMP_TARGET_EXIT_DATA
)
10405 else if (DECL_SIZE (decl
)
10406 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
10407 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_POINTER
10408 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_FIRSTPRIVATE_POINTER
10409 && (OMP_CLAUSE_MAP_KIND (c
)
10410 != GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
10412 /* For GOMP_MAP_FORCE_DEVICEPTR, we'll never enter here, because
10413 for these, TREE_CODE (DECL_SIZE (decl)) will always be
10415 gcc_assert (OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_FORCE_DEVICEPTR
);
10417 tree decl2
= DECL_VALUE_EXPR (decl
);
10418 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
10419 decl2
= TREE_OPERAND (decl2
, 0);
10420 gcc_assert (DECL_P (decl2
));
10421 tree mem
= build_simple_mem_ref (decl2
);
10422 OMP_CLAUSE_DECL (c
) = mem
;
10423 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
10424 if (ctx
->outer_context
)
10426 omp_notice_variable (ctx
->outer_context
, decl2
, true);
10427 omp_notice_variable (ctx
->outer_context
,
10428 OMP_CLAUSE_SIZE (c
), true);
10430 if (((ctx
->region_type
& ORT_TARGET
) != 0
10431 || !ctx
->target_firstprivatize_array_bases
)
10432 && ((n
->value
& GOVD_SEEN
) == 0
10433 || (n
->value
& (GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
)) == 0))
10435 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
10437 OMP_CLAUSE_DECL (nc
) = decl
;
10438 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
10439 if (ctx
->target_firstprivatize_array_bases
)
10440 OMP_CLAUSE_SET_MAP_KIND (nc
,
10441 GOMP_MAP_FIRSTPRIVATE_POINTER
);
10443 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_POINTER
);
10444 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (c
);
10445 OMP_CLAUSE_CHAIN (c
) = nc
;
10451 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
10452 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
10453 gcc_assert ((n
->value
& GOVD_SEEN
) == 0
10454 || ((n
->value
& (GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
))
10459 case OMP_CLAUSE_TO
:
10460 case OMP_CLAUSE_FROM
:
10461 case OMP_CLAUSE__CACHE_
:
10462 decl
= OMP_CLAUSE_DECL (c
);
10463 if (!DECL_P (decl
))
10465 if (DECL_SIZE (decl
)
10466 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
10468 tree decl2
= DECL_VALUE_EXPR (decl
);
10469 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
10470 decl2
= TREE_OPERAND (decl2
, 0);
10471 gcc_assert (DECL_P (decl2
));
10472 tree mem
= build_simple_mem_ref (decl2
);
10473 OMP_CLAUSE_DECL (c
) = mem
;
10474 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
10475 if (ctx
->outer_context
)
10477 omp_notice_variable (ctx
->outer_context
, decl2
, true);
10478 omp_notice_variable (ctx
->outer_context
,
10479 OMP_CLAUSE_SIZE (c
), true);
10482 else if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
10483 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
10486 case OMP_CLAUSE_REDUCTION
:
10487 if (OMP_CLAUSE_REDUCTION_INSCAN (c
))
10489 decl
= OMP_CLAUSE_DECL (c
);
10490 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
10491 if ((n
->value
& GOVD_REDUCTION_INSCAN
) == 0)
10494 error_at (OMP_CLAUSE_LOCATION (c
),
10495 "%qD specified in %<inscan%> %<reduction%> clause "
10496 "but not in %<scan%> directive clause", decl
);
10499 has_inscan_reductions
= true;
10502 case OMP_CLAUSE_IN_REDUCTION
:
10503 case OMP_CLAUSE_TASK_REDUCTION
:
10504 decl
= OMP_CLAUSE_DECL (c
);
10505 /* OpenACC reductions need a present_or_copy data clause.
10506 Add one if necessary. Emit error when the reduction is private. */
10507 if (ctx
->region_type
== ORT_ACC_PARALLEL
10508 || ctx
->region_type
== ORT_ACC_SERIAL
)
10510 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
10511 if (n
->value
& (GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
))
10514 error_at (OMP_CLAUSE_LOCATION (c
), "invalid private "
10515 "reduction on %qE", DECL_NAME (decl
));
10517 else if ((n
->value
& GOVD_MAP
) == 0)
10519 tree next
= OMP_CLAUSE_CHAIN (c
);
10520 tree nc
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE_MAP
);
10521 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_TOFROM
);
10522 OMP_CLAUSE_DECL (nc
) = decl
;
10523 OMP_CLAUSE_CHAIN (c
) = nc
;
10524 lang_hooks
.decls
.omp_finish_clause (nc
, pre_p
);
10527 OMP_CLAUSE_MAP_IN_REDUCTION (nc
) = 1;
10528 if (OMP_CLAUSE_CHAIN (nc
) == NULL
)
10530 nc
= OMP_CLAUSE_CHAIN (nc
);
10532 OMP_CLAUSE_CHAIN (nc
) = next
;
10533 n
->value
|= GOVD_MAP
;
10537 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
10538 omp_mark_stores (gimplify_omp_ctxp
->outer_context
, decl
);
10540 case OMP_CLAUSE_COPYIN
:
10541 case OMP_CLAUSE_COPYPRIVATE
:
10542 case OMP_CLAUSE_IF
:
10543 case OMP_CLAUSE_NUM_THREADS
:
10544 case OMP_CLAUSE_NUM_TEAMS
:
10545 case OMP_CLAUSE_THREAD_LIMIT
:
10546 case OMP_CLAUSE_DIST_SCHEDULE
:
10547 case OMP_CLAUSE_DEVICE
:
10548 case OMP_CLAUSE_SCHEDULE
:
10549 case OMP_CLAUSE_NOWAIT
:
10550 case OMP_CLAUSE_ORDERED
:
10551 case OMP_CLAUSE_DEFAULT
:
10552 case OMP_CLAUSE_UNTIED
:
10553 case OMP_CLAUSE_COLLAPSE
:
10554 case OMP_CLAUSE_FINAL
:
10555 case OMP_CLAUSE_MERGEABLE
:
10556 case OMP_CLAUSE_PROC_BIND
:
10557 case OMP_CLAUSE_SAFELEN
:
10558 case OMP_CLAUSE_SIMDLEN
:
10559 case OMP_CLAUSE_DEPEND
:
10560 case OMP_CLAUSE_PRIORITY
:
10561 case OMP_CLAUSE_GRAINSIZE
:
10562 case OMP_CLAUSE_NUM_TASKS
:
10563 case OMP_CLAUSE_NOGROUP
:
10564 case OMP_CLAUSE_THREADS
:
10565 case OMP_CLAUSE_SIMD
:
10566 case OMP_CLAUSE_HINT
:
10567 case OMP_CLAUSE_DEFAULTMAP
:
10568 case OMP_CLAUSE_ORDER
:
10569 case OMP_CLAUSE_BIND
:
10570 case OMP_CLAUSE_USE_DEVICE_PTR
:
10571 case OMP_CLAUSE_USE_DEVICE_ADDR
:
10572 case OMP_CLAUSE_IS_DEVICE_PTR
:
10573 case OMP_CLAUSE_ASYNC
:
10574 case OMP_CLAUSE_WAIT
:
10575 case OMP_CLAUSE_INDEPENDENT
:
10576 case OMP_CLAUSE_NUM_GANGS
:
10577 case OMP_CLAUSE_NUM_WORKERS
:
10578 case OMP_CLAUSE_VECTOR_LENGTH
:
10579 case OMP_CLAUSE_GANG
:
10580 case OMP_CLAUSE_WORKER
:
10581 case OMP_CLAUSE_VECTOR
:
10582 case OMP_CLAUSE_AUTO
:
10583 case OMP_CLAUSE_SEQ
:
10584 case OMP_CLAUSE_TILE
:
10585 case OMP_CLAUSE_IF_PRESENT
:
10586 case OMP_CLAUSE_FINALIZE
:
10587 case OMP_CLAUSE_INCLUSIVE
:
10588 case OMP_CLAUSE_EXCLUSIVE
:
10592 gcc_unreachable ();
10596 *list_p
= OMP_CLAUSE_CHAIN (c
);
10598 list_p
= &OMP_CLAUSE_CHAIN (c
);
10601 /* Add in any implicit data sharing. */
10602 struct gimplify_adjust_omp_clauses_data data
;
10603 data
.list_p
= list_p
;
10604 data
.pre_p
= pre_p
;
10605 splay_tree_foreach (ctx
->variables
, gimplify_adjust_omp_clauses_1
, &data
);
10607 if (has_inscan_reductions
)
10608 for (c
= *orig_list_p
; c
; c
= OMP_CLAUSE_CHAIN (c
))
10609 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
10610 && !OMP_CLAUSE_LINEAR_NO_COPYIN (c
))
10612 error_at (OMP_CLAUSE_LOCATION (c
),
10613 "%<inscan%> %<reduction%> clause used together with "
10614 "%<linear%> clause for a variable other than loop "
10619 gimplify_omp_ctxp
= ctx
->outer_context
;
10620 delete_omp_context (ctx
);
10623 /* Return 0 if CONSTRUCTS selectors don't match the OpenMP context,
10624 -1 if unknown yet (simd is involved, won't be known until vectorization)
10625 and 1 if they do. If SCORES is non-NULL, it should point to an array
10626 of at least 2*NCONSTRUCTS+2 ints, and will be filled with the positions
10627 of the CONSTRUCTS (position -1 if it will never match) followed by
10628 number of constructs in the OpenMP context construct trait. If the
10629 score depends on whether it will be in a declare simd clone or not,
10630 the function returns 2 and there will be two sets of the scores, the first
10631 one for the case that it is not in a declare simd clone, the other
10632 that it is in a declare simd clone. */
10635 omp_construct_selector_matches (enum tree_code
*constructs
, int nconstructs
,
10638 int matched
= 0, cnt
= 0;
10639 bool simd_seen
= false;
10640 bool target_seen
= false;
10641 int declare_simd_cnt
= -1;
10642 auto_vec
<enum tree_code
, 16> codes
;
10643 for (struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
; ctx
;)
10645 if (((ctx
->region_type
& ORT_PARALLEL
) && ctx
->code
== OMP_PARALLEL
)
10646 || ((ctx
->region_type
& (ORT_TARGET
| ORT_IMPLICIT_TARGET
| ORT_ACC
))
10647 == ORT_TARGET
&& ctx
->code
== OMP_TARGET
)
10648 || ((ctx
->region_type
& ORT_TEAMS
) && ctx
->code
== OMP_TEAMS
)
10649 || (ctx
->region_type
== ORT_WORKSHARE
&& ctx
->code
== OMP_FOR
)
10650 || (ctx
->region_type
== ORT_SIMD
10651 && ctx
->code
== OMP_SIMD
10652 && !omp_find_clause (ctx
->clauses
, OMP_CLAUSE_BIND
)))
10656 codes
.safe_push (ctx
->code
);
10657 else if (matched
< nconstructs
&& ctx
->code
== constructs
[matched
])
10659 if (ctx
->code
== OMP_SIMD
)
10667 if (ctx
->code
== OMP_TARGET
)
10669 if (scores
== NULL
)
10670 return matched
< nconstructs
? 0 : simd_seen
? -1 : 1;
10671 target_seen
= true;
10675 else if (ctx
->region_type
== ORT_WORKSHARE
10676 && ctx
->code
== OMP_LOOP
10677 && ctx
->outer_context
10678 && ctx
->outer_context
->region_type
== ORT_COMBINED_PARALLEL
10679 && ctx
->outer_context
->outer_context
10680 && ctx
->outer_context
->outer_context
->code
== OMP_LOOP
10681 && ctx
->outer_context
->outer_context
->distribute
)
10682 ctx
= ctx
->outer_context
->outer_context
;
10683 ctx
= ctx
->outer_context
;
10686 && lookup_attribute ("omp declare simd",
10687 DECL_ATTRIBUTES (current_function_decl
)))
10689 /* Declare simd is a maybe case, it is supposed to be added only to the
10690 omp-simd-clone.c added clones and not to the base function. */
10691 declare_simd_cnt
= cnt
++;
10693 codes
.safe_push (OMP_SIMD
);
10695 && constructs
[0] == OMP_SIMD
)
10697 gcc_assert (matched
== 0);
10699 if (++matched
== nconstructs
)
10703 if (tree attr
= lookup_attribute ("omp declare variant variant",
10704 DECL_ATTRIBUTES (current_function_decl
)))
10706 enum tree_code variant_constructs
[5];
10707 int variant_nconstructs
= 0;
10709 variant_nconstructs
10710 = omp_constructor_traits_to_codes (TREE_VALUE (attr
),
10711 variant_constructs
);
10712 for (int i
= 0; i
< variant_nconstructs
; i
++)
10716 codes
.safe_push (variant_constructs
[i
]);
10717 else if (matched
< nconstructs
10718 && variant_constructs
[i
] == constructs
[matched
])
10720 if (variant_constructs
[i
] == OMP_SIMD
)
10731 && lookup_attribute ("omp declare target block",
10732 DECL_ATTRIBUTES (current_function_decl
)))
10735 codes
.safe_push (OMP_TARGET
);
10736 else if (matched
< nconstructs
&& constructs
[matched
] == OMP_TARGET
)
10741 for (int pass
= 0; pass
< (declare_simd_cnt
== -1 ? 1 : 2); pass
++)
10743 int j
= codes
.length () - 1;
10744 for (int i
= nconstructs
- 1; i
>= 0; i
--)
10747 && (pass
!= 0 || declare_simd_cnt
!= j
)
10748 && constructs
[i
] != codes
[j
])
10750 if (pass
== 0 && declare_simd_cnt
!= -1 && j
> declare_simd_cnt
)
10755 *scores
++ = ((pass
== 0 && declare_simd_cnt
!= -1)
10756 ? codes
.length () - 1 : codes
.length ());
10758 return declare_simd_cnt
== -1 ? 1 : 2;
10760 if (matched
== nconstructs
)
10761 return simd_seen
? -1 : 1;
10765 /* Gimplify OACC_CACHE. */
10768 gimplify_oacc_cache (tree
*expr_p
, gimple_seq
*pre_p
)
10770 tree expr
= *expr_p
;
10772 gimplify_scan_omp_clauses (&OACC_CACHE_CLAUSES (expr
), pre_p
, ORT_ACC
,
10774 gimplify_adjust_omp_clauses (pre_p
, NULL
, &OACC_CACHE_CLAUSES (expr
),
10777 /* TODO: Do something sensible with this information. */
10779 *expr_p
= NULL_TREE
;
10782 /* Helper function of gimplify_oacc_declare. The helper's purpose is to,
10783 if required, translate 'kind' in CLAUSE into an 'entry' kind and 'exit'
10784 kind. The entry kind will replace the one in CLAUSE, while the exit
10785 kind will be used in a new omp_clause and returned to the caller. */
10788 gimplify_oacc_declare_1 (tree clause
)
10790 HOST_WIDE_INT kind
, new_op
;
10794 kind
= OMP_CLAUSE_MAP_KIND (clause
);
10798 case GOMP_MAP_ALLOC
:
10799 new_op
= GOMP_MAP_RELEASE
;
10803 case GOMP_MAP_FROM
:
10804 OMP_CLAUSE_SET_MAP_KIND (clause
, GOMP_MAP_FORCE_ALLOC
);
10805 new_op
= GOMP_MAP_FROM
;
10809 case GOMP_MAP_TOFROM
:
10810 OMP_CLAUSE_SET_MAP_KIND (clause
, GOMP_MAP_TO
);
10811 new_op
= GOMP_MAP_FROM
;
10815 case GOMP_MAP_DEVICE_RESIDENT
:
10816 case GOMP_MAP_FORCE_DEVICEPTR
:
10817 case GOMP_MAP_FORCE_PRESENT
:
10818 case GOMP_MAP_LINK
:
10819 case GOMP_MAP_POINTER
:
10824 gcc_unreachable ();
10830 c
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
), OMP_CLAUSE_MAP
);
10831 OMP_CLAUSE_SET_MAP_KIND (c
, new_op
);
10832 OMP_CLAUSE_DECL (c
) = OMP_CLAUSE_DECL (clause
);
10838 /* Gimplify OACC_DECLARE. */
10841 gimplify_oacc_declare (tree
*expr_p
, gimple_seq
*pre_p
)
10843 tree expr
= *expr_p
;
10845 tree clauses
, t
, decl
;
10847 clauses
= OACC_DECLARE_CLAUSES (expr
);
10849 gimplify_scan_omp_clauses (&clauses
, pre_p
, ORT_TARGET_DATA
, OACC_DECLARE
);
10850 gimplify_adjust_omp_clauses (pre_p
, NULL
, &clauses
, OACC_DECLARE
);
10852 for (t
= clauses
; t
; t
= OMP_CLAUSE_CHAIN (t
))
10854 decl
= OMP_CLAUSE_DECL (t
);
10856 if (TREE_CODE (decl
) == MEM_REF
)
10857 decl
= TREE_OPERAND (decl
, 0);
10859 if (VAR_P (decl
) && !is_oacc_declared (decl
))
10861 tree attr
= get_identifier ("oacc declare target");
10862 DECL_ATTRIBUTES (decl
) = tree_cons (attr
, NULL_TREE
,
10863 DECL_ATTRIBUTES (decl
));
10867 && !is_global_var (decl
)
10868 && DECL_CONTEXT (decl
) == current_function_decl
)
10870 tree c
= gimplify_oacc_declare_1 (t
);
10873 if (oacc_declare_returns
== NULL
)
10874 oacc_declare_returns
= new hash_map
<tree
, tree
>;
10876 oacc_declare_returns
->put (decl
, c
);
10880 if (gimplify_omp_ctxp
)
10881 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_SEEN
);
10884 stmt
= gimple_build_omp_target (NULL
, GF_OMP_TARGET_KIND_OACC_DECLARE
,
10887 gimplify_seq_add_stmt (pre_p
, stmt
);
10889 *expr_p
= NULL_TREE
;
10892 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
10893 gimplification of the body, as well as scanning the body for used
10894 variables. We need to do this scan now, because variable-sized
10895 decls will be decomposed during gimplification. */
10898 gimplify_omp_parallel (tree
*expr_p
, gimple_seq
*pre_p
)
10900 tree expr
= *expr_p
;
10902 gimple_seq body
= NULL
;
10904 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
), pre_p
,
10905 OMP_PARALLEL_COMBINED (expr
)
10906 ? ORT_COMBINED_PARALLEL
10907 : ORT_PARALLEL
, OMP_PARALLEL
);
10909 push_gimplify_context ();
10911 g
= gimplify_and_return_first (OMP_PARALLEL_BODY (expr
), &body
);
10912 if (gimple_code (g
) == GIMPLE_BIND
)
10913 pop_gimplify_context (g
);
10915 pop_gimplify_context (NULL
);
10917 gimplify_adjust_omp_clauses (pre_p
, body
, &OMP_PARALLEL_CLAUSES (expr
),
10920 g
= gimple_build_omp_parallel (body
,
10921 OMP_PARALLEL_CLAUSES (expr
),
10922 NULL_TREE
, NULL_TREE
);
10923 if (OMP_PARALLEL_COMBINED (expr
))
10924 gimple_omp_set_subcode (g
, GF_OMP_PARALLEL_COMBINED
);
10925 gimplify_seq_add_stmt (pre_p
, g
);
10926 *expr_p
= NULL_TREE
;
10929 /* Gimplify the contents of an OMP_TASK statement. This involves
10930 gimplification of the body, as well as scanning the body for used
10931 variables. We need to do this scan now, because variable-sized
10932 decls will be decomposed during gimplification. */
10935 gimplify_omp_task (tree
*expr_p
, gimple_seq
*pre_p
)
10937 tree expr
= *expr_p
;
10939 gimple_seq body
= NULL
;
10941 if (OMP_TASK_BODY (expr
) == NULL_TREE
)
10942 for (tree c
= OMP_TASK_CLAUSES (expr
); c
; c
= OMP_CLAUSE_CHAIN (c
))
10943 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
10944 && OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_MUTEXINOUTSET
)
10946 error_at (OMP_CLAUSE_LOCATION (c
),
10947 "%<mutexinoutset%> kind in %<depend%> clause on a "
10948 "%<taskwait%> construct");
10952 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr
), pre_p
,
10953 omp_find_clause (OMP_TASK_CLAUSES (expr
),
10955 ? ORT_UNTIED_TASK
: ORT_TASK
, OMP_TASK
);
10957 if (OMP_TASK_BODY (expr
))
10959 push_gimplify_context ();
10961 g
= gimplify_and_return_first (OMP_TASK_BODY (expr
), &body
);
10962 if (gimple_code (g
) == GIMPLE_BIND
)
10963 pop_gimplify_context (g
);
10965 pop_gimplify_context (NULL
);
10968 gimplify_adjust_omp_clauses (pre_p
, body
, &OMP_TASK_CLAUSES (expr
),
10971 g
= gimple_build_omp_task (body
,
10972 OMP_TASK_CLAUSES (expr
),
10973 NULL_TREE
, NULL_TREE
,
10974 NULL_TREE
, NULL_TREE
, NULL_TREE
);
10975 if (OMP_TASK_BODY (expr
) == NULL_TREE
)
10976 gimple_omp_task_set_taskwait_p (g
, true);
10977 gimplify_seq_add_stmt (pre_p
, g
);
10978 *expr_p
= NULL_TREE
;
10981 /* Helper function of gimplify_omp_for, find OMP_FOR resp. OMP_SIMD
10982 with non-NULL OMP_FOR_INIT. Also, fill in pdata array,
10983 pdata[0] non-NULL if there is anything non-trivial in between, pdata[1]
10984 is address of OMP_PARALLEL in between if any, pdata[2] is address of
10985 OMP_FOR in between if any and pdata[3] is address of the inner
10986 OMP_FOR/OMP_SIMD. */
10989 find_combined_omp_for (tree
*tp
, int *walk_subtrees
, void *data
)
10991 tree
**pdata
= (tree
**) data
;
10992 *walk_subtrees
= 0;
10993 switch (TREE_CODE (*tp
))
10996 if (OMP_FOR_INIT (*tp
) != NULL_TREE
)
11002 *walk_subtrees
= 1;
11005 if (OMP_FOR_INIT (*tp
) != NULL_TREE
)
11012 if (BIND_EXPR_VARS (*tp
)
11013 || (BIND_EXPR_BLOCK (*tp
)
11014 && BLOCK_VARS (BIND_EXPR_BLOCK (*tp
))))
11016 *walk_subtrees
= 1;
11018 case STATEMENT_LIST
:
11019 if (!tsi_one_before_end_p (tsi_start (*tp
)))
11021 *walk_subtrees
= 1;
11023 case TRY_FINALLY_EXPR
:
11025 *walk_subtrees
= 1;
11029 *walk_subtrees
= 1;
11037 /* Gimplify the gross structure of an OMP_FOR statement. */
11039 static enum gimplify_status
11040 gimplify_omp_for (tree
*expr_p
, gimple_seq
*pre_p
)
11042 tree for_stmt
, orig_for_stmt
, inner_for_stmt
= NULL_TREE
, decl
, var
, t
;
11043 enum gimplify_status ret
= GS_ALL_DONE
;
11044 enum gimplify_status tret
;
11046 gimple_seq for_body
, for_pre_body
;
11048 bitmap has_decl_expr
= NULL
;
11049 enum omp_region_type ort
= ORT_WORKSHARE
;
11051 orig_for_stmt
= for_stmt
= *expr_p
;
11053 bool loop_p
= (omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_BIND
)
11055 if (OMP_FOR_INIT (for_stmt
) == NULL_TREE
)
11057 tree
*data
[4] = { NULL
, NULL
, NULL
, NULL
};
11058 gcc_assert (TREE_CODE (for_stmt
) != OACC_LOOP
);
11059 inner_for_stmt
= walk_tree (&OMP_FOR_BODY (for_stmt
),
11060 find_combined_omp_for
, data
, NULL
);
11061 if (inner_for_stmt
== NULL_TREE
)
11063 gcc_assert (seen_error ());
11064 *expr_p
= NULL_TREE
;
11067 if (data
[2] && OMP_FOR_PRE_BODY (*data
[2]))
11069 append_to_statement_list_force (OMP_FOR_PRE_BODY (*data
[2]),
11070 &OMP_FOR_PRE_BODY (for_stmt
));
11071 OMP_FOR_PRE_BODY (*data
[2]) = NULL_TREE
;
11073 if (OMP_FOR_PRE_BODY (inner_for_stmt
))
11075 append_to_statement_list_force (OMP_FOR_PRE_BODY (inner_for_stmt
),
11076 &OMP_FOR_PRE_BODY (for_stmt
));
11077 OMP_FOR_PRE_BODY (inner_for_stmt
) = NULL_TREE
;
11082 /* We have some statements or variable declarations in between
11083 the composite construct directives. Move them around the
11086 for (i
= 0; i
< 3; i
++)
11090 if (i
< 2 && data
[i
+ 1] == &OMP_BODY (t
))
11091 data
[i
+ 1] = data
[i
];
11092 *data
[i
] = OMP_BODY (t
);
11093 tree body
= build3 (BIND_EXPR
, void_type_node
, NULL_TREE
,
11094 NULL_TREE
, make_node (BLOCK
));
11095 OMP_BODY (t
) = body
;
11096 append_to_statement_list_force (inner_for_stmt
,
11097 &BIND_EXPR_BODY (body
));
11099 data
[3] = tsi_stmt_ptr (tsi_start (BIND_EXPR_BODY (body
)));
11100 gcc_assert (*data
[3] == inner_for_stmt
);
11105 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (inner_for_stmt
)); i
++)
11107 && OMP_FOR_ORIG_DECLS (inner_for_stmt
)
11108 && TREE_CODE (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt
),
11110 && TREE_PURPOSE (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt
),
11113 tree orig
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt
), i
);
11114 /* Class iterators aren't allowed on OMP_SIMD, so the only
11115 case we need to solve is distribute parallel for. They are
11116 allowed on the loop construct, but that is already handled
11117 in gimplify_omp_loop. */
11118 gcc_assert (TREE_CODE (inner_for_stmt
) == OMP_FOR
11119 && TREE_CODE (for_stmt
) == OMP_DISTRIBUTE
11121 tree orig_decl
= TREE_PURPOSE (orig
);
11122 tree last
= TREE_VALUE (orig
);
11124 for (pc
= &OMP_FOR_CLAUSES (inner_for_stmt
);
11125 *pc
; pc
= &OMP_CLAUSE_CHAIN (*pc
))
11126 if ((OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
11127 || OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_LASTPRIVATE
)
11128 && OMP_CLAUSE_DECL (*pc
) == orig_decl
)
11130 if (*pc
== NULL_TREE
)
11133 for (spc
= &OMP_PARALLEL_CLAUSES (*data
[1]);
11134 *spc
; spc
= &OMP_CLAUSE_CHAIN (*spc
))
11135 if (OMP_CLAUSE_CODE (*spc
) == OMP_CLAUSE_PRIVATE
11136 && OMP_CLAUSE_DECL (*spc
) == orig_decl
)
11141 *spc
= OMP_CLAUSE_CHAIN (c
);
11142 OMP_CLAUSE_CHAIN (c
) = NULL_TREE
;
11146 if (*pc
== NULL_TREE
)
11148 else if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_PRIVATE
)
11150 /* private clause will appear only on inner_for_stmt.
11151 Change it into firstprivate, and add private clause
11153 tree c
= copy_node (*pc
);
11154 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
11155 OMP_FOR_CLAUSES (for_stmt
) = c
;
11156 OMP_CLAUSE_CODE (*pc
) = OMP_CLAUSE_FIRSTPRIVATE
;
11157 lang_hooks
.decls
.omp_finish_clause (*pc
, pre_p
);
11161 /* lastprivate clause will appear on both inner_for_stmt
11162 and for_stmt. Add firstprivate clause to
11164 tree c
= build_omp_clause (OMP_CLAUSE_LOCATION (*pc
),
11165 OMP_CLAUSE_FIRSTPRIVATE
);
11166 OMP_CLAUSE_DECL (c
) = OMP_CLAUSE_DECL (*pc
);
11167 OMP_CLAUSE_CHAIN (c
) = *pc
;
11169 lang_hooks
.decls
.omp_finish_clause (*pc
, pre_p
);
11171 tree c
= build_omp_clause (UNKNOWN_LOCATION
,
11172 OMP_CLAUSE_FIRSTPRIVATE
);
11173 OMP_CLAUSE_DECL (c
) = last
;
11174 OMP_CLAUSE_CHAIN (c
) = OMP_PARALLEL_CLAUSES (*data
[1]);
11175 OMP_PARALLEL_CLAUSES (*data
[1]) = c
;
11176 c
= build_omp_clause (UNKNOWN_LOCATION
,
11177 *pc
? OMP_CLAUSE_SHARED
11178 : OMP_CLAUSE_FIRSTPRIVATE
);
11179 OMP_CLAUSE_DECL (c
) = orig_decl
;
11180 OMP_CLAUSE_CHAIN (c
) = OMP_PARALLEL_CLAUSES (*data
[1]);
11181 OMP_PARALLEL_CLAUSES (*data
[1]) = c
;
11183 /* Similarly, take care of C++ range for temporaries, those should
11184 be firstprivate on OMP_PARALLEL if any. */
11186 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (inner_for_stmt
)); i
++)
11187 if (OMP_FOR_ORIG_DECLS (inner_for_stmt
)
11188 && TREE_CODE (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt
),
11190 && TREE_CHAIN (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt
),
11194 = TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (inner_for_stmt
), i
);
11195 tree v
= TREE_CHAIN (orig
);
11196 tree c
= build_omp_clause (UNKNOWN_LOCATION
,
11197 OMP_CLAUSE_FIRSTPRIVATE
);
11198 /* First add firstprivate clause for the __for_end artificial
11200 OMP_CLAUSE_DECL (c
) = TREE_VEC_ELT (v
, 1);
11201 if (TREE_CODE (TREE_TYPE (OMP_CLAUSE_DECL (c
)))
11203 OMP_CLAUSE_FIRSTPRIVATE_NO_REFERENCE (c
) = 1;
11204 OMP_CLAUSE_CHAIN (c
) = OMP_PARALLEL_CLAUSES (*data
[1]);
11205 OMP_PARALLEL_CLAUSES (*data
[1]) = c
;
11206 if (TREE_VEC_ELT (v
, 0))
11208 /* And now the same for __for_range artificial decl if it
11210 c
= build_omp_clause (UNKNOWN_LOCATION
,
11211 OMP_CLAUSE_FIRSTPRIVATE
);
11212 OMP_CLAUSE_DECL (c
) = TREE_VEC_ELT (v
, 0);
11213 if (TREE_CODE (TREE_TYPE (OMP_CLAUSE_DECL (c
)))
11215 OMP_CLAUSE_FIRSTPRIVATE_NO_REFERENCE (c
) = 1;
11216 OMP_CLAUSE_CHAIN (c
) = OMP_PARALLEL_CLAUSES (*data
[1]);
11217 OMP_PARALLEL_CLAUSES (*data
[1]) = c
;
11222 switch (TREE_CODE (for_stmt
))
11225 case OMP_DISTRIBUTE
:
11231 if (omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_UNTIED
))
11232 ort
= ORT_UNTIED_TASKLOOP
;
11234 ort
= ORT_TASKLOOP
;
11240 gcc_unreachable ();
11243 /* Set OMP_CLAUSE_LINEAR_NO_COPYIN flag on explicit linear
11244 clause for the IV. */
11245 if (ort
== ORT_SIMD
&& TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
11247 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), 0);
11248 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
11249 decl
= TREE_OPERAND (t
, 0);
11250 for (tree c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
11251 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
11252 && OMP_CLAUSE_DECL (c
) == decl
)
11254 OMP_CLAUSE_LINEAR_NO_COPYIN (c
) = 1;
11259 if (TREE_CODE (for_stmt
) != OMP_TASKLOOP
)
11260 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
), pre_p
, ort
,
11261 loop_p
&& TREE_CODE (for_stmt
) != OMP_SIMD
11262 ? OMP_LOOP
: TREE_CODE (for_stmt
));
11264 if (TREE_CODE (for_stmt
) == OMP_DISTRIBUTE
)
11265 gimplify_omp_ctxp
->distribute
= true;
11267 /* Handle OMP_FOR_INIT. */
11268 for_pre_body
= NULL
;
11269 if ((ort
== ORT_SIMD
11270 || (inner_for_stmt
&& TREE_CODE (inner_for_stmt
) == OMP_SIMD
))
11271 && OMP_FOR_PRE_BODY (for_stmt
))
11273 has_decl_expr
= BITMAP_ALLOC (NULL
);
11274 if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == DECL_EXPR
11275 && TREE_CODE (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt
)))
11278 t
= OMP_FOR_PRE_BODY (for_stmt
);
11279 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
11281 else if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == STATEMENT_LIST
)
11283 tree_stmt_iterator si
;
11284 for (si
= tsi_start (OMP_FOR_PRE_BODY (for_stmt
)); !tsi_end_p (si
);
11288 if (TREE_CODE (t
) == DECL_EXPR
11289 && TREE_CODE (DECL_EXPR_DECL (t
)) == VAR_DECL
)
11290 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
11294 if (OMP_FOR_PRE_BODY (for_stmt
))
11296 if (TREE_CODE (for_stmt
) != OMP_TASKLOOP
|| gimplify_omp_ctxp
)
11297 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
11300 struct gimplify_omp_ctx ctx
;
11301 memset (&ctx
, 0, sizeof (ctx
));
11302 ctx
.region_type
= ORT_NONE
;
11303 gimplify_omp_ctxp
= &ctx
;
11304 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
11305 gimplify_omp_ctxp
= NULL
;
11308 OMP_FOR_PRE_BODY (for_stmt
) = NULL_TREE
;
11310 if (OMP_FOR_INIT (for_stmt
) == NULL_TREE
)
11311 for_stmt
= inner_for_stmt
;
11313 /* For taskloop, need to gimplify the start, end and step before the
11314 taskloop, outside of the taskloop omp context. */
11315 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
11317 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
11319 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
11320 if (!is_gimple_constant (TREE_OPERAND (t
, 1)))
11322 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
11323 TREE_OPERAND (t
, 1)
11324 = get_initialized_tmp_var (TREE_OPERAND (t
, 1),
11325 gimple_seq_empty_p (for_pre_body
)
11326 ? pre_p
: &for_pre_body
, NULL
,
11328 /* Reference to pointer conversion is considered useless,
11329 but is significant for firstprivate clause. Force it
11331 if (TREE_CODE (type
) == POINTER_TYPE
11332 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 1)))
11333 == REFERENCE_TYPE
))
11335 tree v
= create_tmp_var (TYPE_MAIN_VARIANT (type
));
11336 tree m
= build2 (INIT_EXPR
, TREE_TYPE (v
), v
,
11337 TREE_OPERAND (t
, 1));
11338 gimplify_and_add (m
, gimple_seq_empty_p (for_pre_body
)
11339 ? pre_p
: &for_pre_body
);
11340 TREE_OPERAND (t
, 1) = v
;
11342 tree c
= build_omp_clause (input_location
,
11343 OMP_CLAUSE_FIRSTPRIVATE
);
11344 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (t
, 1);
11345 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (orig_for_stmt
);
11346 OMP_FOR_CLAUSES (orig_for_stmt
) = c
;
11349 /* Handle OMP_FOR_COND. */
11350 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
11351 if (!is_gimple_constant (TREE_OPERAND (t
, 1)))
11353 tree type
= TREE_TYPE (TREE_OPERAND (t
, 0));
11354 TREE_OPERAND (t
, 1)
11355 = get_initialized_tmp_var (TREE_OPERAND (t
, 1),
11356 gimple_seq_empty_p (for_pre_body
)
11357 ? pre_p
: &for_pre_body
, NULL
,
11359 /* Reference to pointer conversion is considered useless,
11360 but is significant for firstprivate clause. Force it
11362 if (TREE_CODE (type
) == POINTER_TYPE
11363 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 1)))
11364 == REFERENCE_TYPE
))
11366 tree v
= create_tmp_var (TYPE_MAIN_VARIANT (type
));
11367 tree m
= build2 (INIT_EXPR
, TREE_TYPE (v
), v
,
11368 TREE_OPERAND (t
, 1));
11369 gimplify_and_add (m
, gimple_seq_empty_p (for_pre_body
)
11370 ? pre_p
: &for_pre_body
);
11371 TREE_OPERAND (t
, 1) = v
;
11373 tree c
= build_omp_clause (input_location
,
11374 OMP_CLAUSE_FIRSTPRIVATE
);
11375 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (t
, 1);
11376 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (orig_for_stmt
);
11377 OMP_FOR_CLAUSES (orig_for_stmt
) = c
;
11380 /* Handle OMP_FOR_INCR. */
11381 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
11382 if (TREE_CODE (t
) == MODIFY_EXPR
)
11384 decl
= TREE_OPERAND (t
, 0);
11385 t
= TREE_OPERAND (t
, 1);
11386 tree
*tp
= &TREE_OPERAND (t
, 1);
11387 if (TREE_CODE (t
) == PLUS_EXPR
&& *tp
== decl
)
11388 tp
= &TREE_OPERAND (t
, 0);
11390 if (!is_gimple_constant (*tp
))
11392 gimple_seq
*seq
= gimple_seq_empty_p (for_pre_body
)
11393 ? pre_p
: &for_pre_body
;
11394 *tp
= get_initialized_tmp_var (*tp
, seq
, NULL
, false);
11395 tree c
= build_omp_clause (input_location
,
11396 OMP_CLAUSE_FIRSTPRIVATE
);
11397 OMP_CLAUSE_DECL (c
) = *tp
;
11398 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (orig_for_stmt
);
11399 OMP_FOR_CLAUSES (orig_for_stmt
) = c
;
11404 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (orig_for_stmt
), pre_p
, ort
,
11408 if (orig_for_stmt
!= for_stmt
)
11409 gimplify_omp_ctxp
->combined_loop
= true;
11412 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
11413 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt
)));
11414 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
11415 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt
)));
11417 tree c
= omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_ORDERED
);
11418 bool is_doacross
= false;
11419 if (c
&& OMP_CLAUSE_ORDERED_EXPR (c
))
11421 is_doacross
= true;
11422 gimplify_omp_ctxp
->loop_iter_var
.create (TREE_VEC_LENGTH
11423 (OMP_FOR_INIT (for_stmt
))
11426 int collapse
= 1, tile
= 0;
11427 c
= omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_COLLAPSE
);
11429 collapse
= tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (c
));
11430 c
= omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_TILE
);
11432 tile
= list_length (OMP_CLAUSE_TILE_LIST (c
));
11433 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
11435 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
11436 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
11437 decl
= TREE_OPERAND (t
, 0);
11438 gcc_assert (DECL_P (decl
));
11439 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl
))
11440 || POINTER_TYPE_P (TREE_TYPE (decl
)));
11443 if (TREE_CODE (for_stmt
) == OMP_FOR
&& OMP_FOR_ORIG_DECLS (for_stmt
))
11445 tree orig_decl
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt
), i
);
11446 if (TREE_CODE (orig_decl
) == TREE_LIST
)
11448 orig_decl
= TREE_PURPOSE (orig_decl
);
11452 gimplify_omp_ctxp
->loop_iter_var
.quick_push (orig_decl
);
11455 gimplify_omp_ctxp
->loop_iter_var
.quick_push (decl
);
11456 gimplify_omp_ctxp
->loop_iter_var
.quick_push (decl
);
11459 /* Make sure the iteration variable is private. */
11460 tree c
= NULL_TREE
;
11461 tree c2
= NULL_TREE
;
11462 if (orig_for_stmt
!= for_stmt
)
11464 /* Preserve this information until we gimplify the inner simd. */
11466 && bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)))
11467 TREE_PRIVATE (t
) = 1;
11469 else if (ort
== ORT_SIMD
)
11471 splay_tree_node n
= splay_tree_lookup (gimplify_omp_ctxp
->variables
,
11472 (splay_tree_key
) decl
);
11473 omp_is_private (gimplify_omp_ctxp
, decl
,
11474 1 + (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
11476 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
11478 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
11479 if (n
->value
& GOVD_LASTPRIVATE_CONDITIONAL
)
11480 for (tree c3
= omp_find_clause (OMP_FOR_CLAUSES (for_stmt
),
11481 OMP_CLAUSE_LASTPRIVATE
);
11482 c3
; c3
= omp_find_clause (OMP_CLAUSE_CHAIN (c3
),
11483 OMP_CLAUSE_LASTPRIVATE
))
11484 if (OMP_CLAUSE_DECL (c3
) == decl
)
11486 warning_at (OMP_CLAUSE_LOCATION (c3
), 0,
11487 "conditional %<lastprivate%> on loop "
11488 "iterator %qD ignored", decl
);
11489 OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c3
) = 0;
11490 n
->value
&= ~GOVD_LASTPRIVATE_CONDITIONAL
;
11493 else if (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1 && !loop_p
)
11495 c
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
11496 OMP_CLAUSE_LINEAR_NO_COPYIN (c
) = 1;
11497 unsigned int flags
= GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
;
11499 && bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)))
11500 || TREE_PRIVATE (t
))
11502 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
11503 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
11505 struct gimplify_omp_ctx
*outer
11506 = gimplify_omp_ctxp
->outer_context
;
11507 if (outer
&& !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
11509 if (outer
->region_type
== ORT_WORKSHARE
11510 && outer
->combined_loop
)
11512 n
= splay_tree_lookup (outer
->variables
,
11513 (splay_tree_key
)decl
);
11514 if (n
!= NULL
&& (n
->value
& GOVD_LOCAL
) != 0)
11516 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
11517 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
11521 struct gimplify_omp_ctx
*octx
= outer
->outer_context
;
11523 && octx
->region_type
== ORT_COMBINED_PARALLEL
11524 && octx
->outer_context
11525 && (octx
->outer_context
->region_type
11527 && octx
->outer_context
->combined_loop
)
11529 octx
= octx
->outer_context
;
11530 n
= splay_tree_lookup (octx
->variables
,
11531 (splay_tree_key
)decl
);
11532 if (n
!= NULL
&& (n
->value
& GOVD_LOCAL
) != 0)
11534 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
11535 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
11542 OMP_CLAUSE_DECL (c
) = decl
;
11543 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
11544 OMP_FOR_CLAUSES (for_stmt
) = c
;
11545 omp_add_variable (gimplify_omp_ctxp
, decl
, flags
);
11546 if (outer
&& !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
11548 if (outer
->region_type
== ORT_WORKSHARE
11549 && outer
->combined_loop
)
11551 if (outer
->outer_context
11552 && (outer
->outer_context
->region_type
11553 == ORT_COMBINED_PARALLEL
))
11554 outer
= outer
->outer_context
;
11555 else if (omp_check_private (outer
, decl
, false))
11558 else if (((outer
->region_type
& ORT_TASKLOOP
)
11560 && outer
->combined_loop
11561 && !omp_check_private (gimplify_omp_ctxp
,
11564 else if (outer
->region_type
!= ORT_COMBINED_PARALLEL
)
11566 omp_notice_variable (outer
, decl
, true);
11571 n
= splay_tree_lookup (outer
->variables
,
11572 (splay_tree_key
)decl
);
11573 if (n
== NULL
|| (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
11575 omp_add_variable (outer
, decl
,
11576 GOVD_LASTPRIVATE
| GOVD_SEEN
);
11577 if (outer
->region_type
== ORT_COMBINED_PARALLEL
11578 && outer
->outer_context
11579 && (outer
->outer_context
->region_type
11581 && outer
->outer_context
->combined_loop
)
11583 outer
= outer
->outer_context
;
11584 n
= splay_tree_lookup (outer
->variables
,
11585 (splay_tree_key
)decl
);
11586 if (omp_check_private (outer
, decl
, false))
11589 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
11591 omp_add_variable (outer
, decl
,
11597 if (outer
&& outer
->outer_context
11598 && ((outer
->outer_context
->region_type
11599 & ORT_COMBINED_TEAMS
) == ORT_COMBINED_TEAMS
11600 || (((outer
->region_type
& ORT_TASKLOOP
)
11602 && (outer
->outer_context
->region_type
11603 == ORT_COMBINED_PARALLEL
))))
11605 outer
= outer
->outer_context
;
11606 n
= splay_tree_lookup (outer
->variables
,
11607 (splay_tree_key
)decl
);
11609 || (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
11610 omp_add_variable (outer
, decl
,
11611 GOVD_SHARED
| GOVD_SEEN
);
11615 if (outer
&& outer
->outer_context
)
11616 omp_notice_variable (outer
->outer_context
, decl
,
11626 || !bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)));
11627 if (TREE_PRIVATE (t
))
11628 lastprivate
= false;
11629 if (loop_p
&& OMP_FOR_ORIG_DECLS (for_stmt
))
11631 tree elt
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt
), i
);
11632 if (TREE_CODE (elt
) == TREE_LIST
&& TREE_PURPOSE (elt
))
11633 lastprivate
= false;
11636 struct gimplify_omp_ctx
*outer
11637 = gimplify_omp_ctxp
->outer_context
;
11638 if (outer
&& lastprivate
)
11640 if (outer
->region_type
== ORT_WORKSHARE
11641 && outer
->combined_loop
)
11643 n
= splay_tree_lookup (outer
->variables
,
11644 (splay_tree_key
)decl
);
11645 if (n
!= NULL
&& (n
->value
& GOVD_LOCAL
) != 0)
11647 lastprivate
= false;
11650 else if (outer
->outer_context
11651 && (outer
->outer_context
->region_type
11652 == ORT_COMBINED_PARALLEL
))
11653 outer
= outer
->outer_context
;
11654 else if (omp_check_private (outer
, decl
, false))
11657 else if (((outer
->region_type
& ORT_TASKLOOP
)
11659 && outer
->combined_loop
11660 && !omp_check_private (gimplify_omp_ctxp
,
11663 else if (outer
->region_type
!= ORT_COMBINED_PARALLEL
)
11665 omp_notice_variable (outer
, decl
, true);
11670 n
= splay_tree_lookup (outer
->variables
,
11671 (splay_tree_key
)decl
);
11672 if (n
== NULL
|| (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
11674 omp_add_variable (outer
, decl
,
11675 GOVD_LASTPRIVATE
| GOVD_SEEN
);
11676 if (outer
->region_type
== ORT_COMBINED_PARALLEL
11677 && outer
->outer_context
11678 && (outer
->outer_context
->region_type
11680 && outer
->outer_context
->combined_loop
)
11682 outer
= outer
->outer_context
;
11683 n
= splay_tree_lookup (outer
->variables
,
11684 (splay_tree_key
)decl
);
11685 if (omp_check_private (outer
, decl
, false))
11688 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
11690 omp_add_variable (outer
, decl
,
11696 if (outer
&& outer
->outer_context
11697 && ((outer
->outer_context
->region_type
11698 & ORT_COMBINED_TEAMS
) == ORT_COMBINED_TEAMS
11699 || (((outer
->region_type
& ORT_TASKLOOP
)
11701 && (outer
->outer_context
->region_type
11702 == ORT_COMBINED_PARALLEL
))))
11704 outer
= outer
->outer_context
;
11705 n
= splay_tree_lookup (outer
->variables
,
11706 (splay_tree_key
)decl
);
11708 || (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
11709 omp_add_variable (outer
, decl
,
11710 GOVD_SHARED
| GOVD_SEEN
);
11714 if (outer
&& outer
->outer_context
)
11715 omp_notice_variable (outer
->outer_context
, decl
,
11721 c
= build_omp_clause (input_location
,
11722 lastprivate
? OMP_CLAUSE_LASTPRIVATE
11723 : OMP_CLAUSE_PRIVATE
);
11724 OMP_CLAUSE_DECL (c
) = decl
;
11725 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
11726 OMP_FOR_CLAUSES (for_stmt
) = c
;
11727 omp_add_variable (gimplify_omp_ctxp
, decl
,
11728 (lastprivate
? GOVD_LASTPRIVATE
: GOVD_PRIVATE
)
11729 | GOVD_EXPLICIT
| GOVD_SEEN
);
11733 else if (omp_is_private (gimplify_omp_ctxp
, decl
, 0))
11735 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
11736 splay_tree_node n
= splay_tree_lookup (gimplify_omp_ctxp
->variables
,
11737 (splay_tree_key
) decl
);
11738 if (n
&& (n
->value
& GOVD_LASTPRIVATE_CONDITIONAL
))
11739 for (tree c3
= omp_find_clause (OMP_FOR_CLAUSES (for_stmt
),
11740 OMP_CLAUSE_LASTPRIVATE
);
11741 c3
; c3
= omp_find_clause (OMP_CLAUSE_CHAIN (c3
),
11742 OMP_CLAUSE_LASTPRIVATE
))
11743 if (OMP_CLAUSE_DECL (c3
) == decl
)
11745 warning_at (OMP_CLAUSE_LOCATION (c3
), 0,
11746 "conditional %<lastprivate%> on loop "
11747 "iterator %qD ignored", decl
);
11748 OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c3
) = 0;
11749 n
->value
&= ~GOVD_LASTPRIVATE_CONDITIONAL
;
11753 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_PRIVATE
| GOVD_SEEN
);
11755 /* If DECL is not a gimple register, create a temporary variable to act
11756 as an iteration counter. This is valid, since DECL cannot be
11757 modified in the body of the loop. Similarly for any iteration vars
11758 in simd with collapse > 1 where the iterator vars must be
11760 if (orig_for_stmt
!= for_stmt
)
11762 else if (!is_gimple_reg (decl
)
11763 || (ort
== ORT_SIMD
11764 && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1))
11766 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
11767 /* Make sure omp_add_variable is not called on it prematurely.
11768 We call it ourselves a few lines later. */
11769 gimplify_omp_ctxp
= NULL
;
11770 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
11771 gimplify_omp_ctxp
= ctx
;
11772 TREE_OPERAND (t
, 0) = var
;
11774 gimplify_seq_add_stmt (&for_body
, gimple_build_assign (decl
, var
));
11776 if (ort
== ORT_SIMD
11777 && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
11779 c2
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
11780 OMP_CLAUSE_LINEAR_NO_COPYIN (c2
) = 1;
11781 OMP_CLAUSE_LINEAR_NO_COPYOUT (c2
) = 1;
11782 OMP_CLAUSE_DECL (c2
) = var
;
11783 OMP_CLAUSE_CHAIN (c2
) = OMP_FOR_CLAUSES (for_stmt
);
11784 OMP_FOR_CLAUSES (for_stmt
) = c2
;
11785 omp_add_variable (gimplify_omp_ctxp
, var
,
11786 GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
);
11787 if (c
== NULL_TREE
)
11794 omp_add_variable (gimplify_omp_ctxp
, var
,
11795 GOVD_PRIVATE
| GOVD_SEEN
);
11800 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
11801 is_gimple_val
, fb_rvalue
, false);
11802 ret
= MIN (ret
, tret
);
11803 if (ret
== GS_ERROR
)
11806 /* Handle OMP_FOR_COND. */
11807 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
11808 gcc_assert (COMPARISON_CLASS_P (t
));
11809 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
11811 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
11812 is_gimple_val
, fb_rvalue
, false);
11813 ret
= MIN (ret
, tret
);
11815 /* Handle OMP_FOR_INCR. */
11816 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
11817 switch (TREE_CODE (t
))
11819 case PREINCREMENT_EXPR
:
11820 case POSTINCREMENT_EXPR
:
11822 tree decl
= TREE_OPERAND (t
, 0);
11823 /* c_omp_for_incr_canonicalize_ptr() should have been
11824 called to massage things appropriately. */
11825 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl
)));
11827 if (orig_for_stmt
!= for_stmt
)
11829 t
= build_int_cst (TREE_TYPE (decl
), 1);
11831 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
11832 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
11833 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
11834 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
11838 case PREDECREMENT_EXPR
:
11839 case POSTDECREMENT_EXPR
:
11840 /* c_omp_for_incr_canonicalize_ptr() should have been
11841 called to massage things appropriately. */
11842 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl
)));
11843 if (orig_for_stmt
!= for_stmt
)
11845 t
= build_int_cst (TREE_TYPE (decl
), -1);
11847 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
11848 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
11849 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
11850 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
11854 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
11855 TREE_OPERAND (t
, 0) = var
;
11857 t
= TREE_OPERAND (t
, 1);
11858 switch (TREE_CODE (t
))
11861 if (TREE_OPERAND (t
, 1) == decl
)
11863 TREE_OPERAND (t
, 1) = TREE_OPERAND (t
, 0);
11864 TREE_OPERAND (t
, 0) = var
;
11870 case POINTER_PLUS_EXPR
:
11871 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
11872 TREE_OPERAND (t
, 0) = var
;
11875 gcc_unreachable ();
11878 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
11879 is_gimple_val
, fb_rvalue
, false);
11880 ret
= MIN (ret
, tret
);
11883 tree step
= TREE_OPERAND (t
, 1);
11884 tree stept
= TREE_TYPE (decl
);
11885 if (POINTER_TYPE_P (stept
))
11887 step
= fold_convert (stept
, step
);
11888 if (TREE_CODE (t
) == MINUS_EXPR
)
11889 step
= fold_build1 (NEGATE_EXPR
, stept
, step
);
11890 OMP_CLAUSE_LINEAR_STEP (c
) = step
;
11891 if (step
!= TREE_OPERAND (t
, 1))
11893 tret
= gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
),
11894 &for_pre_body
, NULL
,
11895 is_gimple_val
, fb_rvalue
, false);
11896 ret
= MIN (ret
, tret
);
11902 gcc_unreachable ();
11908 OMP_CLAUSE_LINEAR_STEP (c2
) = OMP_CLAUSE_LINEAR_STEP (c
);
11911 if ((var
!= decl
|| collapse
> 1 || tile
) && orig_for_stmt
== for_stmt
)
11913 for (c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
11914 if (((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
11915 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) == NULL
)
11916 || (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
11917 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)
11918 && OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
) == NULL
))
11919 && OMP_CLAUSE_DECL (c
) == decl
)
11921 if (is_doacross
&& (collapse
== 1 || i
>= collapse
))
11925 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
11926 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
11927 gcc_assert (TREE_OPERAND (t
, 0) == var
);
11928 t
= TREE_OPERAND (t
, 1);
11929 gcc_assert (TREE_CODE (t
) == PLUS_EXPR
11930 || TREE_CODE (t
) == MINUS_EXPR
11931 || TREE_CODE (t
) == POINTER_PLUS_EXPR
);
11932 gcc_assert (TREE_OPERAND (t
, 0) == var
);
11933 t
= build2 (TREE_CODE (t
), TREE_TYPE (decl
),
11934 is_doacross
? var
: decl
,
11935 TREE_OPERAND (t
, 1));
11938 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
11939 seq
= &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
);
11941 seq
= &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
);
11942 push_gimplify_context ();
11943 gimplify_assign (decl
, t
, seq
);
11944 gimple
*bind
= NULL
;
11945 if (gimplify_ctxp
->temps
)
11947 bind
= gimple_build_bind (NULL_TREE
, *seq
, NULL_TREE
);
11949 gimplify_seq_add_stmt (seq
, bind
);
11951 pop_gimplify_context (bind
);
11956 BITMAP_FREE (has_decl_expr
);
11958 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
11959 || (loop_p
&& orig_for_stmt
== for_stmt
))
11961 push_gimplify_context ();
11962 if (TREE_CODE (OMP_FOR_BODY (orig_for_stmt
)) != BIND_EXPR
)
11964 OMP_FOR_BODY (orig_for_stmt
)
11965 = build3 (BIND_EXPR
, void_type_node
, NULL
,
11966 OMP_FOR_BODY (orig_for_stmt
), NULL
);
11967 TREE_SIDE_EFFECTS (OMP_FOR_BODY (orig_for_stmt
)) = 1;
11971 gimple
*g
= gimplify_and_return_first (OMP_FOR_BODY (orig_for_stmt
),
11974 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
11975 || (loop_p
&& orig_for_stmt
== for_stmt
))
11977 if (gimple_code (g
) == GIMPLE_BIND
)
11978 pop_gimplify_context (g
);
11980 pop_gimplify_context (NULL
);
11983 if (orig_for_stmt
!= for_stmt
)
11984 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
11986 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
11987 decl
= TREE_OPERAND (t
, 0);
11988 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
11989 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
11990 gimplify_omp_ctxp
= ctx
->outer_context
;
11991 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
11992 gimplify_omp_ctxp
= ctx
;
11993 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
11994 TREE_OPERAND (t
, 0) = var
;
11995 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
11996 TREE_OPERAND (t
, 1) = copy_node (TREE_OPERAND (t
, 1));
11997 TREE_OPERAND (TREE_OPERAND (t
, 1), 0) = var
;
12000 gimplify_adjust_omp_clauses (pre_p
, for_body
,
12001 &OMP_FOR_CLAUSES (orig_for_stmt
),
12002 TREE_CODE (orig_for_stmt
));
12005 switch (TREE_CODE (orig_for_stmt
))
12007 case OMP_FOR
: kind
= GF_OMP_FOR_KIND_FOR
; break;
12008 case OMP_SIMD
: kind
= GF_OMP_FOR_KIND_SIMD
; break;
12009 case OMP_DISTRIBUTE
: kind
= GF_OMP_FOR_KIND_DISTRIBUTE
; break;
12010 case OMP_TASKLOOP
: kind
= GF_OMP_FOR_KIND_TASKLOOP
; break;
12011 case OACC_LOOP
: kind
= GF_OMP_FOR_KIND_OACC_LOOP
; break;
12013 gcc_unreachable ();
12015 if (loop_p
&& kind
== GF_OMP_FOR_KIND_SIMD
)
12017 gimplify_seq_add_seq (pre_p
, for_pre_body
);
12018 for_pre_body
= NULL
;
12020 gfor
= gimple_build_omp_for (for_body
, kind
, OMP_FOR_CLAUSES (orig_for_stmt
),
12021 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)),
12023 if (orig_for_stmt
!= for_stmt
)
12024 gimple_omp_for_set_combined_p (gfor
, true);
12025 if (gimplify_omp_ctxp
12026 && (gimplify_omp_ctxp
->combined_loop
12027 || (gimplify_omp_ctxp
->region_type
== ORT_COMBINED_PARALLEL
12028 && gimplify_omp_ctxp
->outer_context
12029 && gimplify_omp_ctxp
->outer_context
->combined_loop
)))
12031 gimple_omp_for_set_combined_into_p (gfor
, true);
12032 if (gimplify_omp_ctxp
->combined_loop
)
12033 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_SIMD
);
12035 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_FOR
);
12038 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
12040 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
12041 gimple_omp_for_set_index (gfor
, i
, TREE_OPERAND (t
, 0));
12042 gimple_omp_for_set_initial (gfor
, i
, TREE_OPERAND (t
, 1));
12043 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
12044 gimple_omp_for_set_cond (gfor
, i
, TREE_CODE (t
));
12045 gimple_omp_for_set_final (gfor
, i
, TREE_OPERAND (t
, 1));
12046 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
12047 gimple_omp_for_set_incr (gfor
, i
, TREE_OPERAND (t
, 1));
12050 /* OMP_TASKLOOP is gimplified as two GIMPLE_OMP_FOR taskloop
12051 constructs with GIMPLE_OMP_TASK sandwiched in between them.
12052 The outer taskloop stands for computing the number of iterations,
12053 counts for collapsed loops and holding taskloop specific clauses.
12054 The task construct stands for the effect of data sharing on the
12055 explicit task it creates and the inner taskloop stands for expansion
12056 of the static loop inside of the explicit task construct. */
12057 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
12059 tree
*gfor_clauses_ptr
= gimple_omp_for_clauses_ptr (gfor
);
12060 tree task_clauses
= NULL_TREE
;
12061 tree c
= *gfor_clauses_ptr
;
12062 tree
*gtask_clauses_ptr
= &task_clauses
;
12063 tree outer_for_clauses
= NULL_TREE
;
12064 tree
*gforo_clauses_ptr
= &outer_for_clauses
;
12065 for (; c
; c
= OMP_CLAUSE_CHAIN (c
))
12066 switch (OMP_CLAUSE_CODE (c
))
12068 /* These clauses are allowed on task, move them there. */
12069 case OMP_CLAUSE_SHARED
:
12070 case OMP_CLAUSE_FIRSTPRIVATE
:
12071 case OMP_CLAUSE_DEFAULT
:
12072 case OMP_CLAUSE_IF
:
12073 case OMP_CLAUSE_UNTIED
:
12074 case OMP_CLAUSE_FINAL
:
12075 case OMP_CLAUSE_MERGEABLE
:
12076 case OMP_CLAUSE_PRIORITY
:
12077 case OMP_CLAUSE_REDUCTION
:
12078 case OMP_CLAUSE_IN_REDUCTION
:
12079 *gtask_clauses_ptr
= c
;
12080 gtask_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
12082 case OMP_CLAUSE_PRIVATE
:
12083 if (OMP_CLAUSE_PRIVATE_TASKLOOP_IV (c
))
12085 /* We want private on outer for and firstprivate
12088 = build_omp_clause (OMP_CLAUSE_LOCATION (c
),
12089 OMP_CLAUSE_FIRSTPRIVATE
);
12090 OMP_CLAUSE_DECL (*gtask_clauses_ptr
) = OMP_CLAUSE_DECL (c
);
12091 lang_hooks
.decls
.omp_finish_clause (*gtask_clauses_ptr
, NULL
);
12092 gtask_clauses_ptr
= &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr
);
12093 *gforo_clauses_ptr
= c
;
12094 gforo_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
12098 *gtask_clauses_ptr
= c
;
12099 gtask_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
12102 /* These clauses go into outer taskloop clauses. */
12103 case OMP_CLAUSE_GRAINSIZE
:
12104 case OMP_CLAUSE_NUM_TASKS
:
12105 case OMP_CLAUSE_NOGROUP
:
12106 *gforo_clauses_ptr
= c
;
12107 gforo_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
12109 /* Taskloop clause we duplicate on both taskloops. */
12110 case OMP_CLAUSE_COLLAPSE
:
12111 *gfor_clauses_ptr
= c
;
12112 gfor_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
12113 *gforo_clauses_ptr
= copy_node (c
);
12114 gforo_clauses_ptr
= &OMP_CLAUSE_CHAIN (*gforo_clauses_ptr
);
12116 /* For lastprivate, keep the clause on inner taskloop, and add
12117 a shared clause on task. If the same decl is also firstprivate,
12118 add also firstprivate clause on the inner taskloop. */
12119 case OMP_CLAUSE_LASTPRIVATE
:
12120 if (OMP_CLAUSE_LASTPRIVATE_LOOP_IV (c
))
12122 /* For taskloop C++ lastprivate IVs, we want:
12123 1) private on outer taskloop
12124 2) firstprivate and shared on task
12125 3) lastprivate on inner taskloop */
12127 = build_omp_clause (OMP_CLAUSE_LOCATION (c
),
12128 OMP_CLAUSE_FIRSTPRIVATE
);
12129 OMP_CLAUSE_DECL (*gtask_clauses_ptr
) = OMP_CLAUSE_DECL (c
);
12130 lang_hooks
.decls
.omp_finish_clause (*gtask_clauses_ptr
, NULL
);
12131 gtask_clauses_ptr
= &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr
);
12132 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
) = 1;
12133 *gforo_clauses_ptr
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
12134 OMP_CLAUSE_PRIVATE
);
12135 OMP_CLAUSE_DECL (*gforo_clauses_ptr
) = OMP_CLAUSE_DECL (c
);
12136 OMP_CLAUSE_PRIVATE_TASKLOOP_IV (*gforo_clauses_ptr
) = 1;
12137 TREE_TYPE (*gforo_clauses_ptr
) = TREE_TYPE (c
);
12138 gforo_clauses_ptr
= &OMP_CLAUSE_CHAIN (*gforo_clauses_ptr
);
12140 *gfor_clauses_ptr
= c
;
12141 gfor_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
12143 = build_omp_clause (OMP_CLAUSE_LOCATION (c
), OMP_CLAUSE_SHARED
);
12144 OMP_CLAUSE_DECL (*gtask_clauses_ptr
) = OMP_CLAUSE_DECL (c
);
12145 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
12146 OMP_CLAUSE_SHARED_FIRSTPRIVATE (*gtask_clauses_ptr
) = 1;
12148 = &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr
);
12151 gcc_unreachable ();
12153 *gfor_clauses_ptr
= NULL_TREE
;
12154 *gtask_clauses_ptr
= NULL_TREE
;
12155 *gforo_clauses_ptr
= NULL_TREE
;
12156 g
= gimple_build_bind (NULL_TREE
, gfor
, NULL_TREE
);
12157 g
= gimple_build_omp_task (g
, task_clauses
, NULL_TREE
, NULL_TREE
,
12158 NULL_TREE
, NULL_TREE
, NULL_TREE
);
12159 gimple_omp_task_set_taskloop_p (g
, true);
12160 g
= gimple_build_bind (NULL_TREE
, g
, NULL_TREE
);
12162 = gimple_build_omp_for (g
, GF_OMP_FOR_KIND_TASKLOOP
, outer_for_clauses
,
12163 gimple_omp_for_collapse (gfor
),
12164 gimple_omp_for_pre_body (gfor
));
12165 gimple_omp_for_set_pre_body (gfor
, NULL
);
12166 gimple_omp_for_set_combined_p (gforo
, true);
12167 gimple_omp_for_set_combined_into_p (gfor
, true);
12168 for (i
= 0; i
< (int) gimple_omp_for_collapse (gfor
); i
++)
12170 tree type
= TREE_TYPE (gimple_omp_for_index (gfor
, i
));
12171 tree v
= create_tmp_var (type
);
12172 gimple_omp_for_set_index (gforo
, i
, v
);
12173 t
= unshare_expr (gimple_omp_for_initial (gfor
, i
));
12174 gimple_omp_for_set_initial (gforo
, i
, t
);
12175 gimple_omp_for_set_cond (gforo
, i
,
12176 gimple_omp_for_cond (gfor
, i
));
12177 t
= unshare_expr (gimple_omp_for_final (gfor
, i
));
12178 gimple_omp_for_set_final (gforo
, i
, t
);
12179 t
= unshare_expr (gimple_omp_for_incr (gfor
, i
));
12180 gcc_assert (TREE_OPERAND (t
, 0) == gimple_omp_for_index (gfor
, i
));
12181 TREE_OPERAND (t
, 0) = v
;
12182 gimple_omp_for_set_incr (gforo
, i
, t
);
12183 t
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
12184 OMP_CLAUSE_DECL (t
) = v
;
12185 OMP_CLAUSE_CHAIN (t
) = gimple_omp_for_clauses (gforo
);
12186 gimple_omp_for_set_clauses (gforo
, t
);
12188 gimplify_seq_add_stmt (pre_p
, gforo
);
12191 gimplify_seq_add_stmt (pre_p
, gfor
);
12193 if (TREE_CODE (orig_for_stmt
) == OMP_FOR
)
12195 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
12196 unsigned lastprivate_conditional
= 0;
12198 && (ctx
->region_type
== ORT_TARGET_DATA
12199 || ctx
->region_type
== ORT_TASKGROUP
))
12200 ctx
= ctx
->outer_context
;
12201 if (ctx
&& (ctx
->region_type
& ORT_PARALLEL
) != 0)
12202 for (tree c
= gimple_omp_for_clauses (gfor
);
12203 c
; c
= OMP_CLAUSE_CHAIN (c
))
12204 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
12205 && OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
))
12206 ++lastprivate_conditional
;
12207 if (lastprivate_conditional
)
12209 struct omp_for_data fd
;
12210 omp_extract_for_data (gfor
, &fd
, NULL
);
12211 tree type
= build_array_type_nelts (unsigned_type_for (fd
.iter_type
),
12212 lastprivate_conditional
);
12213 tree var
= create_tmp_var_raw (type
);
12214 tree c
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE__CONDTEMP_
);
12215 OMP_CLAUSE_DECL (c
) = var
;
12216 OMP_CLAUSE_CHAIN (c
) = gimple_omp_for_clauses (gfor
);
12217 gimple_omp_for_set_clauses (gfor
, c
);
12218 omp_add_variable (ctx
, var
, GOVD_CONDTEMP
| GOVD_SEEN
);
12221 else if (TREE_CODE (orig_for_stmt
) == OMP_SIMD
)
12223 unsigned lastprivate_conditional
= 0;
12224 for (tree c
= gimple_omp_for_clauses (gfor
); c
; c
= OMP_CLAUSE_CHAIN (c
))
12225 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
12226 && OMP_CLAUSE_LASTPRIVATE_CONDITIONAL (c
))
12227 ++lastprivate_conditional
;
12228 if (lastprivate_conditional
)
12230 struct omp_for_data fd
;
12231 omp_extract_for_data (gfor
, &fd
, NULL
);
12232 tree type
= unsigned_type_for (fd
.iter_type
);
12233 while (lastprivate_conditional
--)
12235 tree c
= build_omp_clause (UNKNOWN_LOCATION
,
12236 OMP_CLAUSE__CONDTEMP_
);
12237 OMP_CLAUSE_DECL (c
) = create_tmp_var (type
);
12238 OMP_CLAUSE_CHAIN (c
) = gimple_omp_for_clauses (gfor
);
12239 gimple_omp_for_set_clauses (gfor
, c
);
12244 if (ret
!= GS_ALL_DONE
)
12246 *expr_p
= NULL_TREE
;
12247 return GS_ALL_DONE
;
12250 /* Helper for gimplify_omp_loop, called through walk_tree. */
12253 replace_reduction_placeholders (tree
*tp
, int *walk_subtrees
, void *data
)
12257 tree
*d
= (tree
*) data
;
12258 if (*tp
== OMP_CLAUSE_REDUCTION_PLACEHOLDER (d
[0]))
12260 *tp
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (d
[1]);
12261 *walk_subtrees
= 0;
12263 else if (*tp
== OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (d
[0]))
12265 *tp
= OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (d
[1]);
12266 *walk_subtrees
= 0;
12272 /* Gimplify the gross structure of an OMP_LOOP statement. */
12274 static enum gimplify_status
12275 gimplify_omp_loop (tree
*expr_p
, gimple_seq
*pre_p
)
12277 tree for_stmt
= *expr_p
;
12278 tree clauses
= OMP_FOR_CLAUSES (for_stmt
);
12279 struct gimplify_omp_ctx
*octx
= gimplify_omp_ctxp
;
12280 enum omp_clause_bind_kind kind
= OMP_CLAUSE_BIND_THREAD
;
12283 /* If order is not present, the behavior is as if order(concurrent)
12285 tree order
= omp_find_clause (clauses
, OMP_CLAUSE_ORDER
);
12286 if (order
== NULL_TREE
)
12288 order
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE_ORDER
);
12289 OMP_CLAUSE_CHAIN (order
) = clauses
;
12290 OMP_FOR_CLAUSES (for_stmt
) = clauses
= order
;
12293 tree bind
= omp_find_clause (clauses
, OMP_CLAUSE_BIND
);
12294 if (bind
== NULL_TREE
)
12296 if (!flag_openmp
) /* flag_openmp_simd */
12298 else if (octx
&& (octx
->region_type
& ORT_TEAMS
) != 0)
12299 kind
= OMP_CLAUSE_BIND_TEAMS
;
12300 else if (octx
&& (octx
->region_type
& ORT_PARALLEL
) != 0)
12301 kind
= OMP_CLAUSE_BIND_PARALLEL
;
12304 for (; octx
; octx
= octx
->outer_context
)
12306 if ((octx
->region_type
& ORT_ACC
) != 0
12307 || octx
->region_type
== ORT_NONE
12308 || octx
->region_type
== ORT_IMPLICIT_TARGET
)
12312 if (octx
== NULL
&& !in_omp_construct
)
12313 error_at (EXPR_LOCATION (for_stmt
),
12314 "%<bind%> clause not specified on a %<loop%> "
12315 "construct not nested inside another OpenMP construct");
12317 bind
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE_BIND
);
12318 OMP_CLAUSE_CHAIN (bind
) = clauses
;
12319 OMP_CLAUSE_BIND_KIND (bind
) = kind
;
12320 OMP_FOR_CLAUSES (for_stmt
) = bind
;
12323 switch (OMP_CLAUSE_BIND_KIND (bind
))
12325 case OMP_CLAUSE_BIND_THREAD
:
12327 case OMP_CLAUSE_BIND_PARALLEL
:
12328 if (!flag_openmp
) /* flag_openmp_simd */
12330 OMP_CLAUSE_BIND_KIND (bind
) = OMP_CLAUSE_BIND_THREAD
;
12333 for (; octx
; octx
= octx
->outer_context
)
12334 if (octx
->region_type
== ORT_SIMD
12335 && omp_find_clause (octx
->clauses
, OMP_CLAUSE_BIND
) == NULL_TREE
)
12337 error_at (EXPR_LOCATION (for_stmt
),
12338 "%<bind(parallel)%> on a %<loop%> construct nested "
12339 "inside %<simd%> construct");
12340 OMP_CLAUSE_BIND_KIND (bind
) = OMP_CLAUSE_BIND_THREAD
;
12343 kind
= OMP_CLAUSE_BIND_PARALLEL
;
12345 case OMP_CLAUSE_BIND_TEAMS
:
12346 if (!flag_openmp
) /* flag_openmp_simd */
12348 OMP_CLAUSE_BIND_KIND (bind
) = OMP_CLAUSE_BIND_THREAD
;
12352 && octx
->region_type
!= ORT_IMPLICIT_TARGET
12353 && octx
->region_type
!= ORT_NONE
12354 && (octx
->region_type
& ORT_TEAMS
) == 0)
12355 || in_omp_construct
)
12357 error_at (EXPR_LOCATION (for_stmt
),
12358 "%<bind(teams)%> on a %<loop%> region not strictly "
12359 "nested inside of a %<teams%> region");
12360 OMP_CLAUSE_BIND_KIND (bind
) = OMP_CLAUSE_BIND_THREAD
;
12363 kind
= OMP_CLAUSE_BIND_TEAMS
;
12366 gcc_unreachable ();
12369 for (tree
*pc
= &OMP_FOR_CLAUSES (for_stmt
); *pc
; )
12370 switch (OMP_CLAUSE_CODE (*pc
))
12372 case OMP_CLAUSE_REDUCTION
:
12373 if (OMP_CLAUSE_REDUCTION_INSCAN (*pc
))
12375 error_at (OMP_CLAUSE_LOCATION (*pc
),
12376 "%<inscan%> %<reduction%> clause on "
12377 "%qs construct", "loop");
12378 OMP_CLAUSE_REDUCTION_INSCAN (*pc
) = 0;
12380 if (OMP_CLAUSE_REDUCTION_TASK (*pc
))
12382 error_at (OMP_CLAUSE_LOCATION (*pc
),
12383 "invalid %<task%> reduction modifier on construct "
12384 "other than %<parallel%>, %<for%> or %<sections%>");
12385 OMP_CLAUSE_REDUCTION_TASK (*pc
) = 0;
12387 pc
= &OMP_CLAUSE_CHAIN (*pc
);
12389 case OMP_CLAUSE_LASTPRIVATE
:
12390 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
12392 tree t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
12393 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
12394 if (OMP_CLAUSE_DECL (*pc
) == TREE_OPERAND (t
, 0))
12396 if (OMP_FOR_ORIG_DECLS (for_stmt
)
12397 && TREE_CODE (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt
),
12399 && TREE_PURPOSE (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt
),
12402 tree orig
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt
), i
);
12403 if (OMP_CLAUSE_DECL (*pc
) == TREE_PURPOSE (orig
))
12407 if (i
== TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)))
12409 error_at (OMP_CLAUSE_LOCATION (*pc
),
12410 "%<lastprivate%> clause on a %<loop%> construct refers "
12411 "to a variable %qD which is not the loop iterator",
12412 OMP_CLAUSE_DECL (*pc
));
12413 *pc
= OMP_CLAUSE_CHAIN (*pc
);
12416 pc
= &OMP_CLAUSE_CHAIN (*pc
);
12419 pc
= &OMP_CLAUSE_CHAIN (*pc
);
12423 TREE_SET_CODE (for_stmt
, OMP_SIMD
);
12428 case OMP_CLAUSE_BIND_THREAD
: last
= 0; break;
12429 case OMP_CLAUSE_BIND_PARALLEL
: last
= 1; break;
12430 case OMP_CLAUSE_BIND_TEAMS
: last
= 2; break;
12432 for (int pass
= 1; pass
<= last
; pass
++)
12436 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
12437 append_to_statement_list (*expr_p
, &BIND_EXPR_BODY (bind
));
12438 *expr_p
= make_node (OMP_PARALLEL
);
12439 TREE_TYPE (*expr_p
) = void_type_node
;
12440 OMP_PARALLEL_BODY (*expr_p
) = bind
;
12441 OMP_PARALLEL_COMBINED (*expr_p
) = 1;
12442 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (for_stmt
));
12443 tree
*pc
= &OMP_PARALLEL_CLAUSES (*expr_p
);
12444 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
12445 if (OMP_FOR_ORIG_DECLS (for_stmt
)
12446 && (TREE_CODE (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt
), i
))
12449 tree elt
= TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt
), i
);
12450 if (TREE_PURPOSE (elt
) && TREE_VALUE (elt
))
12452 *pc
= build_omp_clause (UNKNOWN_LOCATION
,
12453 OMP_CLAUSE_FIRSTPRIVATE
);
12454 OMP_CLAUSE_DECL (*pc
) = TREE_VALUE (elt
);
12455 pc
= &OMP_CLAUSE_CHAIN (*pc
);
12459 tree t
= make_node (pass
== 2 ? OMP_DISTRIBUTE
: OMP_FOR
);
12460 tree
*pc
= &OMP_FOR_CLAUSES (t
);
12461 TREE_TYPE (t
) = void_type_node
;
12462 OMP_FOR_BODY (t
) = *expr_p
;
12463 SET_EXPR_LOCATION (t
, EXPR_LOCATION (for_stmt
));
12464 for (tree c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
12465 switch (OMP_CLAUSE_CODE (c
))
12467 case OMP_CLAUSE_BIND
:
12468 case OMP_CLAUSE_ORDER
:
12469 case OMP_CLAUSE_COLLAPSE
:
12470 *pc
= copy_node (c
);
12471 pc
= &OMP_CLAUSE_CHAIN (*pc
);
12473 case OMP_CLAUSE_PRIVATE
:
12474 case OMP_CLAUSE_FIRSTPRIVATE
:
12475 /* Only needed on innermost. */
12477 case OMP_CLAUSE_LASTPRIVATE
:
12478 if (OMP_CLAUSE_LASTPRIVATE_LOOP_IV (c
) && pass
!= last
)
12480 *pc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
12481 OMP_CLAUSE_FIRSTPRIVATE
);
12482 OMP_CLAUSE_DECL (*pc
) = OMP_CLAUSE_DECL (c
);
12483 lang_hooks
.decls
.omp_finish_clause (*pc
, NULL
);
12484 pc
= &OMP_CLAUSE_CHAIN (*pc
);
12486 *pc
= copy_node (c
);
12487 OMP_CLAUSE_LASTPRIVATE_STMT (*pc
) = NULL_TREE
;
12488 TREE_TYPE (*pc
) = unshare_expr (TREE_TYPE (c
));
12489 if (OMP_CLAUSE_LASTPRIVATE_LOOP_IV (c
))
12492 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (*pc
) = 1;
12494 lang_hooks
.decls
.omp_finish_clause (*pc
, NULL
);
12495 OMP_CLAUSE_LASTPRIVATE_LOOP_IV (*pc
) = 0;
12497 pc
= &OMP_CLAUSE_CHAIN (*pc
);
12499 case OMP_CLAUSE_REDUCTION
:
12500 *pc
= copy_node (c
);
12501 OMP_CLAUSE_DECL (*pc
) = unshare_expr (OMP_CLAUSE_DECL (c
));
12502 TREE_TYPE (*pc
) = unshare_expr (TREE_TYPE (c
));
12503 OMP_CLAUSE_REDUCTION_INIT (*pc
)
12504 = unshare_expr (OMP_CLAUSE_REDUCTION_INIT (c
));
12505 OMP_CLAUSE_REDUCTION_MERGE (*pc
)
12506 = unshare_expr (OMP_CLAUSE_REDUCTION_MERGE (c
));
12507 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (*pc
))
12509 OMP_CLAUSE_REDUCTION_PLACEHOLDER (*pc
)
12510 = copy_node (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
));
12511 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (*pc
))
12512 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (*pc
)
12513 = copy_node (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
));
12515 tree data
[2] = { c
, nc
};
12516 walk_tree_without_duplicates (&OMP_CLAUSE_REDUCTION_INIT (nc
),
12517 replace_reduction_placeholders
,
12519 walk_tree_without_duplicates (&OMP_CLAUSE_REDUCTION_MERGE (nc
),
12520 replace_reduction_placeholders
,
12523 pc
= &OMP_CLAUSE_CHAIN (*pc
);
12526 gcc_unreachable ();
12531 return gimplify_omp_for (expr_p
, pre_p
);
12535 /* Helper function of optimize_target_teams, find OMP_TEAMS inside
12536 of OMP_TARGET's body. */
12539 find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
12541 *walk_subtrees
= 0;
12542 switch (TREE_CODE (*tp
))
12547 case STATEMENT_LIST
:
12548 *walk_subtrees
= 1;
12556 /* Helper function of optimize_target_teams, determine if the expression
12557 can be computed safely before the target construct on the host. */
12560 computable_teams_clause (tree
*tp
, int *walk_subtrees
, void *)
12566 *walk_subtrees
= 0;
12569 switch (TREE_CODE (*tp
))
12574 *walk_subtrees
= 0;
12575 if (error_operand_p (*tp
)
12576 || !INTEGRAL_TYPE_P (TREE_TYPE (*tp
))
12577 || DECL_HAS_VALUE_EXPR_P (*tp
)
12578 || DECL_THREAD_LOCAL_P (*tp
)
12579 || TREE_SIDE_EFFECTS (*tp
)
12580 || TREE_THIS_VOLATILE (*tp
))
12582 if (is_global_var (*tp
)
12583 && (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (*tp
))
12584 || lookup_attribute ("omp declare target link",
12585 DECL_ATTRIBUTES (*tp
))))
12588 && !DECL_SEEN_IN_BIND_EXPR_P (*tp
)
12589 && !is_global_var (*tp
)
12590 && decl_function_context (*tp
) == current_function_decl
)
12592 n
= splay_tree_lookup (gimplify_omp_ctxp
->variables
,
12593 (splay_tree_key
) *tp
);
12596 if (gimplify_omp_ctxp
->defaultmap
[GDMK_SCALAR
] & GOVD_FIRSTPRIVATE
)
12600 else if (n
->value
& GOVD_LOCAL
)
12602 else if (n
->value
& GOVD_FIRSTPRIVATE
)
12604 else if ((n
->value
& (GOVD_MAP
| GOVD_MAP_ALWAYS_TO
))
12605 == (GOVD_MAP
| GOVD_MAP_ALWAYS_TO
))
12609 if (!INTEGRAL_TYPE_P (TREE_TYPE (*tp
)))
12613 if (TARGET_EXPR_INITIAL (*tp
)
12614 || TREE_CODE (TARGET_EXPR_SLOT (*tp
)) != VAR_DECL
)
12616 return computable_teams_clause (&TARGET_EXPR_SLOT (*tp
),
12617 walk_subtrees
, NULL
);
12618 /* Allow some reasonable subset of integral arithmetics. */
12622 case TRUNC_DIV_EXPR
:
12623 case CEIL_DIV_EXPR
:
12624 case FLOOR_DIV_EXPR
:
12625 case ROUND_DIV_EXPR
:
12626 case TRUNC_MOD_EXPR
:
12627 case CEIL_MOD_EXPR
:
12628 case FLOOR_MOD_EXPR
:
12629 case ROUND_MOD_EXPR
:
12631 case EXACT_DIV_EXPR
:
12642 case NON_LVALUE_EXPR
:
12644 if (!INTEGRAL_TYPE_P (TREE_TYPE (*tp
)))
12647 /* And disallow anything else, except for comparisons. */
12649 if (COMPARISON_CLASS_P (*tp
))
12655 /* Try to determine if the num_teams and/or thread_limit expressions
12656 can have their values determined already before entering the
12658 INTEGER_CSTs trivially are,
12659 integral decls that are firstprivate (explicitly or implicitly)
12660 or explicitly map(always, to:) or map(always, tofrom:) on the target
12661 region too, and expressions involving simple arithmetics on those
12662 too, function calls are not ok, dereferencing something neither etc.
12663 Add NUM_TEAMS and THREAD_LIMIT clauses to the OMP_CLAUSES of
12664 EXPR based on what we find:
12665 0 stands for clause not specified at all, use implementation default
12666 -1 stands for value that can't be determined easily before entering
12667 the target construct.
12668 If teams construct is not present at all, use 1 for num_teams
12669 and 0 for thread_limit (only one team is involved, and the thread
12670 limit is implementation defined. */
12673 optimize_target_teams (tree target
, gimple_seq
*pre_p
)
12675 tree body
= OMP_BODY (target
);
12676 tree teams
= walk_tree (&body
, find_omp_teams
, NULL
, NULL
);
12677 tree num_teams
= integer_zero_node
;
12678 tree thread_limit
= integer_zero_node
;
12679 location_t num_teams_loc
= EXPR_LOCATION (target
);
12680 location_t thread_limit_loc
= EXPR_LOCATION (target
);
12682 struct gimplify_omp_ctx
*target_ctx
= gimplify_omp_ctxp
;
12684 if (teams
== NULL_TREE
)
12685 num_teams
= integer_one_node
;
12687 for (c
= OMP_TEAMS_CLAUSES (teams
); c
; c
= OMP_CLAUSE_CHAIN (c
))
12689 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
)
12692 num_teams_loc
= OMP_CLAUSE_LOCATION (c
);
12694 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
12697 thread_limit_loc
= OMP_CLAUSE_LOCATION (c
);
12701 expr
= OMP_CLAUSE_OPERAND (c
, 0);
12702 if (TREE_CODE (expr
) == INTEGER_CST
)
12707 if (walk_tree (&expr
, computable_teams_clause
, NULL
, NULL
))
12709 *p
= integer_minus_one_node
;
12713 gimplify_omp_ctxp
= gimplify_omp_ctxp
->outer_context
;
12714 if (gimplify_expr (p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
, false)
12717 gimplify_omp_ctxp
= target_ctx
;
12718 *p
= integer_minus_one_node
;
12721 gimplify_omp_ctxp
= target_ctx
;
12722 if (!DECL_P (expr
) && TREE_CODE (expr
) != TARGET_EXPR
)
12723 OMP_CLAUSE_OPERAND (c
, 0) = *p
;
12725 c
= build_omp_clause (thread_limit_loc
, OMP_CLAUSE_THREAD_LIMIT
);
12726 OMP_CLAUSE_THREAD_LIMIT_EXPR (c
) = thread_limit
;
12727 OMP_CLAUSE_CHAIN (c
) = OMP_TARGET_CLAUSES (target
);
12728 OMP_TARGET_CLAUSES (target
) = c
;
12729 c
= build_omp_clause (num_teams_loc
, OMP_CLAUSE_NUM_TEAMS
);
12730 OMP_CLAUSE_NUM_TEAMS_EXPR (c
) = num_teams
;
12731 OMP_CLAUSE_CHAIN (c
) = OMP_TARGET_CLAUSES (target
);
12732 OMP_TARGET_CLAUSES (target
) = c
;
12735 /* Gimplify the gross structure of several OMP constructs. */
12738 gimplify_omp_workshare (tree
*expr_p
, gimple_seq
*pre_p
)
12740 tree expr
= *expr_p
;
12742 gimple_seq body
= NULL
;
12743 enum omp_region_type ort
;
12745 switch (TREE_CODE (expr
))
12749 ort
= ORT_WORKSHARE
;
12752 ort
= OMP_TARGET_COMBINED (expr
) ? ORT_COMBINED_TARGET
: ORT_TARGET
;
12755 ort
= ORT_ACC_KERNELS
;
12757 case OACC_PARALLEL
:
12758 ort
= ORT_ACC_PARALLEL
;
12761 ort
= ORT_ACC_SERIAL
;
12764 ort
= ORT_ACC_DATA
;
12766 case OMP_TARGET_DATA
:
12767 ort
= ORT_TARGET_DATA
;
12770 ort
= OMP_TEAMS_COMBINED (expr
) ? ORT_COMBINED_TEAMS
: ORT_TEAMS
;
12771 if (gimplify_omp_ctxp
== NULL
12772 || gimplify_omp_ctxp
->region_type
== ORT_IMPLICIT_TARGET
)
12773 ort
= (enum omp_region_type
) (ort
| ORT_HOST_TEAMS
);
12775 case OACC_HOST_DATA
:
12776 ort
= ORT_ACC_HOST_DATA
;
12779 gcc_unreachable ();
12782 bool save_in_omp_construct
= in_omp_construct
;
12783 if ((ort
& ORT_ACC
) == 0)
12784 in_omp_construct
= false;
12785 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr
), pre_p
, ort
,
12787 if (TREE_CODE (expr
) == OMP_TARGET
)
12788 optimize_target_teams (expr
, pre_p
);
12789 if ((ort
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0
12790 || (ort
& ORT_HOST_TEAMS
) == ORT_HOST_TEAMS
)
12792 push_gimplify_context ();
12793 gimple
*g
= gimplify_and_return_first (OMP_BODY (expr
), &body
);
12794 if (gimple_code (g
) == GIMPLE_BIND
)
12795 pop_gimplify_context (g
);
12797 pop_gimplify_context (NULL
);
12798 if ((ort
& ORT_TARGET_DATA
) != 0)
12800 enum built_in_function end_ix
;
12801 switch (TREE_CODE (expr
))
12804 case OACC_HOST_DATA
:
12805 end_ix
= BUILT_IN_GOACC_DATA_END
;
12807 case OMP_TARGET_DATA
:
12808 end_ix
= BUILT_IN_GOMP_TARGET_END_DATA
;
12811 gcc_unreachable ();
12813 tree fn
= builtin_decl_explicit (end_ix
);
12814 g
= gimple_build_call (fn
, 0);
12815 gimple_seq cleanup
= NULL
;
12816 gimple_seq_add_stmt (&cleanup
, g
);
12817 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
12819 gimple_seq_add_stmt (&body
, g
);
12823 gimplify_and_add (OMP_BODY (expr
), &body
);
12824 gimplify_adjust_omp_clauses (pre_p
, body
, &OMP_CLAUSES (expr
),
12826 in_omp_construct
= save_in_omp_construct
;
12828 switch (TREE_CODE (expr
))
12831 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_DATA
,
12832 OMP_CLAUSES (expr
));
12834 case OACC_HOST_DATA
:
12835 if (omp_find_clause (OMP_CLAUSES (expr
), OMP_CLAUSE_IF_PRESENT
))
12837 for (tree c
= OMP_CLAUSES (expr
); c
; c
= OMP_CLAUSE_CHAIN (c
))
12838 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_USE_DEVICE_PTR
)
12839 OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT (c
) = 1;
12842 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_HOST_DATA
,
12843 OMP_CLAUSES (expr
));
12846 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_KERNELS
,
12847 OMP_CLAUSES (expr
));
12849 case OACC_PARALLEL
:
12850 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_PARALLEL
,
12851 OMP_CLAUSES (expr
));
12854 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_SERIAL
,
12855 OMP_CLAUSES (expr
));
12858 stmt
= gimple_build_omp_sections (body
, OMP_CLAUSES (expr
));
12861 stmt
= gimple_build_omp_single (body
, OMP_CLAUSES (expr
));
12864 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_REGION
,
12865 OMP_CLAUSES (expr
));
12867 case OMP_TARGET_DATA
:
12868 /* Put use_device_{ptr,addr} clauses last, as map clauses are supposed
12869 to be evaluated before the use_device_{ptr,addr} clauses if they
12870 refer to the same variables. */
12872 tree use_device_clauses
;
12873 tree
*pc
, *uc
= &use_device_clauses
;
12874 for (pc
= &OMP_CLAUSES (expr
); *pc
; )
12875 if (OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_USE_DEVICE_PTR
12876 || OMP_CLAUSE_CODE (*pc
) == OMP_CLAUSE_USE_DEVICE_ADDR
)
12879 *pc
= OMP_CLAUSE_CHAIN (*pc
);
12880 uc
= &OMP_CLAUSE_CHAIN (*uc
);
12883 pc
= &OMP_CLAUSE_CHAIN (*pc
);
12885 *pc
= use_device_clauses
;
12886 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_DATA
,
12887 OMP_CLAUSES (expr
));
12891 stmt
= gimple_build_omp_teams (body
, OMP_CLAUSES (expr
));
12892 if ((ort
& ORT_HOST_TEAMS
) == ORT_HOST_TEAMS
)
12893 gimple_omp_teams_set_host (as_a
<gomp_teams
*> (stmt
), true);
12896 gcc_unreachable ();
12899 gimplify_seq_add_stmt (pre_p
, stmt
);
12900 *expr_p
= NULL_TREE
;
12903 /* Gimplify the gross structure of OpenACC enter/exit data, update, and OpenMP
12904 target update constructs. */
12907 gimplify_omp_target_update (tree
*expr_p
, gimple_seq
*pre_p
)
12909 tree expr
= *expr_p
;
12912 enum omp_region_type ort
= ORT_WORKSHARE
;
12914 switch (TREE_CODE (expr
))
12916 case OACC_ENTER_DATA
:
12917 case OACC_EXIT_DATA
:
12918 kind
= GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
;
12922 kind
= GF_OMP_TARGET_KIND_OACC_UPDATE
;
12925 case OMP_TARGET_UPDATE
:
12926 kind
= GF_OMP_TARGET_KIND_UPDATE
;
12928 case OMP_TARGET_ENTER_DATA
:
12929 kind
= GF_OMP_TARGET_KIND_ENTER_DATA
;
12931 case OMP_TARGET_EXIT_DATA
:
12932 kind
= GF_OMP_TARGET_KIND_EXIT_DATA
;
12935 gcc_unreachable ();
12937 gimplify_scan_omp_clauses (&OMP_STANDALONE_CLAUSES (expr
), pre_p
,
12938 ort
, TREE_CODE (expr
));
12939 gimplify_adjust_omp_clauses (pre_p
, NULL
, &OMP_STANDALONE_CLAUSES (expr
),
12941 if (TREE_CODE (expr
) == OACC_UPDATE
12942 && omp_find_clause (OMP_STANDALONE_CLAUSES (expr
),
12943 OMP_CLAUSE_IF_PRESENT
))
12945 /* The runtime uses GOMP_MAP_{TO,FROM} to denote the if_present
12947 for (tree c
= OMP_STANDALONE_CLAUSES (expr
); c
; c
= OMP_CLAUSE_CHAIN (c
))
12948 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
)
12949 switch (OMP_CLAUSE_MAP_KIND (c
))
12951 case GOMP_MAP_FORCE_TO
:
12952 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_TO
);
12954 case GOMP_MAP_FORCE_FROM
:
12955 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_FROM
);
12961 else if (TREE_CODE (expr
) == OACC_EXIT_DATA
12962 && omp_find_clause (OMP_STANDALONE_CLAUSES (expr
),
12963 OMP_CLAUSE_FINALIZE
))
12965 /* Use GOMP_MAP_DELETE/GOMP_MAP_FORCE_FROM to denote "finalize"
12967 bool have_clause
= false;
12968 for (tree c
= OMP_STANDALONE_CLAUSES (expr
); c
; c
= OMP_CLAUSE_CHAIN (c
))
12969 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
)
12970 switch (OMP_CLAUSE_MAP_KIND (c
))
12972 case GOMP_MAP_FROM
:
12973 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_FORCE_FROM
);
12974 have_clause
= true;
12976 case GOMP_MAP_RELEASE
:
12977 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_DELETE
);
12978 have_clause
= true;
12980 case GOMP_MAP_POINTER
:
12981 case GOMP_MAP_TO_PSET
:
12982 /* TODO PR92929: we may see these here, but they'll always follow
12983 one of the clauses above, and will be handled by libgomp as
12984 one group, so no handling required here. */
12985 gcc_assert (have_clause
);
12987 case GOMP_MAP_DETACH
:
12988 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_FORCE_DETACH
);
12989 have_clause
= false;
12991 case GOMP_MAP_STRUCT
:
12992 have_clause
= false;
12995 gcc_unreachable ();
12998 stmt
= gimple_build_omp_target (NULL
, kind
, OMP_STANDALONE_CLAUSES (expr
));
13000 gimplify_seq_add_stmt (pre_p
, stmt
);
13001 *expr_p
= NULL_TREE
;
13004 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
13005 stabilized the lhs of the atomic operation as *ADDR. Return true if
13006 EXPR is this stabilized form. */
13009 goa_lhs_expr_p (tree expr
, tree addr
)
13011 /* Also include casts to other type variants. The C front end is fond
13012 of adding these for e.g. volatile variables. This is like
13013 STRIP_TYPE_NOPS but includes the main variant lookup. */
13014 STRIP_USELESS_TYPE_CONVERSION (expr
);
13016 if (TREE_CODE (expr
) == INDIRECT_REF
)
13018 expr
= TREE_OPERAND (expr
, 0);
13019 while (expr
!= addr
13020 && (CONVERT_EXPR_P (expr
)
13021 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
13022 && TREE_CODE (expr
) == TREE_CODE (addr
)
13023 && types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (addr
)))
13025 expr
= TREE_OPERAND (expr
, 0);
13026 addr
= TREE_OPERAND (addr
, 0);
13030 return (TREE_CODE (addr
) == ADDR_EXPR
13031 && TREE_CODE (expr
) == ADDR_EXPR
13032 && TREE_OPERAND (addr
, 0) == TREE_OPERAND (expr
, 0));
13034 if (TREE_CODE (addr
) == ADDR_EXPR
&& expr
== TREE_OPERAND (addr
, 0))
13039 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
13040 expression does not involve the lhs, evaluate it into a temporary.
13041 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
13042 or -1 if an error was encountered. */
13045 goa_stabilize_expr (tree
*expr_p
, gimple_seq
*pre_p
, tree lhs_addr
,
13048 tree expr
= *expr_p
;
13051 if (goa_lhs_expr_p (expr
, lhs_addr
))
13056 if (is_gimple_val (expr
))
13060 switch (TREE_CODE_CLASS (TREE_CODE (expr
)))
13063 case tcc_comparison
:
13064 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
, lhs_addr
,
13068 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
, lhs_addr
,
13071 case tcc_expression
:
13072 switch (TREE_CODE (expr
))
13074 case TRUTH_ANDIF_EXPR
:
13075 case TRUTH_ORIF_EXPR
:
13076 case TRUTH_AND_EXPR
:
13077 case TRUTH_OR_EXPR
:
13078 case TRUTH_XOR_EXPR
:
13079 case BIT_INSERT_EXPR
:
13080 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
,
13081 lhs_addr
, lhs_var
);
13083 case TRUTH_NOT_EXPR
:
13084 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
13085 lhs_addr
, lhs_var
);
13087 case COMPOUND_EXPR
:
13088 /* Break out any preevaluations from cp_build_modify_expr. */
13089 for (; TREE_CODE (expr
) == COMPOUND_EXPR
;
13090 expr
= TREE_OPERAND (expr
, 1))
13091 gimplify_stmt (&TREE_OPERAND (expr
, 0), pre_p
);
13093 return goa_stabilize_expr (expr_p
, pre_p
, lhs_addr
, lhs_var
);
13098 case tcc_reference
:
13099 if (TREE_CODE (expr
) == BIT_FIELD_REF
)
13100 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
13101 lhs_addr
, lhs_var
);
13109 enum gimplify_status gs
;
13110 gs
= gimplify_expr (expr_p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
13111 if (gs
!= GS_ALL_DONE
)
13118 /* Gimplify an OMP_ATOMIC statement. */
13120 static enum gimplify_status
13121 gimplify_omp_atomic (tree
*expr_p
, gimple_seq
*pre_p
)
13123 tree addr
= TREE_OPERAND (*expr_p
, 0);
13124 tree rhs
= TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
13125 ? NULL
: TREE_OPERAND (*expr_p
, 1);
13126 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
13128 gomp_atomic_load
*loadstmt
;
13129 gomp_atomic_store
*storestmt
;
13131 tmp_load
= create_tmp_reg (type
);
13132 if (rhs
&& goa_stabilize_expr (&rhs
, pre_p
, addr
, tmp_load
) < 0)
13135 if (gimplify_expr (&addr
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
13139 loadstmt
= gimple_build_omp_atomic_load (tmp_load
, addr
,
13140 OMP_ATOMIC_MEMORY_ORDER (*expr_p
));
13141 gimplify_seq_add_stmt (pre_p
, loadstmt
);
13144 /* BIT_INSERT_EXPR is not valid for non-integral bitfield
13145 representatives. Use BIT_FIELD_REF on the lhs instead. */
13146 if (TREE_CODE (rhs
) == BIT_INSERT_EXPR
13147 && !INTEGRAL_TYPE_P (TREE_TYPE (tmp_load
)))
13149 tree bitpos
= TREE_OPERAND (rhs
, 2);
13150 tree op1
= TREE_OPERAND (rhs
, 1);
13152 tree tmp_store
= tmp_load
;
13153 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_CAPTURE_OLD
)
13154 tmp_store
= get_initialized_tmp_var (tmp_load
, pre_p
);
13155 if (INTEGRAL_TYPE_P (TREE_TYPE (op1
)))
13156 bitsize
= bitsize_int (TYPE_PRECISION (TREE_TYPE (op1
)));
13158 bitsize
= TYPE_SIZE (TREE_TYPE (op1
));
13159 gcc_assert (TREE_OPERAND (rhs
, 0) == tmp_load
);
13160 tree t
= build2_loc (EXPR_LOCATION (rhs
),
13161 MODIFY_EXPR
, void_type_node
,
13162 build3_loc (EXPR_LOCATION (rhs
), BIT_FIELD_REF
,
13163 TREE_TYPE (op1
), tmp_store
, bitsize
,
13165 gimplify_and_add (t
, pre_p
);
13168 if (gimplify_expr (&rhs
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
13173 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
)
13176 = gimple_build_omp_atomic_store (rhs
, OMP_ATOMIC_MEMORY_ORDER (*expr_p
));
13177 gimplify_seq_add_stmt (pre_p
, storestmt
);
13178 switch (TREE_CODE (*expr_p
))
13180 case OMP_ATOMIC_READ
:
13181 case OMP_ATOMIC_CAPTURE_OLD
:
13182 *expr_p
= tmp_load
;
13183 gimple_omp_atomic_set_need_value (loadstmt
);
13185 case OMP_ATOMIC_CAPTURE_NEW
:
13187 gimple_omp_atomic_set_need_value (storestmt
);
13194 return GS_ALL_DONE
;
13197 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
13198 body, and adding some EH bits. */
13200 static enum gimplify_status
13201 gimplify_transaction (tree
*expr_p
, gimple_seq
*pre_p
)
13203 tree expr
= *expr_p
, temp
, tbody
= TRANSACTION_EXPR_BODY (expr
);
13205 gtransaction
*trans_stmt
;
13206 gimple_seq body
= NULL
;
13209 /* Wrap the transaction body in a BIND_EXPR so we have a context
13210 where to put decls for OMP. */
13211 if (TREE_CODE (tbody
) != BIND_EXPR
)
13213 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, tbody
, NULL
);
13214 TREE_SIDE_EFFECTS (bind
) = 1;
13215 SET_EXPR_LOCATION (bind
, EXPR_LOCATION (tbody
));
13216 TRANSACTION_EXPR_BODY (expr
) = bind
;
13219 push_gimplify_context ();
13220 temp
= voidify_wrapper_expr (*expr_p
, NULL
);
13222 body_stmt
= gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr
), &body
);
13223 pop_gimplify_context (body_stmt
);
13225 trans_stmt
= gimple_build_transaction (body
);
13226 if (TRANSACTION_EXPR_OUTER (expr
))
13227 subcode
= GTMA_IS_OUTER
;
13228 else if (TRANSACTION_EXPR_RELAXED (expr
))
13229 subcode
= GTMA_IS_RELAXED
;
13230 gimple_transaction_set_subcode (trans_stmt
, subcode
);
13232 gimplify_seq_add_stmt (pre_p
, trans_stmt
);
13240 *expr_p
= NULL_TREE
;
13241 return GS_ALL_DONE
;
13244 /* Gimplify an OMP_ORDERED construct. EXPR is the tree version. BODY
13245 is the OMP_BODY of the original EXPR (which has already been
13246 gimplified so it's not present in the EXPR).
13248 Return the gimplified GIMPLE_OMP_ORDERED tuple. */
13251 gimplify_omp_ordered (tree expr
, gimple_seq body
)
13256 tree source_c
= NULL_TREE
;
13257 tree sink_c
= NULL_TREE
;
13259 if (gimplify_omp_ctxp
)
13261 for (c
= OMP_ORDERED_CLAUSES (expr
); c
; c
= OMP_CLAUSE_CHAIN (c
))
13262 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
13263 && gimplify_omp_ctxp
->loop_iter_var
.is_empty ()
13264 && (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
13265 || OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SOURCE
))
13267 error_at (OMP_CLAUSE_LOCATION (c
),
13268 "%<ordered%> construct with %<depend%> clause must be "
13269 "closely nested inside a loop with %<ordered%> clause "
13270 "with a parameter");
13273 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
13274 && OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
)
13277 for (decls
= OMP_CLAUSE_DECL (c
), i
= 0;
13278 decls
&& TREE_CODE (decls
) == TREE_LIST
;
13279 decls
= TREE_CHAIN (decls
), ++i
)
13280 if (i
>= gimplify_omp_ctxp
->loop_iter_var
.length () / 2)
13282 else if (TREE_VALUE (decls
)
13283 != gimplify_omp_ctxp
->loop_iter_var
[2 * i
])
13285 error_at (OMP_CLAUSE_LOCATION (c
),
13286 "variable %qE is not an iteration "
13287 "of outermost loop %d, expected %qE",
13288 TREE_VALUE (decls
), i
+ 1,
13289 gimplify_omp_ctxp
->loop_iter_var
[2 * i
]);
13295 = gimplify_omp_ctxp
->loop_iter_var
[2 * i
+ 1];
13296 if (!fail
&& i
!= gimplify_omp_ctxp
->loop_iter_var
.length () / 2)
13298 error_at (OMP_CLAUSE_LOCATION (c
),
13299 "number of variables in %<depend%> clause with "
13300 "%<sink%> modifier does not match number of "
13301 "iteration variables");
13306 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
13307 && OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SOURCE
)
13311 error_at (OMP_CLAUSE_LOCATION (c
),
13312 "more than one %<depend%> clause with %<source%> "
13313 "modifier on an %<ordered%> construct");
13320 if (source_c
&& sink_c
)
13322 error_at (OMP_CLAUSE_LOCATION (source_c
),
13323 "%<depend%> clause with %<source%> modifier specified "
13324 "together with %<depend%> clauses with %<sink%> modifier "
13325 "on the same construct");
13330 return gimple_build_nop ();
13331 return gimple_build_omp_ordered (body
, OMP_ORDERED_CLAUSES (expr
));
13334 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
13335 expression produces a value to be used as an operand inside a GIMPLE
13336 statement, the value will be stored back in *EXPR_P. This value will
13337 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
13338 an SSA_NAME. The corresponding sequence of GIMPLE statements is
13339 emitted in PRE_P and POST_P.
13341 Additionally, this process may overwrite parts of the input
13342 expression during gimplification. Ideally, it should be
13343 possible to do non-destructive gimplification.
13345 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
13346 the expression needs to evaluate to a value to be used as
13347 an operand in a GIMPLE statement, this value will be stored in
13348 *EXPR_P on exit. This happens when the caller specifies one
13349 of fb_lvalue or fb_rvalue fallback flags.
13351 PRE_P will contain the sequence of GIMPLE statements corresponding
13352 to the evaluation of EXPR and all the side-effects that must
13353 be executed before the main expression. On exit, the last
13354 statement of PRE_P is the core statement being gimplified. For
13355 instance, when gimplifying 'if (++a)' the last statement in
13356 PRE_P will be 'if (t.1)' where t.1 is the result of
13357 pre-incrementing 'a'.
13359 POST_P will contain the sequence of GIMPLE statements corresponding
13360 to the evaluation of all the side-effects that must be executed
13361 after the main expression. If this is NULL, the post
13362 side-effects are stored at the end of PRE_P.
13364 The reason why the output is split in two is to handle post
13365 side-effects explicitly. In some cases, an expression may have
13366 inner and outer post side-effects which need to be emitted in
13367 an order different from the one given by the recursive
13368 traversal. For instance, for the expression (*p--)++ the post
13369 side-effects of '--' must actually occur *after* the post
13370 side-effects of '++'. However, gimplification will first visit
13371 the inner expression, so if a separate POST sequence was not
13372 used, the resulting sequence would be:
13379 However, the post-decrement operation in line #2 must not be
13380 evaluated until after the store to *p at line #4, so the
13381 correct sequence should be:
13388 So, by specifying a separate post queue, it is possible
13389 to emit the post side-effects in the correct order.
13390 If POST_P is NULL, an internal queue will be used. Before
13391 returning to the caller, the sequence POST_P is appended to
13392 the main output sequence PRE_P.
13394 GIMPLE_TEST_F points to a function that takes a tree T and
13395 returns nonzero if T is in the GIMPLE form requested by the
13396 caller. The GIMPLE predicates are in gimple.c.
13398 FALLBACK tells the function what sort of a temporary we want if
13399 gimplification cannot produce an expression that complies with
13402 fb_none means that no temporary should be generated
13403 fb_rvalue means that an rvalue is OK to generate
13404 fb_lvalue means that an lvalue is OK to generate
13405 fb_either means that either is OK, but an lvalue is preferable.
13406 fb_mayfail means that gimplification may fail (in which case
13407 GS_ERROR will be returned)
13409 The return value is either GS_ERROR or GS_ALL_DONE, since this
13410 function iterates until EXPR is completely gimplified or an error
13413 enum gimplify_status
13414 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
13415 bool (*gimple_test_f
) (tree
), fallback_t fallback
)
13418 gimple_seq internal_pre
= NULL
;
13419 gimple_seq internal_post
= NULL
;
13422 location_t saved_location
;
13423 enum gimplify_status ret
;
13424 gimple_stmt_iterator pre_last_gsi
, post_last_gsi
;
13427 save_expr
= *expr_p
;
13428 if (save_expr
== NULL_TREE
)
13429 return GS_ALL_DONE
;
13431 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
13432 is_statement
= gimple_test_f
== is_gimple_stmt
;
13434 gcc_assert (pre_p
);
13436 /* Consistency checks. */
13437 if (gimple_test_f
== is_gimple_reg
)
13438 gcc_assert (fallback
& (fb_rvalue
| fb_lvalue
));
13439 else if (gimple_test_f
== is_gimple_val
13440 || gimple_test_f
== is_gimple_call_addr
13441 || gimple_test_f
== is_gimple_condexpr
13442 || gimple_test_f
== is_gimple_condexpr_for_cond
13443 || gimple_test_f
== is_gimple_mem_rhs
13444 || gimple_test_f
== is_gimple_mem_rhs_or_call
13445 || gimple_test_f
== is_gimple_reg_rhs
13446 || gimple_test_f
== is_gimple_reg_rhs_or_call
13447 || gimple_test_f
== is_gimple_asm_val
13448 || gimple_test_f
== is_gimple_mem_ref_addr
)
13449 gcc_assert (fallback
& fb_rvalue
);
13450 else if (gimple_test_f
== is_gimple_min_lval
13451 || gimple_test_f
== is_gimple_lvalue
)
13452 gcc_assert (fallback
& fb_lvalue
);
13453 else if (gimple_test_f
== is_gimple_addressable
)
13454 gcc_assert (fallback
& fb_either
);
13455 else if (gimple_test_f
== is_gimple_stmt
)
13456 gcc_assert (fallback
== fb_none
);
13459 /* We should have recognized the GIMPLE_TEST_F predicate to
13460 know what kind of fallback to use in case a temporary is
13461 needed to hold the value or address of *EXPR_P. */
13462 gcc_unreachable ();
13465 /* We used to check the predicate here and return immediately if it
13466 succeeds. This is wrong; the design is for gimplification to be
13467 idempotent, and for the predicates to only test for valid forms, not
13468 whether they are fully simplified. */
13470 pre_p
= &internal_pre
;
13472 if (post_p
== NULL
)
13473 post_p
= &internal_post
;
13475 /* Remember the last statements added to PRE_P and POST_P. Every
13476 new statement added by the gimplification helpers needs to be
13477 annotated with location information. To centralize the
13478 responsibility, we remember the last statement that had been
13479 added to both queues before gimplifying *EXPR_P. If
13480 gimplification produces new statements in PRE_P and POST_P, those
13481 statements will be annotated with the same location information
13483 pre_last_gsi
= gsi_last (*pre_p
);
13484 post_last_gsi
= gsi_last (*post_p
);
13486 saved_location
= input_location
;
13487 if (save_expr
!= error_mark_node
13488 && EXPR_HAS_LOCATION (*expr_p
))
13489 input_location
= EXPR_LOCATION (*expr_p
);
13491 /* Loop over the specific gimplifiers until the toplevel node
13492 remains the same. */
13495 /* Strip away as many useless type conversions as possible
13496 at the toplevel. */
13497 STRIP_USELESS_TYPE_CONVERSION (*expr_p
);
13499 /* Remember the expr. */
13500 save_expr
= *expr_p
;
13502 /* Die, die, die, my darling. */
13503 if (error_operand_p (save_expr
))
13509 /* Do any language-specific gimplification. */
13510 ret
= ((enum gimplify_status
)
13511 lang_hooks
.gimplify_expr (expr_p
, pre_p
, post_p
));
13514 if (*expr_p
== NULL_TREE
)
13516 if (*expr_p
!= save_expr
)
13519 else if (ret
!= GS_UNHANDLED
)
13522 /* Make sure that all the cases set 'ret' appropriately. */
13523 ret
= GS_UNHANDLED
;
13524 switch (TREE_CODE (*expr_p
))
13526 /* First deal with the special cases. */
13528 case POSTINCREMENT_EXPR
:
13529 case POSTDECREMENT_EXPR
:
13530 case PREINCREMENT_EXPR
:
13531 case PREDECREMENT_EXPR
:
13532 ret
= gimplify_self_mod_expr (expr_p
, pre_p
, post_p
,
13533 fallback
!= fb_none
,
13534 TREE_TYPE (*expr_p
));
13537 case VIEW_CONVERT_EXPR
:
13538 if ((fallback
& fb_rvalue
)
13539 && is_gimple_reg_type (TREE_TYPE (*expr_p
))
13540 && is_gimple_reg_type (TREE_TYPE (TREE_OPERAND (*expr_p
, 0))))
13542 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
13543 post_p
, is_gimple_val
, fb_rvalue
);
13544 recalculate_side_effects (*expr_p
);
13550 case ARRAY_RANGE_REF
:
13551 case REALPART_EXPR
:
13552 case IMAGPART_EXPR
:
13553 case COMPONENT_REF
:
13554 ret
= gimplify_compound_lval (expr_p
, pre_p
, post_p
,
13555 fallback
? fallback
: fb_rvalue
);
13559 ret
= gimplify_cond_expr (expr_p
, pre_p
, fallback
);
13561 /* C99 code may assign to an array in a structure value of a
13562 conditional expression, and this has undefined behavior
13563 only on execution, so create a temporary if an lvalue is
13565 if (fallback
== fb_lvalue
)
13567 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
, false);
13568 mark_addressable (*expr_p
);
13574 ret
= gimplify_call_expr (expr_p
, pre_p
, fallback
!= fb_none
);
13576 /* C99 code may assign to an array in a structure returned
13577 from a function, and this has undefined behavior only on
13578 execution, so create a temporary if an lvalue is
13580 if (fallback
== fb_lvalue
)
13582 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
, false);
13583 mark_addressable (*expr_p
);
13589 gcc_unreachable ();
13591 case COMPOUND_EXPR
:
13592 ret
= gimplify_compound_expr (expr_p
, pre_p
, fallback
!= fb_none
);
13595 case COMPOUND_LITERAL_EXPR
:
13596 ret
= gimplify_compound_literal_expr (expr_p
, pre_p
,
13597 gimple_test_f
, fallback
);
13602 ret
= gimplify_modify_expr (expr_p
, pre_p
, post_p
,
13603 fallback
!= fb_none
);
13606 case TRUTH_ANDIF_EXPR
:
13607 case TRUTH_ORIF_EXPR
:
13609 /* Preserve the original type of the expression and the
13610 source location of the outer expression. */
13611 tree org_type
= TREE_TYPE (*expr_p
);
13612 *expr_p
= gimple_boolify (*expr_p
);
13613 *expr_p
= build3_loc (input_location
, COND_EXPR
,
13617 org_type
, boolean_true_node
),
13620 org_type
, boolean_false_node
));
13625 case TRUTH_NOT_EXPR
:
13627 tree type
= TREE_TYPE (*expr_p
);
13628 /* The parsers are careful to generate TRUTH_NOT_EXPR
13629 only with operands that are always zero or one.
13630 We do not fold here but handle the only interesting case
13631 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
13632 *expr_p
= gimple_boolify (*expr_p
);
13633 if (TYPE_PRECISION (TREE_TYPE (*expr_p
)) == 1)
13634 *expr_p
= build1_loc (input_location
, BIT_NOT_EXPR
,
13635 TREE_TYPE (*expr_p
),
13636 TREE_OPERAND (*expr_p
, 0));
13638 *expr_p
= build2_loc (input_location
, BIT_XOR_EXPR
,
13639 TREE_TYPE (*expr_p
),
13640 TREE_OPERAND (*expr_p
, 0),
13641 build_int_cst (TREE_TYPE (*expr_p
), 1));
13642 if (!useless_type_conversion_p (type
, TREE_TYPE (*expr_p
)))
13643 *expr_p
= fold_convert_loc (input_location
, type
, *expr_p
);
13649 ret
= gimplify_addr_expr (expr_p
, pre_p
, post_p
);
13652 case ANNOTATE_EXPR
:
13654 tree cond
= TREE_OPERAND (*expr_p
, 0);
13655 tree kind
= TREE_OPERAND (*expr_p
, 1);
13656 tree data
= TREE_OPERAND (*expr_p
, 2);
13657 tree type
= TREE_TYPE (cond
);
13658 if (!INTEGRAL_TYPE_P (type
))
13664 tree tmp
= create_tmp_var (type
);
13665 gimplify_arg (&cond
, pre_p
, EXPR_LOCATION (*expr_p
));
13667 = gimple_build_call_internal (IFN_ANNOTATE
, 3, cond
, kind
, data
);
13668 gimple_call_set_lhs (call
, tmp
);
13669 gimplify_seq_add_stmt (pre_p
, call
);
13676 ret
= gimplify_va_arg_expr (expr_p
, pre_p
, post_p
);
13680 if (IS_EMPTY_STMT (*expr_p
))
13686 if (VOID_TYPE_P (TREE_TYPE (*expr_p
))
13687 || fallback
== fb_none
)
13689 /* Just strip a conversion to void (or in void context) and
13691 *expr_p
= TREE_OPERAND (*expr_p
, 0);
13696 ret
= gimplify_conversion (expr_p
);
13697 if (ret
== GS_ERROR
)
13699 if (*expr_p
!= save_expr
)
13703 case FIX_TRUNC_EXPR
:
13704 /* unary_expr: ... | '(' cast ')' val | ... */
13705 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
13706 is_gimple_val
, fb_rvalue
);
13707 recalculate_side_effects (*expr_p
);
13712 bool volatilep
= TREE_THIS_VOLATILE (*expr_p
);
13713 bool notrap
= TREE_THIS_NOTRAP (*expr_p
);
13714 tree saved_ptr_type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 0));
13716 *expr_p
= fold_indirect_ref_loc (input_location
, *expr_p
);
13717 if (*expr_p
!= save_expr
)
13723 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
13724 is_gimple_reg
, fb_rvalue
);
13725 if (ret
== GS_ERROR
)
13728 recalculate_side_effects (*expr_p
);
13729 *expr_p
= fold_build2_loc (input_location
, MEM_REF
,
13730 TREE_TYPE (*expr_p
),
13731 TREE_OPERAND (*expr_p
, 0),
13732 build_int_cst (saved_ptr_type
, 0));
13733 TREE_THIS_VOLATILE (*expr_p
) = volatilep
;
13734 TREE_THIS_NOTRAP (*expr_p
) = notrap
;
13739 /* We arrive here through the various re-gimplifcation paths. */
13741 /* First try re-folding the whole thing. */
13742 tmp
= fold_binary (MEM_REF
, TREE_TYPE (*expr_p
),
13743 TREE_OPERAND (*expr_p
, 0),
13744 TREE_OPERAND (*expr_p
, 1));
13747 REF_REVERSE_STORAGE_ORDER (tmp
)
13748 = REF_REVERSE_STORAGE_ORDER (*expr_p
);
13750 recalculate_side_effects (*expr_p
);
13754 /* Avoid re-gimplifying the address operand if it is already
13755 in suitable form. Re-gimplifying would mark the address
13756 operand addressable. Always gimplify when not in SSA form
13757 as we still may have to gimplify decls with value-exprs. */
13758 if (!gimplify_ctxp
|| !gimple_in_ssa_p (cfun
)
13759 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p
, 0)))
13761 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
13762 is_gimple_mem_ref_addr
, fb_rvalue
);
13763 if (ret
== GS_ERROR
)
13766 recalculate_side_effects (*expr_p
);
13770 /* Constants need not be gimplified. */
13777 /* Drop the overflow flag on constants, we do not want
13778 that in the GIMPLE IL. */
13779 if (TREE_OVERFLOW_P (*expr_p
))
13780 *expr_p
= drop_tree_overflow (*expr_p
);
13785 /* If we require an lvalue, such as for ADDR_EXPR, retain the
13786 CONST_DECL node. Otherwise the decl is replaceable by its
13788 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
13789 if (fallback
& fb_lvalue
)
13793 *expr_p
= DECL_INITIAL (*expr_p
);
13799 ret
= gimplify_decl_expr (expr_p
, pre_p
);
13803 ret
= gimplify_bind_expr (expr_p
, pre_p
);
13807 ret
= gimplify_loop_expr (expr_p
, pre_p
);
13811 ret
= gimplify_switch_expr (expr_p
, pre_p
);
13815 ret
= gimplify_exit_expr (expr_p
);
13819 /* If the target is not LABEL, then it is a computed jump
13820 and the target needs to be gimplified. */
13821 if (TREE_CODE (GOTO_DESTINATION (*expr_p
)) != LABEL_DECL
)
13823 ret
= gimplify_expr (&GOTO_DESTINATION (*expr_p
), pre_p
,
13824 NULL
, is_gimple_val
, fb_rvalue
);
13825 if (ret
== GS_ERROR
)
13828 gimplify_seq_add_stmt (pre_p
,
13829 gimple_build_goto (GOTO_DESTINATION (*expr_p
)));
13834 gimplify_seq_add_stmt (pre_p
,
13835 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p
),
13836 PREDICT_EXPR_OUTCOME (*expr_p
)));
13841 ret
= gimplify_label_expr (expr_p
, pre_p
);
13842 label
= LABEL_EXPR_LABEL (*expr_p
);
13843 gcc_assert (decl_function_context (label
) == current_function_decl
);
13845 /* If the label is used in a goto statement, or address of the label
13846 is taken, we need to unpoison all variables that were seen so far.
13847 Doing so would prevent us from reporting a false positives. */
13848 if (asan_poisoned_variables
13849 && asan_used_labels
!= NULL
13850 && asan_used_labels
->contains (label
))
13851 asan_poison_variables (asan_poisoned_variables
, false, pre_p
);
13854 case CASE_LABEL_EXPR
:
13855 ret
= gimplify_case_label_expr (expr_p
, pre_p
);
13857 if (gimplify_ctxp
->live_switch_vars
)
13858 asan_poison_variables (gimplify_ctxp
->live_switch_vars
, false,
13863 ret
= gimplify_return_expr (*expr_p
, pre_p
);
13867 /* Don't reduce this in place; let gimplify_init_constructor work its
13868 magic. Buf if we're just elaborating this for side effects, just
13869 gimplify any element that has side-effects. */
13870 if (fallback
== fb_none
)
13872 unsigned HOST_WIDE_INT ix
;
13874 tree temp
= NULL_TREE
;
13875 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p
), ix
, val
)
13876 if (TREE_SIDE_EFFECTS (val
))
13877 append_to_statement_list (val
, &temp
);
13880 ret
= temp
? GS_OK
: GS_ALL_DONE
;
13882 /* C99 code may assign to an array in a constructed
13883 structure or union, and this has undefined behavior only
13884 on execution, so create a temporary if an lvalue is
13886 else if (fallback
== fb_lvalue
)
13888 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
, false);
13889 mark_addressable (*expr_p
);
13896 /* The following are special cases that are not handled by the
13897 original GIMPLE grammar. */
13899 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
13902 ret
= gimplify_save_expr (expr_p
, pre_p
, post_p
);
13905 case BIT_FIELD_REF
:
13906 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
13907 post_p
, is_gimple_lvalue
, fb_either
);
13908 recalculate_side_effects (*expr_p
);
13911 case TARGET_MEM_REF
:
13913 enum gimplify_status r0
= GS_ALL_DONE
, r1
= GS_ALL_DONE
;
13915 if (TMR_BASE (*expr_p
))
13916 r0
= gimplify_expr (&TMR_BASE (*expr_p
), pre_p
,
13917 post_p
, is_gimple_mem_ref_addr
, fb_either
);
13918 if (TMR_INDEX (*expr_p
))
13919 r1
= gimplify_expr (&TMR_INDEX (*expr_p
), pre_p
,
13920 post_p
, is_gimple_val
, fb_rvalue
);
13921 if (TMR_INDEX2 (*expr_p
))
13922 r1
= gimplify_expr (&TMR_INDEX2 (*expr_p
), pre_p
,
13923 post_p
, is_gimple_val
, fb_rvalue
);
13924 /* TMR_STEP and TMR_OFFSET are always integer constants. */
13925 ret
= MIN (r0
, r1
);
13929 case NON_LVALUE_EXPR
:
13930 /* This should have been stripped above. */
13931 gcc_unreachable ();
13934 ret
= gimplify_asm_expr (expr_p
, pre_p
, post_p
);
13937 case TRY_FINALLY_EXPR
:
13938 case TRY_CATCH_EXPR
:
13940 gimple_seq eval
, cleanup
;
13943 /* Calls to destructors are generated automatically in FINALLY/CATCH
13944 block. They should have location as UNKNOWN_LOCATION. However,
13945 gimplify_call_expr will reset these call stmts to input_location
13946 if it finds stmt's location is unknown. To prevent resetting for
13947 destructors, we set the input_location to unknown.
13948 Note that this only affects the destructor calls in FINALLY/CATCH
13949 block, and will automatically reset to its original value by the
13950 end of gimplify_expr. */
13951 input_location
= UNKNOWN_LOCATION
;
13952 eval
= cleanup
= NULL
;
13953 gimplify_and_add (TREE_OPERAND (*expr_p
, 0), &eval
);
13954 if (TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
13955 && TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == EH_ELSE_EXPR
)
13957 gimple_seq n
= NULL
, e
= NULL
;
13958 gimplify_and_add (TREE_OPERAND (TREE_OPERAND (*expr_p
, 1),
13960 gimplify_and_add (TREE_OPERAND (TREE_OPERAND (*expr_p
, 1),
13962 if (!gimple_seq_empty_p (n
) && !gimple_seq_empty_p (e
))
13964 geh_else
*stmt
= gimple_build_eh_else (n
, e
);
13965 gimple_seq_add_stmt (&cleanup
, stmt
);
13969 gimplify_and_add (TREE_OPERAND (*expr_p
, 1), &cleanup
);
13970 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
13971 if (gimple_seq_empty_p (cleanup
))
13973 gimple_seq_add_seq (pre_p
, eval
);
13977 try_
= gimple_build_try (eval
, cleanup
,
13978 TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
13979 ? GIMPLE_TRY_FINALLY
13980 : GIMPLE_TRY_CATCH
);
13981 if (EXPR_HAS_LOCATION (save_expr
))
13982 gimple_set_location (try_
, EXPR_LOCATION (save_expr
));
13983 else if (LOCATION_LOCUS (saved_location
) != UNKNOWN_LOCATION
)
13984 gimple_set_location (try_
, saved_location
);
13985 if (TREE_CODE (*expr_p
) == TRY_CATCH_EXPR
)
13986 gimple_try_set_catch_is_cleanup (try_
,
13987 TRY_CATCH_IS_CLEANUP (*expr_p
));
13988 gimplify_seq_add_stmt (pre_p
, try_
);
13993 case CLEANUP_POINT_EXPR
:
13994 ret
= gimplify_cleanup_point_expr (expr_p
, pre_p
);
13998 ret
= gimplify_target_expr (expr_p
, pre_p
, post_p
);
14004 gimple_seq handler
= NULL
;
14005 gimplify_and_add (CATCH_BODY (*expr_p
), &handler
);
14006 c
= gimple_build_catch (CATCH_TYPES (*expr_p
), handler
);
14007 gimplify_seq_add_stmt (pre_p
, c
);
14012 case EH_FILTER_EXPR
:
14015 gimple_seq failure
= NULL
;
14017 gimplify_and_add (EH_FILTER_FAILURE (*expr_p
), &failure
);
14018 ehf
= gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p
), failure
);
14019 gimple_set_no_warning (ehf
, TREE_NO_WARNING (*expr_p
));
14020 gimplify_seq_add_stmt (pre_p
, ehf
);
14027 enum gimplify_status r0
, r1
;
14028 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
,
14029 post_p
, is_gimple_val
, fb_rvalue
);
14030 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
,
14031 post_p
, is_gimple_val
, fb_rvalue
);
14032 TREE_SIDE_EFFECTS (*expr_p
) = 0;
14033 ret
= MIN (r0
, r1
);
14038 /* We get here when taking the address of a label. We mark
14039 the label as "forced"; meaning it can never be removed and
14040 it is a potential target for any computed goto. */
14041 FORCED_LABEL (*expr_p
) = 1;
14045 case STATEMENT_LIST
:
14046 ret
= gimplify_statement_list (expr_p
, pre_p
);
14049 case WITH_SIZE_EXPR
:
14051 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
14052 post_p
== &internal_post
? NULL
: post_p
,
14053 gimple_test_f
, fallback
);
14054 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
14055 is_gimple_val
, fb_rvalue
);
14062 ret
= gimplify_var_or_parm_decl (expr_p
);
14066 /* When within an OMP context, notice uses of variables. */
14067 if (gimplify_omp_ctxp
)
14068 omp_notice_variable (gimplify_omp_ctxp
, *expr_p
, true);
14072 case DEBUG_EXPR_DECL
:
14073 gcc_unreachable ();
14075 case DEBUG_BEGIN_STMT
:
14076 gimplify_seq_add_stmt (pre_p
,
14077 gimple_build_debug_begin_stmt
14078 (TREE_BLOCK (*expr_p
),
14079 EXPR_LOCATION (*expr_p
)));
14085 /* Allow callbacks into the gimplifier during optimization. */
14090 gimplify_omp_parallel (expr_p
, pre_p
);
14095 gimplify_omp_task (expr_p
, pre_p
);
14101 case OMP_DISTRIBUTE
:
14104 ret
= gimplify_omp_for (expr_p
, pre_p
);
14108 ret
= gimplify_omp_loop (expr_p
, pre_p
);
14112 gimplify_oacc_cache (expr_p
, pre_p
);
14117 gimplify_oacc_declare (expr_p
, pre_p
);
14121 case OACC_HOST_DATA
:
14124 case OACC_PARALLEL
:
14129 case OMP_TARGET_DATA
:
14131 gimplify_omp_workshare (expr_p
, pre_p
);
14135 case OACC_ENTER_DATA
:
14136 case OACC_EXIT_DATA
:
14138 case OMP_TARGET_UPDATE
:
14139 case OMP_TARGET_ENTER_DATA
:
14140 case OMP_TARGET_EXIT_DATA
:
14141 gimplify_omp_target_update (expr_p
, pre_p
);
14151 gimple_seq body
= NULL
;
14153 bool saved_in_omp_construct
= in_omp_construct
;
14155 in_omp_construct
= true;
14156 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
14157 in_omp_construct
= saved_in_omp_construct
;
14158 switch (TREE_CODE (*expr_p
))
14161 g
= gimple_build_omp_section (body
);
14164 g
= gimple_build_omp_master (body
);
14167 g
= gimplify_omp_ordered (*expr_p
, body
);
14170 gimplify_scan_omp_clauses (&OMP_CRITICAL_CLAUSES (*expr_p
),
14171 pre_p
, ORT_WORKSHARE
, OMP_CRITICAL
);
14172 gimplify_adjust_omp_clauses (pre_p
, body
,
14173 &OMP_CRITICAL_CLAUSES (*expr_p
),
14175 g
= gimple_build_omp_critical (body
,
14176 OMP_CRITICAL_NAME (*expr_p
),
14177 OMP_CRITICAL_CLAUSES (*expr_p
));
14180 gimplify_scan_omp_clauses (&OMP_SCAN_CLAUSES (*expr_p
),
14181 pre_p
, ORT_WORKSHARE
, OMP_SCAN
);
14182 gimplify_adjust_omp_clauses (pre_p
, body
,
14183 &OMP_SCAN_CLAUSES (*expr_p
),
14185 g
= gimple_build_omp_scan (body
, OMP_SCAN_CLAUSES (*expr_p
));
14188 gcc_unreachable ();
14190 gimplify_seq_add_stmt (pre_p
, g
);
14195 case OMP_TASKGROUP
:
14197 gimple_seq body
= NULL
;
14199 tree
*pclauses
= &OMP_TASKGROUP_CLAUSES (*expr_p
);
14200 bool saved_in_omp_construct
= in_omp_construct
;
14201 gimplify_scan_omp_clauses (pclauses
, pre_p
, ORT_TASKGROUP
,
14203 gimplify_adjust_omp_clauses (pre_p
, NULL
, pclauses
, OMP_TASKGROUP
);
14205 in_omp_construct
= true;
14206 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
14207 in_omp_construct
= saved_in_omp_construct
;
14208 gimple_seq cleanup
= NULL
;
14209 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TASKGROUP_END
);
14210 gimple
*g
= gimple_build_call (fn
, 0);
14211 gimple_seq_add_stmt (&cleanup
, g
);
14212 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
14214 gimple_seq_add_stmt (&body
, g
);
14215 g
= gimple_build_omp_taskgroup (body
, *pclauses
);
14216 gimplify_seq_add_stmt (pre_p
, g
);
14222 case OMP_ATOMIC_READ
:
14223 case OMP_ATOMIC_CAPTURE_OLD
:
14224 case OMP_ATOMIC_CAPTURE_NEW
:
14225 ret
= gimplify_omp_atomic (expr_p
, pre_p
);
14228 case TRANSACTION_EXPR
:
14229 ret
= gimplify_transaction (expr_p
, pre_p
);
14232 case TRUTH_AND_EXPR
:
14233 case TRUTH_OR_EXPR
:
14234 case TRUTH_XOR_EXPR
:
14236 tree orig_type
= TREE_TYPE (*expr_p
);
14237 tree new_type
, xop0
, xop1
;
14238 *expr_p
= gimple_boolify (*expr_p
);
14239 new_type
= TREE_TYPE (*expr_p
);
14240 if (!useless_type_conversion_p (orig_type
, new_type
))
14242 *expr_p
= fold_convert_loc (input_location
, orig_type
, *expr_p
);
14247 /* Boolified binary truth expressions are semantically equivalent
14248 to bitwise binary expressions. Canonicalize them to the
14249 bitwise variant. */
14250 switch (TREE_CODE (*expr_p
))
14252 case TRUTH_AND_EXPR
:
14253 TREE_SET_CODE (*expr_p
, BIT_AND_EXPR
);
14255 case TRUTH_OR_EXPR
:
14256 TREE_SET_CODE (*expr_p
, BIT_IOR_EXPR
);
14258 case TRUTH_XOR_EXPR
:
14259 TREE_SET_CODE (*expr_p
, BIT_XOR_EXPR
);
14264 /* Now make sure that operands have compatible type to
14265 expression's new_type. */
14266 xop0
= TREE_OPERAND (*expr_p
, 0);
14267 xop1
= TREE_OPERAND (*expr_p
, 1);
14268 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop0
)))
14269 TREE_OPERAND (*expr_p
, 0) = fold_convert_loc (input_location
,
14272 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop1
)))
14273 TREE_OPERAND (*expr_p
, 1) = fold_convert_loc (input_location
,
14276 /* Continue classified as tcc_binary. */
14280 case VEC_COND_EXPR
:
14282 enum gimplify_status r0
, r1
, r2
;
14284 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
14285 post_p
, is_gimple_condexpr
, fb_rvalue
);
14286 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
14287 post_p
, is_gimple_val
, fb_rvalue
);
14288 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
14289 post_p
, is_gimple_val
, fb_rvalue
);
14291 ret
= MIN (MIN (r0
, r1
), r2
);
14292 recalculate_side_effects (*expr_p
);
14296 case VEC_PERM_EXPR
:
14297 /* Classified as tcc_expression. */
14300 case BIT_INSERT_EXPR
:
14301 /* Argument 3 is a constant. */
14304 case POINTER_PLUS_EXPR
:
14306 enum gimplify_status r0
, r1
;
14307 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
14308 post_p
, is_gimple_val
, fb_rvalue
);
14309 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
14310 post_p
, is_gimple_val
, fb_rvalue
);
14311 recalculate_side_effects (*expr_p
);
14312 ret
= MIN (r0
, r1
);
14317 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p
)))
14319 case tcc_comparison
:
14320 /* Handle comparison of objects of non scalar mode aggregates
14321 with a call to memcmp. It would be nice to only have to do
14322 this for variable-sized objects, but then we'd have to allow
14323 the same nest of reference nodes we allow for MODIFY_EXPR and
14324 that's too complex.
14326 Compare scalar mode aggregates as scalar mode values. Using
14327 memcmp for them would be very inefficient at best, and is
14328 plain wrong if bitfields are involved. */
14330 tree type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 1));
14332 /* Vector comparisons need no boolification. */
14333 if (TREE_CODE (type
) == VECTOR_TYPE
)
14335 else if (!AGGREGATE_TYPE_P (type
))
14337 tree org_type
= TREE_TYPE (*expr_p
);
14338 *expr_p
= gimple_boolify (*expr_p
);
14339 if (!useless_type_conversion_p (org_type
,
14340 TREE_TYPE (*expr_p
)))
14342 *expr_p
= fold_convert_loc (input_location
,
14343 org_type
, *expr_p
);
14349 else if (TYPE_MODE (type
) != BLKmode
)
14350 ret
= gimplify_scalar_mode_aggregate_compare (expr_p
);
14352 ret
= gimplify_variable_sized_compare (expr_p
);
14357 /* If *EXPR_P does not need to be special-cased, handle it
14358 according to its class. */
14360 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
14361 post_p
, is_gimple_val
, fb_rvalue
);
14367 enum gimplify_status r0
, r1
;
14369 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
14370 post_p
, is_gimple_val
, fb_rvalue
);
14371 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
14372 post_p
, is_gimple_val
, fb_rvalue
);
14374 ret
= MIN (r0
, r1
);
14380 enum gimplify_status r0
, r1
, r2
;
14382 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
14383 post_p
, is_gimple_val
, fb_rvalue
);
14384 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
14385 post_p
, is_gimple_val
, fb_rvalue
);
14386 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
14387 post_p
, is_gimple_val
, fb_rvalue
);
14389 ret
= MIN (MIN (r0
, r1
), r2
);
14393 case tcc_declaration
:
14396 goto dont_recalculate
;
14399 gcc_unreachable ();
14402 recalculate_side_effects (*expr_p
);
14408 gcc_assert (*expr_p
|| ret
!= GS_OK
);
14410 while (ret
== GS_OK
);
14412 /* If we encountered an error_mark somewhere nested inside, either
14413 stub out the statement or propagate the error back out. */
14414 if (ret
== GS_ERROR
)
14421 /* This was only valid as a return value from the langhook, which
14422 we handled. Make sure it doesn't escape from any other context. */
14423 gcc_assert (ret
!= GS_UNHANDLED
);
14425 if (fallback
== fb_none
&& *expr_p
&& !is_gimple_stmt (*expr_p
))
14427 /* We aren't looking for a value, and we don't have a valid
14428 statement. If it doesn't have side-effects, throw it away.
14429 We can also get here with code such as "*&&L;", where L is
14430 a LABEL_DECL that is marked as FORCED_LABEL. */
14431 if (TREE_CODE (*expr_p
) == LABEL_DECL
14432 || !TREE_SIDE_EFFECTS (*expr_p
))
14434 else if (!TREE_THIS_VOLATILE (*expr_p
))
14436 /* This is probably a _REF that contains something nested that
14437 has side effects. Recurse through the operands to find it. */
14438 enum tree_code code
= TREE_CODE (*expr_p
);
14442 case COMPONENT_REF
:
14443 case REALPART_EXPR
:
14444 case IMAGPART_EXPR
:
14445 case VIEW_CONVERT_EXPR
:
14446 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
14447 gimple_test_f
, fallback
);
14451 case ARRAY_RANGE_REF
:
14452 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
14453 gimple_test_f
, fallback
);
14454 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
14455 gimple_test_f
, fallback
);
14459 /* Anything else with side-effects must be converted to
14460 a valid statement before we get here. */
14461 gcc_unreachable ();
14466 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p
))
14467 && TYPE_MODE (TREE_TYPE (*expr_p
)) != BLKmode
)
14469 /* Historically, the compiler has treated a bare reference
14470 to a non-BLKmode volatile lvalue as forcing a load. */
14471 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p
));
14473 /* Normally, we do not want to create a temporary for a
14474 TREE_ADDRESSABLE type because such a type should not be
14475 copied by bitwise-assignment. However, we make an
14476 exception here, as all we are doing here is ensuring that
14477 we read the bytes that make up the type. We use
14478 create_tmp_var_raw because create_tmp_var will abort when
14479 given a TREE_ADDRESSABLE type. */
14480 tree tmp
= create_tmp_var_raw (type
, "vol");
14481 gimple_add_tmp_var (tmp
);
14482 gimplify_assign (tmp
, *expr_p
, pre_p
);
14486 /* We can't do anything useful with a volatile reference to
14487 an incomplete type, so just throw it away. Likewise for
14488 a BLKmode type, since any implicit inner load should
14489 already have been turned into an explicit one by the
14490 gimplification process. */
14494 /* If we are gimplifying at the statement level, we're done. Tack
14495 everything together and return. */
14496 if (fallback
== fb_none
|| is_statement
)
14498 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
14499 it out for GC to reclaim it. */
14500 *expr_p
= NULL_TREE
;
14502 if (!gimple_seq_empty_p (internal_pre
)
14503 || !gimple_seq_empty_p (internal_post
))
14505 gimplify_seq_add_seq (&internal_pre
, internal_post
);
14506 gimplify_seq_add_seq (pre_p
, internal_pre
);
14509 /* The result of gimplifying *EXPR_P is going to be the last few
14510 statements in *PRE_P and *POST_P. Add location information
14511 to all the statements that were added by the gimplification
14513 if (!gimple_seq_empty_p (*pre_p
))
14514 annotate_all_with_location_after (*pre_p
, pre_last_gsi
, input_location
);
14516 if (!gimple_seq_empty_p (*post_p
))
14517 annotate_all_with_location_after (*post_p
, post_last_gsi
,
14523 #ifdef ENABLE_GIMPLE_CHECKING
14526 enum tree_code code
= TREE_CODE (*expr_p
);
14527 /* These expressions should already be in gimple IR form. */
14528 gcc_assert (code
!= MODIFY_EXPR
14529 && code
!= ASM_EXPR
14530 && code
!= BIND_EXPR
14531 && code
!= CATCH_EXPR
14532 && (code
!= COND_EXPR
|| gimplify_ctxp
->allow_rhs_cond_expr
)
14533 && code
!= EH_FILTER_EXPR
14534 && code
!= GOTO_EXPR
14535 && code
!= LABEL_EXPR
14536 && code
!= LOOP_EXPR
14537 && code
!= SWITCH_EXPR
14538 && code
!= TRY_FINALLY_EXPR
14539 && code
!= EH_ELSE_EXPR
14540 && code
!= OACC_PARALLEL
14541 && code
!= OACC_KERNELS
14542 && code
!= OACC_SERIAL
14543 && code
!= OACC_DATA
14544 && code
!= OACC_HOST_DATA
14545 && code
!= OACC_DECLARE
14546 && code
!= OACC_UPDATE
14547 && code
!= OACC_ENTER_DATA
14548 && code
!= OACC_EXIT_DATA
14549 && code
!= OACC_CACHE
14550 && code
!= OMP_CRITICAL
14552 && code
!= OACC_LOOP
14553 && code
!= OMP_MASTER
14554 && code
!= OMP_TASKGROUP
14555 && code
!= OMP_ORDERED
14556 && code
!= OMP_PARALLEL
14557 && code
!= OMP_SCAN
14558 && code
!= OMP_SECTIONS
14559 && code
!= OMP_SECTION
14560 && code
!= OMP_SINGLE
);
14564 /* Otherwise we're gimplifying a subexpression, so the resulting
14565 value is interesting. If it's a valid operand that matches
14566 GIMPLE_TEST_F, we're done. Unless we are handling some
14567 post-effects internally; if that's the case, we need to copy into
14568 a temporary before adding the post-effects to POST_P. */
14569 if (gimple_seq_empty_p (internal_post
) && (*gimple_test_f
) (*expr_p
))
14572 /* Otherwise, we need to create a new temporary for the gimplified
14575 /* We can't return an lvalue if we have an internal postqueue. The
14576 object the lvalue refers to would (probably) be modified by the
14577 postqueue; we need to copy the value out first, which means an
14579 if ((fallback
& fb_lvalue
)
14580 && gimple_seq_empty_p (internal_post
)
14581 && is_gimple_addressable (*expr_p
))
14583 /* An lvalue will do. Take the address of the expression, store it
14584 in a temporary, and replace the expression with an INDIRECT_REF of
14586 tree ref_alias_type
= reference_alias_ptr_type (*expr_p
);
14587 unsigned int ref_align
= get_object_alignment (*expr_p
);
14588 tree ref_type
= TREE_TYPE (*expr_p
);
14589 tmp
= build_fold_addr_expr_loc (input_location
, *expr_p
);
14590 gimplify_expr (&tmp
, pre_p
, post_p
, is_gimple_reg
, fb_rvalue
);
14591 if (TYPE_ALIGN (ref_type
) != ref_align
)
14592 ref_type
= build_aligned_type (ref_type
, ref_align
);
14593 *expr_p
= build2 (MEM_REF
, ref_type
,
14594 tmp
, build_zero_cst (ref_alias_type
));
14596 else if ((fallback
& fb_rvalue
) && is_gimple_reg_rhs_or_call (*expr_p
))
14598 /* An rvalue will do. Assign the gimplified expression into a
14599 new temporary TMP and replace the original expression with
14600 TMP. First, make sure that the expression has a type so that
14601 it can be assigned into a temporary. */
14602 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p
)));
14603 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
14607 #ifdef ENABLE_GIMPLE_CHECKING
14608 if (!(fallback
& fb_mayfail
))
14610 fprintf (stderr
, "gimplification failed:\n");
14611 print_generic_expr (stderr
, *expr_p
);
14612 debug_tree (*expr_p
);
14613 internal_error ("gimplification failed");
14616 gcc_assert (fallback
& fb_mayfail
);
14618 /* If this is an asm statement, and the user asked for the
14619 impossible, don't die. Fail and let gimplify_asm_expr
14625 /* Make sure the temporary matches our predicate. */
14626 gcc_assert ((*gimple_test_f
) (*expr_p
));
14628 if (!gimple_seq_empty_p (internal_post
))
14630 annotate_all_with_location (internal_post
, input_location
);
14631 gimplify_seq_add_seq (pre_p
, internal_post
);
14635 input_location
= saved_location
;
14639 /* Like gimplify_expr but make sure the gimplified result is not itself
14640 a SSA name (but a decl if it were). Temporaries required by
14641 evaluating *EXPR_P may be still SSA names. */
14643 static enum gimplify_status
14644 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
14645 bool (*gimple_test_f
) (tree
), fallback_t fallback
,
14648 bool was_ssa_name_p
= TREE_CODE (*expr_p
) == SSA_NAME
;
14649 enum gimplify_status ret
= gimplify_expr (expr_p
, pre_p
, post_p
,
14650 gimple_test_f
, fallback
);
14652 && TREE_CODE (*expr_p
) == SSA_NAME
)
14654 tree name
= *expr_p
;
14655 if (was_ssa_name_p
)
14656 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, NULL
, false);
14659 /* Avoid the extra copy if possible. */
14660 *expr_p
= create_tmp_reg (TREE_TYPE (name
));
14661 if (!gimple_nop_p (SSA_NAME_DEF_STMT (name
)))
14662 gimple_set_lhs (SSA_NAME_DEF_STMT (name
), *expr_p
);
14663 release_ssa_name (name
);
14669 /* Look through TYPE for variable-sized objects and gimplify each such
14670 size that we find. Add to LIST_P any statements generated. */
14673 gimplify_type_sizes (tree type
, gimple_seq
*list_p
)
14677 if (type
== NULL
|| type
== error_mark_node
)
14680 /* We first do the main variant, then copy into any other variants. */
14681 type
= TYPE_MAIN_VARIANT (type
);
14683 /* Avoid infinite recursion. */
14684 if (TYPE_SIZES_GIMPLIFIED (type
))
14687 TYPE_SIZES_GIMPLIFIED (type
) = 1;
14689 switch (TREE_CODE (type
))
14692 case ENUMERAL_TYPE
:
14695 case FIXED_POINT_TYPE
:
14696 gimplify_one_sizepos (&TYPE_MIN_VALUE (type
), list_p
);
14697 gimplify_one_sizepos (&TYPE_MAX_VALUE (type
), list_p
);
14699 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
14701 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (type
);
14702 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (type
);
14707 /* These types may not have declarations, so handle them here. */
14708 gimplify_type_sizes (TREE_TYPE (type
), list_p
);
14709 gimplify_type_sizes (TYPE_DOMAIN (type
), list_p
);
14710 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
14711 with assigned stack slots, for -O1+ -g they should be tracked
14713 if (!(TYPE_NAME (type
)
14714 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
14715 && DECL_IGNORED_P (TYPE_NAME (type
)))
14716 && TYPE_DOMAIN (type
)
14717 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type
)))
14719 t
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
14720 if (t
&& VAR_P (t
) && DECL_ARTIFICIAL (t
))
14721 DECL_IGNORED_P (t
) = 0;
14722 t
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
14723 if (t
&& VAR_P (t
) && DECL_ARTIFICIAL (t
))
14724 DECL_IGNORED_P (t
) = 0;
14730 case QUAL_UNION_TYPE
:
14731 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
14732 if (TREE_CODE (field
) == FIELD_DECL
)
14734 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field
), list_p
);
14735 gimplify_one_sizepos (&DECL_SIZE (field
), list_p
);
14736 gimplify_one_sizepos (&DECL_SIZE_UNIT (field
), list_p
);
14737 gimplify_type_sizes (TREE_TYPE (field
), list_p
);
14742 case REFERENCE_TYPE
:
14743 /* We used to recurse on the pointed-to type here, which turned out to
14744 be incorrect because its definition might refer to variables not
14745 yet initialized at this point if a forward declaration is involved.
14747 It was actually useful for anonymous pointed-to types to ensure
14748 that the sizes evaluation dominates every possible later use of the
14749 values. Restricting to such types here would be safe since there
14750 is no possible forward declaration around, but would introduce an
14751 undesirable middle-end semantic to anonymity. We then defer to
14752 front-ends the responsibility of ensuring that the sizes are
14753 evaluated both early and late enough, e.g. by attaching artificial
14754 type declarations to the tree. */
14761 gimplify_one_sizepos (&TYPE_SIZE (type
), list_p
);
14762 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type
), list_p
);
14764 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
14766 TYPE_SIZE (t
) = TYPE_SIZE (type
);
14767 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (type
);
14768 TYPE_SIZES_GIMPLIFIED (t
) = 1;
14772 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
14773 a size or position, has had all of its SAVE_EXPRs evaluated.
14774 We add any required statements to *STMT_P. */
14777 gimplify_one_sizepos (tree
*expr_p
, gimple_seq
*stmt_p
)
14779 tree expr
= *expr_p
;
14781 /* We don't do anything if the value isn't there, is constant, or contains
14782 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
14783 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
14784 will want to replace it with a new variable, but that will cause problems
14785 if this type is from outside the function. It's OK to have that here. */
14786 if (expr
== NULL_TREE
14787 || is_gimple_constant (expr
)
14788 || TREE_CODE (expr
) == VAR_DECL
14789 || CONTAINS_PLACEHOLDER_P (expr
))
14792 *expr_p
= unshare_expr (expr
);
14794 /* SSA names in decl/type fields are a bad idea - they'll get reclaimed
14795 if the def vanishes. */
14796 gimplify_expr (expr_p
, stmt_p
, NULL
, is_gimple_val
, fb_rvalue
, false);
14798 /* If expr wasn't already is_gimple_sizepos or is_gimple_constant from the
14799 FE, ensure that it is a VAR_DECL, otherwise we might handle some decls
14800 as gimplify_vla_decl even when they would have all sizes INTEGER_CSTs. */
14801 if (is_gimple_constant (*expr_p
))
14802 *expr_p
= get_initialized_tmp_var (*expr_p
, stmt_p
, NULL
, false);
14805 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
14806 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
14807 is true, also gimplify the parameters. */
14810 gimplify_body (tree fndecl
, bool do_parms
)
14812 location_t saved_location
= input_location
;
14813 gimple_seq parm_stmts
, parm_cleanup
= NULL
, seq
;
14814 gimple
*outer_stmt
;
14817 timevar_push (TV_TREE_GIMPLIFY
);
14819 init_tree_ssa (cfun
);
14821 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
14823 default_rtl_profile ();
14825 gcc_assert (gimplify_ctxp
== NULL
);
14826 push_gimplify_context (true);
14828 if (flag_openacc
|| flag_openmp
)
14830 gcc_assert (gimplify_omp_ctxp
== NULL
);
14831 if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (fndecl
)))
14832 gimplify_omp_ctxp
= new_omp_context (ORT_IMPLICIT_TARGET
);
14835 /* Unshare most shared trees in the body and in that of any nested functions.
14836 It would seem we don't have to do this for nested functions because
14837 they are supposed to be output and then the outer function gimplified
14838 first, but the g++ front end doesn't always do it that way. */
14839 unshare_body (fndecl
);
14840 unvisit_body (fndecl
);
14842 /* Make sure input_location isn't set to something weird. */
14843 input_location
= DECL_SOURCE_LOCATION (fndecl
);
14845 /* Resolve callee-copies. This has to be done before processing
14846 the body so that DECL_VALUE_EXPR gets processed correctly. */
14847 parm_stmts
= do_parms
? gimplify_parameters (&parm_cleanup
) : NULL
;
14849 /* Gimplify the function's body. */
14851 gimplify_stmt (&DECL_SAVED_TREE (fndecl
), &seq
);
14852 outer_stmt
= gimple_seq_first_stmt (seq
);
14855 outer_stmt
= gimple_build_nop ();
14856 gimplify_seq_add_stmt (&seq
, outer_stmt
);
14859 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
14860 not the case, wrap everything in a GIMPLE_BIND to make it so. */
14861 if (gimple_code (outer_stmt
) == GIMPLE_BIND
14862 && gimple_seq_first (seq
) == gimple_seq_last (seq
))
14863 outer_bind
= as_a
<gbind
*> (outer_stmt
);
14865 outer_bind
= gimple_build_bind (NULL_TREE
, seq
, NULL
);
14867 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
14869 /* If we had callee-copies statements, insert them at the beginning
14870 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
14871 if (!gimple_seq_empty_p (parm_stmts
))
14875 gimplify_seq_add_seq (&parm_stmts
, gimple_bind_body (outer_bind
));
14878 gtry
*g
= gimple_build_try (parm_stmts
, parm_cleanup
,
14879 GIMPLE_TRY_FINALLY
);
14881 gimple_seq_add_stmt (&parm_stmts
, g
);
14883 gimple_bind_set_body (outer_bind
, parm_stmts
);
14885 for (parm
= DECL_ARGUMENTS (current_function_decl
);
14886 parm
; parm
= DECL_CHAIN (parm
))
14887 if (DECL_HAS_VALUE_EXPR_P (parm
))
14889 DECL_HAS_VALUE_EXPR_P (parm
) = 0;
14890 DECL_IGNORED_P (parm
) = 0;
14894 if ((flag_openacc
|| flag_openmp
|| flag_openmp_simd
)
14895 && gimplify_omp_ctxp
)
14897 delete_omp_context (gimplify_omp_ctxp
);
14898 gimplify_omp_ctxp
= NULL
;
14901 pop_gimplify_context (outer_bind
);
14902 gcc_assert (gimplify_ctxp
== NULL
);
14904 if (flag_checking
&& !seen_error ())
14905 verify_gimple_in_seq (gimple_bind_body (outer_bind
));
14907 timevar_pop (TV_TREE_GIMPLIFY
);
14908 input_location
= saved_location
;
14913 typedef char *char_p
; /* For DEF_VEC_P. */
14915 /* Return whether we should exclude FNDECL from instrumentation. */
14918 flag_instrument_functions_exclude_p (tree fndecl
)
14922 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_functions
;
14923 if (v
&& v
->length () > 0)
14929 name
= lang_hooks
.decl_printable_name (fndecl
, 1);
14930 FOR_EACH_VEC_ELT (*v
, i
, s
)
14931 if (strstr (name
, s
) != NULL
)
14935 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_files
;
14936 if (v
&& v
->length () > 0)
14942 name
= DECL_SOURCE_FILE (fndecl
);
14943 FOR_EACH_VEC_ELT (*v
, i
, s
)
14944 if (strstr (name
, s
) != NULL
)
14951 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
14952 node for the function we want to gimplify.
14954 Return the sequence of GIMPLE statements corresponding to the body
14958 gimplify_function_tree (tree fndecl
)
14964 gcc_assert (!gimple_body (fndecl
));
14966 if (DECL_STRUCT_FUNCTION (fndecl
))
14967 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
14969 push_struct_function (fndecl
);
14971 /* Tentatively set PROP_gimple_lva here, and reset it in gimplify_va_arg_expr
14973 cfun
->curr_properties
|= PROP_gimple_lva
;
14975 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
14977 /* Preliminarily mark non-addressed complex variables as eligible
14978 for promotion to gimple registers. We'll transform their uses
14979 as we find them. */
14980 if ((TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
14981 || TREE_CODE (TREE_TYPE (parm
)) == VECTOR_TYPE
)
14982 && !TREE_THIS_VOLATILE (parm
)
14983 && !needs_to_live_in_memory (parm
))
14984 DECL_GIMPLE_REG_P (parm
) = 1;
14987 ret
= DECL_RESULT (fndecl
);
14988 if ((TREE_CODE (TREE_TYPE (ret
)) == COMPLEX_TYPE
14989 || TREE_CODE (TREE_TYPE (ret
)) == VECTOR_TYPE
)
14990 && !needs_to_live_in_memory (ret
))
14991 DECL_GIMPLE_REG_P (ret
) = 1;
14993 if (asan_sanitize_use_after_scope () && sanitize_flags_p (SANITIZE_ADDRESS
))
14994 asan_poisoned_variables
= new hash_set
<tree
> ();
14995 bind
= gimplify_body (fndecl
, true);
14996 if (asan_poisoned_variables
)
14998 delete asan_poisoned_variables
;
14999 asan_poisoned_variables
= NULL
;
15002 /* The tree body of the function is no longer needed, replace it
15003 with the new GIMPLE body. */
15005 gimple_seq_add_stmt (&seq
, bind
);
15006 gimple_set_body (fndecl
, seq
);
15008 /* If we're instrumenting function entry/exit, then prepend the call to
15009 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
15010 catch the exit hook. */
15011 /* ??? Add some way to ignore exceptions for this TFE. */
15012 if (flag_instrument_function_entry_exit
15013 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
)
15014 /* Do not instrument extern inline functions. */
15015 && !(DECL_DECLARED_INLINE_P (fndecl
)
15016 && DECL_EXTERNAL (fndecl
)
15017 && DECL_DISREGARD_INLINE_LIMITS (fndecl
))
15018 && !flag_instrument_functions_exclude_p (fndecl
))
15023 gimple_seq cleanup
= NULL
, body
= NULL
;
15024 tree tmp_var
, this_fn_addr
;
15027 /* The instrumentation hooks aren't going to call the instrumented
15028 function and the address they receive is expected to be matchable
15029 against symbol addresses. Make sure we don't create a trampoline,
15030 in case the current function is nested. */
15031 this_fn_addr
= build_fold_addr_expr (current_function_decl
);
15032 TREE_NO_TRAMPOLINE (this_fn_addr
) = 1;
15034 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
15035 call
= gimple_build_call (x
, 1, integer_zero_node
);
15036 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
15037 gimple_call_set_lhs (call
, tmp_var
);
15038 gimplify_seq_add_stmt (&cleanup
, call
);
15039 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT
);
15040 call
= gimple_build_call (x
, 2, this_fn_addr
, tmp_var
);
15041 gimplify_seq_add_stmt (&cleanup
, call
);
15042 tf
= gimple_build_try (seq
, cleanup
, GIMPLE_TRY_FINALLY
);
15044 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
15045 call
= gimple_build_call (x
, 1, integer_zero_node
);
15046 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
15047 gimple_call_set_lhs (call
, tmp_var
);
15048 gimplify_seq_add_stmt (&body
, call
);
15049 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER
);
15050 call
= gimple_build_call (x
, 2, this_fn_addr
, tmp_var
);
15051 gimplify_seq_add_stmt (&body
, call
);
15052 gimplify_seq_add_stmt (&body
, tf
);
15053 new_bind
= gimple_build_bind (NULL
, body
, NULL
);
15055 /* Replace the current function body with the body
15056 wrapped in the try/finally TF. */
15058 gimple_seq_add_stmt (&seq
, new_bind
);
15059 gimple_set_body (fndecl
, seq
);
15063 if (sanitize_flags_p (SANITIZE_THREAD
))
15065 gcall
*call
= gimple_build_call_internal (IFN_TSAN_FUNC_EXIT
, 0);
15066 gimple
*tf
= gimple_build_try (seq
, call
, GIMPLE_TRY_FINALLY
);
15067 gbind
*new_bind
= gimple_build_bind (NULL
, tf
, NULL
);
15068 /* Replace the current function body with the body
15069 wrapped in the try/finally TF. */
15071 gimple_seq_add_stmt (&seq
, new_bind
);
15072 gimple_set_body (fndecl
, seq
);
15075 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
15076 cfun
->curr_properties
|= PROP_gimple_any
;
15080 dump_function (TDI_gimple
, fndecl
);
15083 /* Return a dummy expression of type TYPE in order to keep going after an
15087 dummy_object (tree type
)
15089 tree t
= build_int_cst (build_pointer_type (type
), 0);
15090 return build2 (MEM_REF
, type
, t
, t
);
15093 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
15094 builtin function, but a very special sort of operator. */
15096 enum gimplify_status
15097 gimplify_va_arg_expr (tree
*expr_p
, gimple_seq
*pre_p
,
15098 gimple_seq
*post_p ATTRIBUTE_UNUSED
)
15100 tree promoted_type
, have_va_type
;
15101 tree valist
= TREE_OPERAND (*expr_p
, 0);
15102 tree type
= TREE_TYPE (*expr_p
);
15103 tree t
, tag
, aptag
;
15104 location_t loc
= EXPR_LOCATION (*expr_p
);
15106 /* Verify that valist is of the proper type. */
15107 have_va_type
= TREE_TYPE (valist
);
15108 if (have_va_type
== error_mark_node
)
15110 have_va_type
= targetm
.canonical_va_list_type (have_va_type
);
15111 if (have_va_type
== NULL_TREE
15112 && POINTER_TYPE_P (TREE_TYPE (valist
)))
15113 /* Handle 'Case 1: Not an array type' from c-common.c/build_va_arg. */
15115 = targetm
.canonical_va_list_type (TREE_TYPE (TREE_TYPE (valist
)));
15116 gcc_assert (have_va_type
!= NULL_TREE
);
15118 /* Generate a diagnostic for requesting data of a type that cannot
15119 be passed through `...' due to type promotion at the call site. */
15120 if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
15123 static bool gave_help
;
15125 /* Use the expansion point to handle cases such as passing bool (defined
15126 in a system header) through `...'. */
15128 = expansion_point_location_if_in_system_header (loc
);
15130 /* Unfortunately, this is merely undefined, rather than a constraint
15131 violation, so we cannot make this an error. If this call is never
15132 executed, the program is still strictly conforming. */
15133 auto_diagnostic_group d
;
15134 warned
= warning_at (xloc
, 0,
15135 "%qT is promoted to %qT when passed through %<...%>",
15136 type
, promoted_type
);
15137 if (!gave_help
&& warned
)
15140 inform (xloc
, "(so you should pass %qT not %qT to %<va_arg%>)",
15141 promoted_type
, type
);
15144 /* We can, however, treat "undefined" any way we please.
15145 Call abort to encourage the user to fix the program. */
15147 inform (xloc
, "if this code is reached, the program will abort");
15148 /* Before the abort, allow the evaluation of the va_list
15149 expression to exit or longjmp. */
15150 gimplify_and_add (valist
, pre_p
);
15151 t
= build_call_expr_loc (loc
,
15152 builtin_decl_implicit (BUILT_IN_TRAP
), 0);
15153 gimplify_and_add (t
, pre_p
);
15155 /* This is dead code, but go ahead and finish so that the
15156 mode of the result comes out right. */
15157 *expr_p
= dummy_object (type
);
15158 return GS_ALL_DONE
;
15161 tag
= build_int_cst (build_pointer_type (type
), 0);
15162 aptag
= build_int_cst (TREE_TYPE (valist
), 0);
15164 *expr_p
= build_call_expr_internal_loc (loc
, IFN_VA_ARG
, type
, 3,
15165 valist
, tag
, aptag
);
15167 /* Clear the tentatively set PROP_gimple_lva, to indicate that IFN_VA_ARG
15168 needs to be expanded. */
15169 cfun
->curr_properties
&= ~PROP_gimple_lva
;
15174 /* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
15176 DST/SRC are the destination and source respectively. You can pass
15177 ungimplified trees in DST or SRC, in which case they will be
15178 converted to a gimple operand if necessary.
15180 This function returns the newly created GIMPLE_ASSIGN tuple. */
15183 gimplify_assign (tree dst
, tree src
, gimple_seq
*seq_p
)
15185 tree t
= build2 (MODIFY_EXPR
, TREE_TYPE (dst
), dst
, src
);
15186 gimplify_and_add (t
, seq_p
);
15188 return gimple_seq_last_stmt (*seq_p
);
15192 gimplify_hasher::hash (const elt_t
*p
)
15195 return iterative_hash_expr (t
, 0);
15199 gimplify_hasher::equal (const elt_t
*p1
, const elt_t
*p2
)
15203 enum tree_code code
= TREE_CODE (t1
);
15205 if (TREE_CODE (t2
) != code
15206 || TREE_TYPE (t1
) != TREE_TYPE (t2
))
15209 if (!operand_equal_p (t1
, t2
, 0))
15212 /* Only allow them to compare equal if they also hash equal; otherwise
15213 results are nondeterminate, and we fail bootstrap comparison. */
15214 gcc_checking_assert (hash (p1
) == hash (p2
));