1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002-2018 Free Software Foundation, Inc.
4 Major work done by Sebastian Pop <s.pop@laposte.net>,
5 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
33 #include "gimple-predict.h"
34 #include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
37 #include "tree-pretty-print.h"
38 #include "diagnostic-core.h"
40 #include "fold-const.h"
45 #include "gimple-fold.h"
48 #include "gimple-iterator.h"
49 #include "stor-layout.h"
50 #include "print-tree.h"
51 #include "tree-iterator.h"
52 #include "tree-inline.h"
53 #include "langhooks.h"
56 #include "omp-general.h"
58 #include "gimple-low.h"
59 #include "gomp-constants.h"
60 #include "splay-tree.h"
61 #include "gimple-walk.h"
62 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
64 #include "stringpool.h"
69 /* Hash set of poisoned variables in a bind expr. */
70 static hash_set
<tree
> *asan_poisoned_variables
= NULL
;
72 enum gimplify_omp_var_data
78 GOVD_FIRSTPRIVATE
= 16,
79 GOVD_LASTPRIVATE
= 32,
83 GOVD_DEBUG_PRIVATE
= 512,
84 GOVD_PRIVATE_OUTER_REF
= 1024,
88 /* Flag for GOVD_MAP: don't copy back. */
89 GOVD_MAP_TO_ONLY
= 8192,
91 /* Flag for GOVD_LINEAR or GOVD_LASTPRIVATE: no outer reference. */
92 GOVD_LINEAR_LASTPRIVATE_NO_OUTER
= 16384,
94 GOVD_MAP_0LEN_ARRAY
= 32768,
96 /* Flag for GOVD_MAP, if it is always, to or always, tofrom mapping. */
97 GOVD_MAP_ALWAYS_TO
= 65536,
99 /* Flag for shared vars that are or might be stored to in the region. */
100 GOVD_WRITTEN
= 131072,
102 /* Flag for GOVD_MAP, if it is a forced mapping. */
103 GOVD_MAP_FORCE
= 262144,
105 /* Flag for GOVD_MAP: must be present already. */
106 GOVD_MAP_FORCE_PRESENT
= 524288,
108 GOVD_DATA_SHARE_CLASS
= (GOVD_SHARED
| GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
109 | GOVD_LASTPRIVATE
| GOVD_REDUCTION
| GOVD_LINEAR
116 ORT_WORKSHARE
= 0x00,
120 ORT_COMBINED_PARALLEL
= 0x03,
123 ORT_UNTIED_TASK
= 0x05,
126 ORT_COMBINED_TEAMS
= 0x09,
129 ORT_TARGET_DATA
= 0x10,
131 /* Data region with offloading. */
133 ORT_COMBINED_TARGET
= 0x21,
135 /* OpenACC variants. */
136 ORT_ACC
= 0x40, /* A generic OpenACC region. */
137 ORT_ACC_DATA
= ORT_ACC
| ORT_TARGET_DATA
, /* Data construct. */
138 ORT_ACC_PARALLEL
= ORT_ACC
| ORT_TARGET
, /* Parallel construct */
139 ORT_ACC_KERNELS
= ORT_ACC
| ORT_TARGET
| 0x80, /* Kernels construct. */
140 ORT_ACC_HOST_DATA
= ORT_ACC
| ORT_TARGET_DATA
| 0x80, /* Host data. */
142 /* Dummy OpenMP region, used to disable expansion of
143 DECL_VALUE_EXPRs in taskloop pre body. */
147 /* Gimplify hashtable helper. */
149 struct gimplify_hasher
: free_ptr_hash
<elt_t
>
151 static inline hashval_t
hash (const elt_t
*);
152 static inline bool equal (const elt_t
*, const elt_t
*);
157 struct gimplify_ctx
*prev_context
;
159 vec
<gbind
*> bind_expr_stack
;
161 gimple_seq conditional_cleanups
;
165 vec
<tree
> case_labels
;
166 hash_set
<tree
> *live_switch_vars
;
167 /* The formal temporary table. Should this be persistent? */
168 hash_table
<gimplify_hasher
> *temp_htab
;
171 unsigned into_ssa
: 1;
172 unsigned allow_rhs_cond_expr
: 1;
173 unsigned in_cleanup_point_expr
: 1;
174 unsigned keep_stack
: 1;
175 unsigned save_stack
: 1;
176 unsigned in_switch_expr
: 1;
179 struct gimplify_omp_ctx
181 struct gimplify_omp_ctx
*outer_context
;
182 splay_tree variables
;
183 hash_set
<tree
> *privatized_types
;
184 /* Iteration variables in an OMP_FOR. */
185 vec
<tree
> loop_iter_var
;
187 enum omp_clause_default_kind default_kind
;
188 enum omp_region_type region_type
;
191 bool target_map_scalars_firstprivate
;
192 bool target_map_pointers_as_0len_arrays
;
193 bool target_firstprivatize_array_bases
;
196 static struct gimplify_ctx
*gimplify_ctxp
;
197 static struct gimplify_omp_ctx
*gimplify_omp_ctxp
;
199 /* Forward declaration. */
200 static enum gimplify_status
gimplify_compound_expr (tree
*, gimple_seq
*, bool);
201 static hash_map
<tree
, tree
> *oacc_declare_returns
;
202 static enum gimplify_status
gimplify_expr (tree
*, gimple_seq
*, gimple_seq
*,
203 bool (*) (tree
), fallback_t
, bool);
205 /* Shorter alias name for the above function for use in gimplify.c
209 gimplify_seq_add_stmt (gimple_seq
*seq_p
, gimple
*gs
)
211 gimple_seq_add_stmt_without_update (seq_p
, gs
);
214 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
215 NULL, a new sequence is allocated. This function is
216 similar to gimple_seq_add_seq, but does not scan the operands.
217 During gimplification, we need to manipulate statement sequences
218 before the def/use vectors have been constructed. */
221 gimplify_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
223 gimple_stmt_iterator si
;
228 si
= gsi_last (*dst_p
);
229 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
233 /* Pointer to a list of allocated gimplify_ctx structs to be used for pushing
234 and popping gimplify contexts. */
236 static struct gimplify_ctx
*ctx_pool
= NULL
;
238 /* Return a gimplify context struct from the pool. */
240 static inline struct gimplify_ctx
*
243 struct gimplify_ctx
* c
= ctx_pool
;
246 ctx_pool
= c
->prev_context
;
248 c
= XNEW (struct gimplify_ctx
);
250 memset (c
, '\0', sizeof (*c
));
254 /* Put gimplify context C back into the pool. */
257 ctx_free (struct gimplify_ctx
*c
)
259 c
->prev_context
= ctx_pool
;
263 /* Free allocated ctx stack memory. */
266 free_gimplify_stack (void)
268 struct gimplify_ctx
*c
;
270 while ((c
= ctx_pool
))
272 ctx_pool
= c
->prev_context
;
278 /* Set up a context for the gimplifier. */
281 push_gimplify_context (bool in_ssa
, bool rhs_cond_ok
)
283 struct gimplify_ctx
*c
= ctx_alloc ();
285 c
->prev_context
= gimplify_ctxp
;
287 gimplify_ctxp
->into_ssa
= in_ssa
;
288 gimplify_ctxp
->allow_rhs_cond_expr
= rhs_cond_ok
;
291 /* Tear down a context for the gimplifier. If BODY is non-null, then
292 put the temporaries into the outer BIND_EXPR. Otherwise, put them
295 BODY is not a sequence, but the first tuple in a sequence. */
298 pop_gimplify_context (gimple
*body
)
300 struct gimplify_ctx
*c
= gimplify_ctxp
;
303 && (!c
->bind_expr_stack
.exists ()
304 || c
->bind_expr_stack
.is_empty ()));
305 c
->bind_expr_stack
.release ();
306 gimplify_ctxp
= c
->prev_context
;
309 declare_vars (c
->temps
, body
, false);
311 record_vars (c
->temps
);
318 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
321 gimple_push_bind_expr (gbind
*bind_stmt
)
323 gimplify_ctxp
->bind_expr_stack
.reserve (8);
324 gimplify_ctxp
->bind_expr_stack
.safe_push (bind_stmt
);
327 /* Pop the first element off the stack of bindings. */
330 gimple_pop_bind_expr (void)
332 gimplify_ctxp
->bind_expr_stack
.pop ();
335 /* Return the first element of the stack of bindings. */
338 gimple_current_bind_expr (void)
340 return gimplify_ctxp
->bind_expr_stack
.last ();
343 /* Return the stack of bindings created during gimplification. */
346 gimple_bind_expr_stack (void)
348 return gimplify_ctxp
->bind_expr_stack
;
351 /* Return true iff there is a COND_EXPR between us and the innermost
352 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
355 gimple_conditional_context (void)
357 return gimplify_ctxp
->conditions
> 0;
360 /* Note that we've entered a COND_EXPR. */
363 gimple_push_condition (void)
365 #ifdef ENABLE_GIMPLE_CHECKING
366 if (gimplify_ctxp
->conditions
== 0)
367 gcc_assert (gimple_seq_empty_p (gimplify_ctxp
->conditional_cleanups
));
369 ++(gimplify_ctxp
->conditions
);
372 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
373 now, add any conditional cleanups we've seen to the prequeue. */
376 gimple_pop_condition (gimple_seq
*pre_p
)
378 int conds
= --(gimplify_ctxp
->conditions
);
380 gcc_assert (conds
>= 0);
383 gimplify_seq_add_seq (pre_p
, gimplify_ctxp
->conditional_cleanups
);
384 gimplify_ctxp
->conditional_cleanups
= NULL
;
388 /* A stable comparison routine for use with splay trees and DECLs. */
391 splay_tree_compare_decl_uid (splay_tree_key xa
, splay_tree_key xb
)
396 return DECL_UID (a
) - DECL_UID (b
);
399 /* Create a new omp construct that deals with variable remapping. */
401 static struct gimplify_omp_ctx
*
402 new_omp_context (enum omp_region_type region_type
)
404 struct gimplify_omp_ctx
*c
;
406 c
= XCNEW (struct gimplify_omp_ctx
);
407 c
->outer_context
= gimplify_omp_ctxp
;
408 c
->variables
= splay_tree_new (splay_tree_compare_decl_uid
, 0, 0);
409 c
->privatized_types
= new hash_set
<tree
>;
410 c
->location
= input_location
;
411 c
->region_type
= region_type
;
412 if ((region_type
& ORT_TASK
) == 0)
413 c
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
415 c
->default_kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
420 /* Destroy an omp construct that deals with variable remapping. */
423 delete_omp_context (struct gimplify_omp_ctx
*c
)
425 splay_tree_delete (c
->variables
);
426 delete c
->privatized_types
;
427 c
->loop_iter_var
.release ();
431 static void omp_add_variable (struct gimplify_omp_ctx
*, tree
, unsigned int);
432 static bool omp_notice_variable (struct gimplify_omp_ctx
*, tree
, bool);
434 /* Both gimplify the statement T and append it to *SEQ_P. This function
435 behaves exactly as gimplify_stmt, but you don't have to pass T as a
439 gimplify_and_add (tree t
, gimple_seq
*seq_p
)
441 gimplify_stmt (&t
, seq_p
);
444 /* Gimplify statement T into sequence *SEQ_P, and return the first
445 tuple in the sequence of generated tuples for this statement.
446 Return NULL if gimplifying T produced no tuples. */
449 gimplify_and_return_first (tree t
, gimple_seq
*seq_p
)
451 gimple_stmt_iterator last
= gsi_last (*seq_p
);
453 gimplify_and_add (t
, seq_p
);
455 if (!gsi_end_p (last
))
458 return gsi_stmt (last
);
461 return gimple_seq_first_stmt (*seq_p
);
464 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
465 LHS, or for a call argument. */
468 is_gimple_mem_rhs (tree t
)
470 /* If we're dealing with a renamable type, either source or dest must be
471 a renamed variable. */
472 if (is_gimple_reg_type (TREE_TYPE (t
)))
473 return is_gimple_val (t
);
475 return is_gimple_val (t
) || is_gimple_lvalue (t
);
478 /* Return true if T is a CALL_EXPR or an expression that can be
479 assigned to a temporary. Note that this predicate should only be
480 used during gimplification. See the rationale for this in
481 gimplify_modify_expr. */
484 is_gimple_reg_rhs_or_call (tree t
)
486 return (get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
487 || TREE_CODE (t
) == CALL_EXPR
);
490 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
491 this predicate should only be used during gimplification. See the
492 rationale for this in gimplify_modify_expr. */
495 is_gimple_mem_rhs_or_call (tree t
)
497 /* If we're dealing with a renamable type, either source or dest must be
498 a renamed variable. */
499 if (is_gimple_reg_type (TREE_TYPE (t
)))
500 return is_gimple_val (t
);
502 return (is_gimple_val (t
)
503 || is_gimple_lvalue (t
)
504 || TREE_CLOBBER_P (t
)
505 || TREE_CODE (t
) == CALL_EXPR
);
508 /* Create a temporary with a name derived from VAL. Subroutine of
509 lookup_tmp_var; nobody else should call this function. */
512 create_tmp_from_val (tree val
)
514 /* Drop all qualifiers and address-space information from the value type. */
515 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (val
));
516 tree var
= create_tmp_var (type
, get_name (val
));
517 if (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
518 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
519 DECL_GIMPLE_REG_P (var
) = 1;
523 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
524 an existing expression temporary. */
527 lookup_tmp_var (tree val
, bool is_formal
)
531 /* If not optimizing, never really reuse a temporary. local-alloc
532 won't allocate any variable that is used in more than one basic
533 block, which means it will go into memory, causing much extra
534 work in reload and final and poorer code generation, outweighing
535 the extra memory allocation here. */
536 if (!optimize
|| !is_formal
|| TREE_SIDE_EFFECTS (val
))
537 ret
= create_tmp_from_val (val
);
544 if (!gimplify_ctxp
->temp_htab
)
545 gimplify_ctxp
->temp_htab
= new hash_table
<gimplify_hasher
> (1000);
546 slot
= gimplify_ctxp
->temp_htab
->find_slot (&elt
, INSERT
);
549 elt_p
= XNEW (elt_t
);
551 elt_p
->temp
= ret
= create_tmp_from_val (val
);
564 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
567 internal_get_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
568 bool is_formal
, bool allow_ssa
)
572 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
573 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
574 gimplify_expr (&val
, pre_p
, post_p
, is_gimple_reg_rhs_or_call
,
578 && gimplify_ctxp
->into_ssa
579 && is_gimple_reg_type (TREE_TYPE (val
)))
581 t
= make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val
)));
582 if (! gimple_in_ssa_p (cfun
))
584 const char *name
= get_name (val
);
586 SET_SSA_NAME_VAR_OR_IDENTIFIER (t
, create_tmp_var_name (name
));
590 t
= lookup_tmp_var (val
, is_formal
);
592 mod
= build2 (INIT_EXPR
, TREE_TYPE (t
), t
, unshare_expr (val
));
594 SET_EXPR_LOCATION (mod
, EXPR_LOC_OR_LOC (val
, input_location
));
596 /* gimplify_modify_expr might want to reduce this further. */
597 gimplify_and_add (mod
, pre_p
);
603 /* Return a formal temporary variable initialized with VAL. PRE_P is as
604 in gimplify_expr. Only use this function if:
606 1) The value of the unfactored expression represented by VAL will not
607 change between the initialization and use of the temporary, and
608 2) The temporary will not be otherwise modified.
610 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
611 and #2 means it is inappropriate for && temps.
613 For other cases, use get_initialized_tmp_var instead. */
616 get_formal_tmp_var (tree val
, gimple_seq
*pre_p
)
618 return internal_get_tmp_var (val
, pre_p
, NULL
, true, true);
621 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
622 are as in gimplify_expr. */
625 get_initialized_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
628 return internal_get_tmp_var (val
, pre_p
, post_p
, false, allow_ssa
);
631 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
632 generate debug info for them; otherwise don't. */
635 declare_vars (tree vars
, gimple
*gs
, bool debug_info
)
642 gbind
*scope
= as_a
<gbind
*> (gs
);
644 temps
= nreverse (last
);
646 block
= gimple_bind_block (scope
);
647 gcc_assert (!block
|| TREE_CODE (block
) == BLOCK
);
648 if (!block
|| !debug_info
)
650 DECL_CHAIN (last
) = gimple_bind_vars (scope
);
651 gimple_bind_set_vars (scope
, temps
);
655 /* We need to attach the nodes both to the BIND_EXPR and to its
656 associated BLOCK for debugging purposes. The key point here
657 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
658 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
659 if (BLOCK_VARS (block
))
660 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), temps
);
663 gimple_bind_set_vars (scope
,
664 chainon (gimple_bind_vars (scope
), temps
));
665 BLOCK_VARS (block
) = temps
;
671 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
672 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
673 no such upper bound can be obtained. */
676 force_constant_size (tree var
)
678 /* The only attempt we make is by querying the maximum size of objects
679 of the variable's type. */
681 HOST_WIDE_INT max_size
;
683 gcc_assert (VAR_P (var
));
685 max_size
= max_int_size_in_bytes (TREE_TYPE (var
));
687 gcc_assert (max_size
>= 0);
690 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var
)), max_size
);
692 = build_int_cst (TREE_TYPE (DECL_SIZE (var
)), max_size
* BITS_PER_UNIT
);
695 /* Push the temporary variable TMP into the current binding. */
698 gimple_add_tmp_var_fn (struct function
*fn
, tree tmp
)
700 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
702 /* Later processing assumes that the object size is constant, which might
703 not be true at this point. Force the use of a constant upper bound in
705 if (!tree_fits_poly_uint64_p (DECL_SIZE_UNIT (tmp
)))
706 force_constant_size (tmp
);
708 DECL_CONTEXT (tmp
) = fn
->decl
;
709 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
711 record_vars_into (tmp
, fn
->decl
);
714 /* Push the temporary variable TMP into the current binding. */
717 gimple_add_tmp_var (tree tmp
)
719 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
721 /* Later processing assumes that the object size is constant, which might
722 not be true at this point. Force the use of a constant upper bound in
724 if (!tree_fits_poly_uint64_p (DECL_SIZE_UNIT (tmp
)))
725 force_constant_size (tmp
);
727 DECL_CONTEXT (tmp
) = current_function_decl
;
728 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
732 DECL_CHAIN (tmp
) = gimplify_ctxp
->temps
;
733 gimplify_ctxp
->temps
= tmp
;
735 /* Mark temporaries local within the nearest enclosing parallel. */
736 if (gimplify_omp_ctxp
)
738 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
740 && (ctx
->region_type
== ORT_WORKSHARE
741 || ctx
->region_type
== ORT_SIMD
742 || ctx
->region_type
== ORT_ACC
))
743 ctx
= ctx
->outer_context
;
745 omp_add_variable (ctx
, tmp
, GOVD_LOCAL
| GOVD_SEEN
);
754 /* This case is for nested functions. We need to expose the locals
756 body_seq
= gimple_body (current_function_decl
);
757 declare_vars (tmp
, gimple_seq_first_stmt (body_seq
), false);
763 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
764 nodes that are referenced more than once in GENERIC functions. This is
765 necessary because gimplification (translation into GIMPLE) is performed
766 by modifying tree nodes in-place, so gimplication of a shared node in a
767 first context could generate an invalid GIMPLE form in a second context.
769 This is achieved with a simple mark/copy/unmark algorithm that walks the
770 GENERIC representation top-down, marks nodes with TREE_VISITED the first
771 time it encounters them, duplicates them if they already have TREE_VISITED
772 set, and finally removes the TREE_VISITED marks it has set.
774 The algorithm works only at the function level, i.e. it generates a GENERIC
775 representation of a function with no nodes shared within the function when
776 passed a GENERIC function (except for nodes that are allowed to be shared).
778 At the global level, it is also necessary to unshare tree nodes that are
779 referenced in more than one function, for the same aforementioned reason.
780 This requires some cooperation from the front-end. There are 2 strategies:
782 1. Manual unsharing. The front-end needs to call unshare_expr on every
783 expression that might end up being shared across functions.
785 2. Deep unsharing. This is an extension of regular unsharing. Instead
786 of calling unshare_expr on expressions that might be shared across
787 functions, the front-end pre-marks them with TREE_VISITED. This will
788 ensure that they are unshared on the first reference within functions
789 when the regular unsharing algorithm runs. The counterpart is that
790 this algorithm must look deeper than for manual unsharing, which is
791 specified by LANG_HOOKS_DEEP_UNSHARING.
793 If there are only few specific cases of node sharing across functions, it is
794 probably easier for a front-end to unshare the expressions manually. On the
795 contrary, if the expressions generated at the global level are as widespread
796 as expressions generated within functions, deep unsharing is very likely the
799 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
800 These nodes model computations that must be done once. If we were to
801 unshare something like SAVE_EXPR(i++), the gimplification process would
802 create wrong code. However, if DATA is non-null, it must hold a pointer
803 set that is used to unshare the subtrees of these nodes. */
806 mostly_copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
809 enum tree_code code
= TREE_CODE (t
);
811 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
812 copy their subtrees if we can make sure to do it only once. */
813 if (code
== SAVE_EXPR
|| code
== TARGET_EXPR
|| code
== BIND_EXPR
)
815 if (data
&& !((hash_set
<tree
> *)data
)->add (t
))
821 /* Stop at types, decls, constants like copy_tree_r. */
822 else if (TREE_CODE_CLASS (code
) == tcc_type
823 || TREE_CODE_CLASS (code
) == tcc_declaration
824 || TREE_CODE_CLASS (code
) == tcc_constant
)
827 /* Cope with the statement expression extension. */
828 else if (code
== STATEMENT_LIST
)
831 /* Leave the bulk of the work to copy_tree_r itself. */
833 copy_tree_r (tp
, walk_subtrees
, NULL
);
838 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
839 If *TP has been visited already, then *TP is deeply copied by calling
840 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
843 copy_if_shared_r (tree
*tp
, int *walk_subtrees
, void *data
)
846 enum tree_code code
= TREE_CODE (t
);
848 /* Skip types, decls, and constants. But we do want to look at their
849 types and the bounds of types. Mark them as visited so we properly
850 unmark their subtrees on the unmark pass. If we've already seen them,
851 don't look down further. */
852 if (TREE_CODE_CLASS (code
) == tcc_type
853 || TREE_CODE_CLASS (code
) == tcc_declaration
854 || TREE_CODE_CLASS (code
) == tcc_constant
)
856 if (TREE_VISITED (t
))
859 TREE_VISITED (t
) = 1;
862 /* If this node has been visited already, unshare it and don't look
864 else if (TREE_VISITED (t
))
866 walk_tree (tp
, mostly_copy_tree_r
, data
, NULL
);
870 /* Otherwise, mark the node as visited and keep looking. */
872 TREE_VISITED (t
) = 1;
877 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
878 copy_if_shared_r callback unmodified. */
881 copy_if_shared (tree
*tp
, void *data
)
883 walk_tree (tp
, copy_if_shared_r
, data
, NULL
);
886 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
887 any nested functions. */
890 unshare_body (tree fndecl
)
892 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
893 /* If the language requires deep unsharing, we need a pointer set to make
894 sure we don't repeatedly unshare subtrees of unshareable nodes. */
895 hash_set
<tree
> *visited
896 = lang_hooks
.deep_unsharing
? new hash_set
<tree
> : NULL
;
898 copy_if_shared (&DECL_SAVED_TREE (fndecl
), visited
);
899 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl
)), visited
);
900 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)), visited
);
905 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
906 unshare_body (cgn
->decl
);
909 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
910 Subtrees are walked until the first unvisited node is encountered. */
913 unmark_visited_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
917 /* If this node has been visited, unmark it and keep looking. */
918 if (TREE_VISITED (t
))
919 TREE_VISITED (t
) = 0;
921 /* Otherwise, don't look any deeper. */
928 /* Unmark the visited trees rooted at *TP. */
931 unmark_visited (tree
*tp
)
933 walk_tree (tp
, unmark_visited_r
, NULL
, NULL
);
936 /* Likewise, but mark all trees as not visited. */
939 unvisit_body (tree fndecl
)
941 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
943 unmark_visited (&DECL_SAVED_TREE (fndecl
));
944 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl
)));
945 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)));
948 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
949 unvisit_body (cgn
->decl
);
952 /* Unconditionally make an unshared copy of EXPR. This is used when using
953 stored expressions which span multiple functions, such as BINFO_VTABLE,
954 as the normal unsharing process can't tell that they're shared. */
957 unshare_expr (tree expr
)
959 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
963 /* Worker for unshare_expr_without_location. */
966 prune_expr_location (tree
*tp
, int *walk_subtrees
, void *)
969 SET_EXPR_LOCATION (*tp
, UNKNOWN_LOCATION
);
975 /* Similar to unshare_expr but also prune all expression locations
979 unshare_expr_without_location (tree expr
)
981 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
983 walk_tree (&expr
, prune_expr_location
, NULL
, NULL
);
987 /* Return the EXPR_LOCATION of EXPR, if it (maybe recursively) has
988 one, OR_ELSE otherwise. The location of a STATEMENT_LISTs
989 comprising at least one DEBUG_BEGIN_STMT followed by exactly one
990 EXPR is the location of the EXPR. */
993 rexpr_location (tree expr
, location_t or_else
= UNKNOWN_LOCATION
)
998 if (EXPR_HAS_LOCATION (expr
))
999 return EXPR_LOCATION (expr
);
1001 if (TREE_CODE (expr
) != STATEMENT_LIST
)
1004 tree_stmt_iterator i
= tsi_start (expr
);
1007 while (!tsi_end_p (i
) && TREE_CODE (tsi_stmt (i
)) == DEBUG_BEGIN_STMT
)
1013 if (!found
|| !tsi_one_before_end_p (i
))
1016 return rexpr_location (tsi_stmt (i
), or_else
);
1019 /* Return TRUE iff EXPR (maybe recursively) has a location; see
1020 rexpr_location for the potential recursion. */
1023 rexpr_has_location (tree expr
)
1025 return rexpr_location (expr
) != UNKNOWN_LOCATION
;
1029 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1030 contain statements and have a value. Assign its value to a temporary
1031 and give it void_type_node. Return the temporary, or NULL_TREE if
1032 WRAPPER was already void. */
1035 voidify_wrapper_expr (tree wrapper
, tree temp
)
1037 tree type
= TREE_TYPE (wrapper
);
1038 if (type
&& !VOID_TYPE_P (type
))
1042 /* Set p to point to the body of the wrapper. Loop until we find
1043 something that isn't a wrapper. */
1044 for (p
= &wrapper
; p
&& *p
; )
1046 switch (TREE_CODE (*p
))
1049 TREE_SIDE_EFFECTS (*p
) = 1;
1050 TREE_TYPE (*p
) = void_type_node
;
1051 /* For a BIND_EXPR, the body is operand 1. */
1052 p
= &BIND_EXPR_BODY (*p
);
1055 case CLEANUP_POINT_EXPR
:
1056 case TRY_FINALLY_EXPR
:
1057 case TRY_CATCH_EXPR
:
1058 TREE_SIDE_EFFECTS (*p
) = 1;
1059 TREE_TYPE (*p
) = void_type_node
;
1060 p
= &TREE_OPERAND (*p
, 0);
1063 case STATEMENT_LIST
:
1065 tree_stmt_iterator i
= tsi_last (*p
);
1066 TREE_SIDE_EFFECTS (*p
) = 1;
1067 TREE_TYPE (*p
) = void_type_node
;
1068 p
= tsi_end_p (i
) ? NULL
: tsi_stmt_ptr (i
);
1073 /* Advance to the last statement. Set all container types to
1075 for (; TREE_CODE (*p
) == COMPOUND_EXPR
; p
= &TREE_OPERAND (*p
, 1))
1077 TREE_SIDE_EFFECTS (*p
) = 1;
1078 TREE_TYPE (*p
) = void_type_node
;
1082 case TRANSACTION_EXPR
:
1083 TREE_SIDE_EFFECTS (*p
) = 1;
1084 TREE_TYPE (*p
) = void_type_node
;
1085 p
= &TRANSACTION_EXPR_BODY (*p
);
1089 /* Assume that any tree upon which voidify_wrapper_expr is
1090 directly called is a wrapper, and that its body is op0. */
1093 TREE_SIDE_EFFECTS (*p
) = 1;
1094 TREE_TYPE (*p
) = void_type_node
;
1095 p
= &TREE_OPERAND (*p
, 0);
1103 if (p
== NULL
|| IS_EMPTY_STMT (*p
))
1107 /* The wrapper is on the RHS of an assignment that we're pushing
1109 gcc_assert (TREE_CODE (temp
) == INIT_EXPR
1110 || TREE_CODE (temp
) == MODIFY_EXPR
);
1111 TREE_OPERAND (temp
, 1) = *p
;
1116 temp
= create_tmp_var (type
, "retval");
1117 *p
= build2 (INIT_EXPR
, type
, temp
, *p
);
1126 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1127 a temporary through which they communicate. */
1130 build_stack_save_restore (gcall
**save
, gcall
**restore
)
1134 *save
= gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE
), 0);
1135 tmp_var
= create_tmp_var (ptr_type_node
, "saved_stack");
1136 gimple_call_set_lhs (*save
, tmp_var
);
1139 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE
),
1143 /* Generate IFN_ASAN_MARK call that poisons shadow of a for DECL variable. */
1146 build_asan_poison_call_expr (tree decl
)
1148 /* Do not poison variables that have size equal to zero. */
1149 tree unit_size
= DECL_SIZE_UNIT (decl
);
1150 if (zerop (unit_size
))
1153 tree base
= build_fold_addr_expr (decl
);
1155 return build_call_expr_internal_loc (UNKNOWN_LOCATION
, IFN_ASAN_MARK
,
1157 build_int_cst (integer_type_node
,
1162 /* Generate IFN_ASAN_MARK call that would poison or unpoison, depending
1163 on POISON flag, shadow memory of a DECL variable. The call will be
1164 put on location identified by IT iterator, where BEFORE flag drives
1165 position where the stmt will be put. */
1168 asan_poison_variable (tree decl
, bool poison
, gimple_stmt_iterator
*it
,
1171 tree unit_size
= DECL_SIZE_UNIT (decl
);
1172 tree base
= build_fold_addr_expr (decl
);
1174 /* Do not poison variables that have size equal to zero. */
1175 if (zerop (unit_size
))
1178 /* It's necessary to have all stack variables aligned to ASAN granularity
1180 if (DECL_ALIGN_UNIT (decl
) <= ASAN_SHADOW_GRANULARITY
)
1181 SET_DECL_ALIGN (decl
, BITS_PER_UNIT
* ASAN_SHADOW_GRANULARITY
);
1183 HOST_WIDE_INT flags
= poison
? ASAN_MARK_POISON
: ASAN_MARK_UNPOISON
;
1186 = gimple_build_call_internal (IFN_ASAN_MARK
, 3,
1187 build_int_cst (integer_type_node
, flags
),
1191 gsi_insert_before (it
, g
, GSI_NEW_STMT
);
1193 gsi_insert_after (it
, g
, GSI_NEW_STMT
);
1196 /* Generate IFN_ASAN_MARK internal call that depending on POISON flag
1197 either poisons or unpoisons a DECL. Created statement is appended
1198 to SEQ_P gimple sequence. */
1201 asan_poison_variable (tree decl
, bool poison
, gimple_seq
*seq_p
)
1203 gimple_stmt_iterator it
= gsi_last (*seq_p
);
1204 bool before
= false;
1209 asan_poison_variable (decl
, poison
, &it
, before
);
1212 /* Sort pair of VAR_DECLs A and B by DECL_UID. */
1215 sort_by_decl_uid (const void *a
, const void *b
)
1217 const tree
*t1
= (const tree
*)a
;
1218 const tree
*t2
= (const tree
*)b
;
1220 int uid1
= DECL_UID (*t1
);
1221 int uid2
= DECL_UID (*t2
);
1225 else if (uid1
> uid2
)
1231 /* Generate IFN_ASAN_MARK internal call for all VARIABLES
1232 depending on POISON flag. Created statement is appended
1233 to SEQ_P gimple sequence. */
1236 asan_poison_variables (hash_set
<tree
> *variables
, bool poison
, gimple_seq
*seq_p
)
1238 unsigned c
= variables
->elements ();
1242 auto_vec
<tree
> sorted_variables (c
);
1244 for (hash_set
<tree
>::iterator it
= variables
->begin ();
1245 it
!= variables
->end (); ++it
)
1246 sorted_variables
.safe_push (*it
);
1248 sorted_variables
.qsort (sort_by_decl_uid
);
1252 FOR_EACH_VEC_ELT (sorted_variables
, i
, var
)
1254 asan_poison_variable (var
, poison
, seq_p
);
1256 /* Add use_after_scope_memory attribute for the variable in order
1257 to prevent re-written into SSA. */
1258 if (!lookup_attribute (ASAN_USE_AFTER_SCOPE_ATTRIBUTE
,
1259 DECL_ATTRIBUTES (var
)))
1260 DECL_ATTRIBUTES (var
)
1261 = tree_cons (get_identifier (ASAN_USE_AFTER_SCOPE_ATTRIBUTE
),
1263 DECL_ATTRIBUTES (var
));
1267 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1269 static enum gimplify_status
1270 gimplify_bind_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1272 tree bind_expr
= *expr_p
;
1273 bool old_keep_stack
= gimplify_ctxp
->keep_stack
;
1274 bool old_save_stack
= gimplify_ctxp
->save_stack
;
1277 gimple_seq body
, cleanup
;
1279 location_t start_locus
= 0, end_locus
= 0;
1280 tree ret_clauses
= NULL
;
1282 tree temp
= voidify_wrapper_expr (bind_expr
, NULL
);
1284 /* Mark variables seen in this bind expr. */
1285 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1289 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1291 /* Mark variable as local. */
1292 if (ctx
&& ctx
->region_type
!= ORT_NONE
&& !DECL_EXTERNAL (t
)
1293 && (! DECL_SEEN_IN_BIND_EXPR_P (t
)
1294 || splay_tree_lookup (ctx
->variables
,
1295 (splay_tree_key
) t
) == NULL
))
1297 if (ctx
->region_type
== ORT_SIMD
1298 && TREE_ADDRESSABLE (t
)
1299 && !TREE_STATIC (t
))
1300 omp_add_variable (ctx
, t
, GOVD_PRIVATE
| GOVD_SEEN
);
1302 omp_add_variable (ctx
, t
, GOVD_LOCAL
| GOVD_SEEN
);
1305 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
1307 if (DECL_HARD_REGISTER (t
) && !is_global_var (t
) && cfun
)
1308 cfun
->has_local_explicit_reg_vars
= true;
1311 /* Preliminarily mark non-addressed complex variables as eligible
1312 for promotion to gimple registers. We'll transform their uses
1314 if ((TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
1315 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1316 && !TREE_THIS_VOLATILE (t
)
1317 && (VAR_P (t
) && !DECL_HARD_REGISTER (t
))
1318 && !needs_to_live_in_memory (t
))
1319 DECL_GIMPLE_REG_P (t
) = 1;
1322 bind_stmt
= gimple_build_bind (BIND_EXPR_VARS (bind_expr
), NULL
,
1323 BIND_EXPR_BLOCK (bind_expr
));
1324 gimple_push_bind_expr (bind_stmt
);
1326 gimplify_ctxp
->keep_stack
= false;
1327 gimplify_ctxp
->save_stack
= false;
1329 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1331 gimplify_stmt (&BIND_EXPR_BODY (bind_expr
), &body
);
1332 gimple_bind_set_body (bind_stmt
, body
);
1334 /* Source location wise, the cleanup code (stack_restore and clobbers)
1335 belongs to the end of the block, so propagate what we have. The
1336 stack_save operation belongs to the beginning of block, which we can
1337 infer from the bind_expr directly if the block has no explicit
1339 if (BIND_EXPR_BLOCK (bind_expr
))
1341 end_locus
= BLOCK_SOURCE_END_LOCATION (BIND_EXPR_BLOCK (bind_expr
));
1342 start_locus
= BLOCK_SOURCE_LOCATION (BIND_EXPR_BLOCK (bind_expr
));
1344 if (start_locus
== 0)
1345 start_locus
= EXPR_LOCATION (bind_expr
);
1350 /* If the code both contains VLAs and calls alloca, then we cannot reclaim
1351 the stack space allocated to the VLAs. */
1352 if (gimplify_ctxp
->save_stack
&& !gimplify_ctxp
->keep_stack
)
1354 gcall
*stack_restore
;
1356 /* Save stack on entry and restore it on exit. Add a try_finally
1357 block to achieve this. */
1358 build_stack_save_restore (&stack_save
, &stack_restore
);
1360 gimple_set_location (stack_save
, start_locus
);
1361 gimple_set_location (stack_restore
, end_locus
);
1363 gimplify_seq_add_stmt (&cleanup
, stack_restore
);
1366 /* Add clobbers for all variables that go out of scope. */
1367 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1370 && !is_global_var (t
)
1371 && DECL_CONTEXT (t
) == current_function_decl
)
1373 if (!DECL_HARD_REGISTER (t
)
1374 && !TREE_THIS_VOLATILE (t
)
1375 && !DECL_HAS_VALUE_EXPR_P (t
)
1376 /* Only care for variables that have to be in memory. Others
1377 will be rewritten into SSA names, hence moved to the
1379 && !is_gimple_reg (t
)
1380 && flag_stack_reuse
!= SR_NONE
)
1382 tree clobber
= build_clobber (TREE_TYPE (t
));
1383 gimple
*clobber_stmt
;
1384 clobber_stmt
= gimple_build_assign (t
, clobber
);
1385 gimple_set_location (clobber_stmt
, end_locus
);
1386 gimplify_seq_add_stmt (&cleanup
, clobber_stmt
);
1389 if (flag_openacc
&& oacc_declare_returns
!= NULL
)
1391 tree
*c
= oacc_declare_returns
->get (t
);
1395 OMP_CLAUSE_CHAIN (*c
) = ret_clauses
;
1399 oacc_declare_returns
->remove (t
);
1401 if (oacc_declare_returns
->elements () == 0)
1403 delete oacc_declare_returns
;
1404 oacc_declare_returns
= NULL
;
1410 if (asan_poisoned_variables
!= NULL
1411 && asan_poisoned_variables
->contains (t
))
1413 asan_poisoned_variables
->remove (t
);
1414 asan_poison_variable (t
, true, &cleanup
);
1417 if (gimplify_ctxp
->live_switch_vars
!= NULL
1418 && gimplify_ctxp
->live_switch_vars
->contains (t
))
1419 gimplify_ctxp
->live_switch_vars
->remove (t
);
1425 gimple_stmt_iterator si
= gsi_start (cleanup
);
1427 stmt
= gimple_build_omp_target (NULL
, GF_OMP_TARGET_KIND_OACC_DECLARE
,
1429 gsi_insert_seq_before_without_update (&si
, stmt
, GSI_NEW_STMT
);
1435 gimple_seq new_body
;
1438 gs
= gimple_build_try (gimple_bind_body (bind_stmt
), cleanup
,
1439 GIMPLE_TRY_FINALLY
);
1442 gimplify_seq_add_stmt (&new_body
, stack_save
);
1443 gimplify_seq_add_stmt (&new_body
, gs
);
1444 gimple_bind_set_body (bind_stmt
, new_body
);
1447 /* keep_stack propagates all the way up to the outermost BIND_EXPR. */
1448 if (!gimplify_ctxp
->keep_stack
)
1449 gimplify_ctxp
->keep_stack
= old_keep_stack
;
1450 gimplify_ctxp
->save_stack
= old_save_stack
;
1452 gimple_pop_bind_expr ();
1454 gimplify_seq_add_stmt (pre_p
, bind_stmt
);
1462 *expr_p
= NULL_TREE
;
1466 /* Maybe add early return predict statement to PRE_P sequence. */
1469 maybe_add_early_return_predict_stmt (gimple_seq
*pre_p
)
1471 /* If we are not in a conditional context, add PREDICT statement. */
1472 if (gimple_conditional_context ())
1474 gimple
*predict
= gimple_build_predict (PRED_TREE_EARLY_RETURN
,
1476 gimplify_seq_add_stmt (pre_p
, predict
);
1480 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1481 GIMPLE value, it is assigned to a new temporary and the statement is
1482 re-written to return the temporary.
1484 PRE_P points to the sequence where side effects that must happen before
1485 STMT should be stored. */
1487 static enum gimplify_status
1488 gimplify_return_expr (tree stmt
, gimple_seq
*pre_p
)
1491 tree ret_expr
= TREE_OPERAND (stmt
, 0);
1492 tree result_decl
, result
;
1494 if (ret_expr
== error_mark_node
)
1498 || TREE_CODE (ret_expr
) == RESULT_DECL
)
1500 maybe_add_early_return_predict_stmt (pre_p
);
1501 greturn
*ret
= gimple_build_return (ret_expr
);
1502 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1503 gimplify_seq_add_stmt (pre_p
, ret
);
1507 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1508 result_decl
= NULL_TREE
;
1511 result_decl
= TREE_OPERAND (ret_expr
, 0);
1513 /* See through a return by reference. */
1514 if (TREE_CODE (result_decl
) == INDIRECT_REF
)
1515 result_decl
= TREE_OPERAND (result_decl
, 0);
1517 gcc_assert ((TREE_CODE (ret_expr
) == MODIFY_EXPR
1518 || TREE_CODE (ret_expr
) == INIT_EXPR
)
1519 && TREE_CODE (result_decl
) == RESULT_DECL
);
1522 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1523 Recall that aggregate_value_p is FALSE for any aggregate type that is
1524 returned in registers. If we're returning values in registers, then
1525 we don't want to extend the lifetime of the RESULT_DECL, particularly
1526 across another call. In addition, for those aggregates for which
1527 hard_function_value generates a PARALLEL, we'll die during normal
1528 expansion of structure assignments; there's special code in expand_return
1529 to handle this case that does not exist in expand_expr. */
1532 else if (aggregate_value_p (result_decl
, TREE_TYPE (current_function_decl
)))
1534 if (TREE_CODE (DECL_SIZE (result_decl
)) != INTEGER_CST
)
1536 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl
)))
1537 gimplify_type_sizes (TREE_TYPE (result_decl
), pre_p
);
1538 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1539 should be effectively allocated by the caller, i.e. all calls to
1540 this function must be subject to the Return Slot Optimization. */
1541 gimplify_one_sizepos (&DECL_SIZE (result_decl
), pre_p
);
1542 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl
), pre_p
);
1544 result
= result_decl
;
1546 else if (gimplify_ctxp
->return_temp
)
1547 result
= gimplify_ctxp
->return_temp
;
1550 result
= create_tmp_reg (TREE_TYPE (result_decl
));
1552 /* ??? With complex control flow (usually involving abnormal edges),
1553 we can wind up warning about an uninitialized value for this. Due
1554 to how this variable is constructed and initialized, this is never
1555 true. Give up and never warn. */
1556 TREE_NO_WARNING (result
) = 1;
1558 gimplify_ctxp
->return_temp
= result
;
1561 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1562 Then gimplify the whole thing. */
1563 if (result
!= result_decl
)
1564 TREE_OPERAND (ret_expr
, 0) = result
;
1566 gimplify_and_add (TREE_OPERAND (stmt
, 0), pre_p
);
1568 maybe_add_early_return_predict_stmt (pre_p
);
1569 ret
= gimple_build_return (result
);
1570 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1571 gimplify_seq_add_stmt (pre_p
, ret
);
1576 /* Gimplify a variable-length array DECL. */
1579 gimplify_vla_decl (tree decl
, gimple_seq
*seq_p
)
1581 /* This is a variable-sized decl. Simplify its size and mark it
1582 for deferred expansion. */
1583 tree t
, addr
, ptr_type
;
1585 gimplify_one_sizepos (&DECL_SIZE (decl
), seq_p
);
1586 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl
), seq_p
);
1588 /* Don't mess with a DECL_VALUE_EXPR set by the front-end. */
1589 if (DECL_HAS_VALUE_EXPR_P (decl
))
1592 /* All occurrences of this decl in final gimplified code will be
1593 replaced by indirection. Setting DECL_VALUE_EXPR does two
1594 things: First, it lets the rest of the gimplifier know what
1595 replacement to use. Second, it lets the debug info know
1596 where to find the value. */
1597 ptr_type
= build_pointer_type (TREE_TYPE (decl
));
1598 addr
= create_tmp_var (ptr_type
, get_name (decl
));
1599 DECL_IGNORED_P (addr
) = 0;
1600 t
= build_fold_indirect_ref (addr
);
1601 TREE_THIS_NOTRAP (t
) = 1;
1602 SET_DECL_VALUE_EXPR (decl
, t
);
1603 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1605 t
= build_alloca_call_expr (DECL_SIZE_UNIT (decl
), DECL_ALIGN (decl
),
1606 max_int_size_in_bytes (TREE_TYPE (decl
)));
1607 /* The call has been built for a variable-sized object. */
1608 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
1609 t
= fold_convert (ptr_type
, t
);
1610 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
1612 gimplify_and_add (t
, seq_p
);
1615 /* A helper function to be called via walk_tree. Mark all labels under *TP
1616 as being forced. To be called for DECL_INITIAL of static variables. */
1619 force_labels_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1623 if (TREE_CODE (*tp
) == LABEL_DECL
)
1625 FORCED_LABEL (*tp
) = 1;
1626 cfun
->has_forced_label_in_static
= 1;
1632 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1633 and initialization explicit. */
1635 static enum gimplify_status
1636 gimplify_decl_expr (tree
*stmt_p
, gimple_seq
*seq_p
)
1638 tree stmt
= *stmt_p
;
1639 tree decl
= DECL_EXPR_DECL (stmt
);
1641 *stmt_p
= NULL_TREE
;
1643 if (TREE_TYPE (decl
) == error_mark_node
)
1646 if ((TREE_CODE (decl
) == TYPE_DECL
1648 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl
)))
1650 gimplify_type_sizes (TREE_TYPE (decl
), seq_p
);
1651 if (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
)
1652 gimplify_type_sizes (TREE_TYPE (TREE_TYPE (decl
)), seq_p
);
1655 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1656 in case its size expressions contain problematic nodes like CALL_EXPR. */
1657 if (TREE_CODE (decl
) == TYPE_DECL
1658 && DECL_ORIGINAL_TYPE (decl
)
1659 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl
)))
1661 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl
), seq_p
);
1662 if (TREE_CODE (DECL_ORIGINAL_TYPE (decl
)) == REFERENCE_TYPE
)
1663 gimplify_type_sizes (TREE_TYPE (DECL_ORIGINAL_TYPE (decl
)), seq_p
);
1666 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
1668 tree init
= DECL_INITIAL (decl
);
1669 bool is_vla
= false;
1671 if (TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1672 || (!TREE_STATIC (decl
)
1673 && flag_stack_check
== GENERIC_STACK_CHECK
1674 && compare_tree_int (DECL_SIZE_UNIT (decl
),
1675 STACK_CHECK_MAX_VAR_SIZE
) > 0))
1677 gimplify_vla_decl (decl
, seq_p
);
1681 if (asan_poisoned_variables
1683 && TREE_ADDRESSABLE (decl
)
1684 && !TREE_STATIC (decl
)
1685 && !DECL_HAS_VALUE_EXPR_P (decl
)
1686 && DECL_ALIGN (decl
) <= MAX_SUPPORTED_STACK_ALIGNMENT
1687 && dbg_cnt (asan_use_after_scope
)
1688 && !gimplify_omp_ctxp
)
1690 asan_poisoned_variables
->add (decl
);
1691 asan_poison_variable (decl
, false, seq_p
);
1692 if (!DECL_ARTIFICIAL (decl
) && gimplify_ctxp
->live_switch_vars
)
1693 gimplify_ctxp
->live_switch_vars
->add (decl
);
1696 /* Some front ends do not explicitly declare all anonymous
1697 artificial variables. We compensate here by declaring the
1698 variables, though it would be better if the front ends would
1699 explicitly declare them. */
1700 if (!DECL_SEEN_IN_BIND_EXPR_P (decl
)
1701 && DECL_ARTIFICIAL (decl
) && DECL_NAME (decl
) == NULL_TREE
)
1702 gimple_add_tmp_var (decl
);
1704 if (init
&& init
!= error_mark_node
)
1706 if (!TREE_STATIC (decl
))
1708 DECL_INITIAL (decl
) = NULL_TREE
;
1709 init
= build2 (INIT_EXPR
, void_type_node
, decl
, init
);
1710 gimplify_and_add (init
, seq_p
);
1714 /* We must still examine initializers for static variables
1715 as they may contain a label address. */
1716 walk_tree (&init
, force_labels_r
, NULL
, NULL
);
1723 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1724 and replacing the LOOP_EXPR with goto, but if the loop contains an
1725 EXIT_EXPR, we need to append a label for it to jump to. */
1727 static enum gimplify_status
1728 gimplify_loop_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1730 tree saved_label
= gimplify_ctxp
->exit_label
;
1731 tree start_label
= create_artificial_label (UNKNOWN_LOCATION
);
1733 gimplify_seq_add_stmt (pre_p
, gimple_build_label (start_label
));
1735 gimplify_ctxp
->exit_label
= NULL_TREE
;
1737 gimplify_and_add (LOOP_EXPR_BODY (*expr_p
), pre_p
);
1739 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (start_label
));
1741 if (gimplify_ctxp
->exit_label
)
1742 gimplify_seq_add_stmt (pre_p
,
1743 gimple_build_label (gimplify_ctxp
->exit_label
));
1745 gimplify_ctxp
->exit_label
= saved_label
;
1751 /* Gimplify a statement list onto a sequence. These may be created either
1752 by an enlightened front-end, or by shortcut_cond_expr. */
1754 static enum gimplify_status
1755 gimplify_statement_list (tree
*expr_p
, gimple_seq
*pre_p
)
1757 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
1759 tree_stmt_iterator i
= tsi_start (*expr_p
);
1761 while (!tsi_end_p (i
))
1763 gimplify_stmt (tsi_stmt_ptr (i
), pre_p
);
1776 /* Callback for walk_gimple_seq. */
1779 warn_switch_unreachable_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
1780 struct walk_stmt_info
*wi
)
1782 gimple
*stmt
= gsi_stmt (*gsi_p
);
1784 *handled_ops_p
= true;
1785 switch (gimple_code (stmt
))
1788 /* A compiler-generated cleanup or a user-written try block.
1789 If it's empty, don't dive into it--that would result in
1790 worse location info. */
1791 if (gimple_try_eval (stmt
) == NULL
)
1794 return integer_zero_node
;
1799 case GIMPLE_EH_FILTER
:
1800 case GIMPLE_TRANSACTION
:
1801 /* Walk the sub-statements. */
1802 *handled_ops_p
= false;
1806 /* Ignore these. We may generate them before declarations that
1807 are never executed. If there's something to warn about,
1808 there will be non-debug stmts too, and we'll catch those. */
1812 if (gimple_call_internal_p (stmt
, IFN_ASAN_MARK
))
1814 *handled_ops_p
= false;
1819 /* Save the first "real" statement (not a decl/lexical scope/...). */
1821 return integer_zero_node
;
1826 /* Possibly warn about unreachable statements between switch's controlling
1827 expression and the first case. SEQ is the body of a switch expression. */
1830 maybe_warn_switch_unreachable (gimple_seq seq
)
1832 if (!warn_switch_unreachable
1833 /* This warning doesn't play well with Fortran when optimizations
1835 || lang_GNU_Fortran ()
1839 struct walk_stmt_info wi
;
1840 memset (&wi
, 0, sizeof (wi
));
1841 walk_gimple_seq (seq
, warn_switch_unreachable_r
, NULL
, &wi
);
1842 gimple
*stmt
= (gimple
*) wi
.info
;
1844 if (stmt
&& gimple_code (stmt
) != GIMPLE_LABEL
)
1846 if (gimple_code (stmt
) == GIMPLE_GOTO
1847 && TREE_CODE (gimple_goto_dest (stmt
)) == LABEL_DECL
1848 && DECL_ARTIFICIAL (gimple_goto_dest (stmt
)))
1849 /* Don't warn for compiler-generated gotos. These occur
1850 in Duff's devices, for example. */;
1852 warning_at (gimple_location (stmt
), OPT_Wswitch_unreachable
,
1853 "statement will never be executed");
1858 /* A label entry that pairs label and a location. */
1865 /* Find LABEL in vector of label entries VEC. */
1867 static struct label_entry
*
1868 find_label_entry (const auto_vec
<struct label_entry
> *vec
, tree label
)
1871 struct label_entry
*l
;
1873 FOR_EACH_VEC_ELT (*vec
, i
, l
)
1874 if (l
->label
== label
)
1879 /* Return true if LABEL, a LABEL_DECL, represents a case label
1880 in a vector of labels CASES. */
1883 case_label_p (const vec
<tree
> *cases
, tree label
)
1888 FOR_EACH_VEC_ELT (*cases
, i
, l
)
1889 if (CASE_LABEL (l
) == label
)
1894 /* Find the last nondebug statement in a scope STMT. */
1897 last_stmt_in_scope (gimple
*stmt
)
1902 switch (gimple_code (stmt
))
1906 gbind
*bind
= as_a
<gbind
*> (stmt
);
1907 stmt
= gimple_seq_last_nondebug_stmt (gimple_bind_body (bind
));
1908 return last_stmt_in_scope (stmt
);
1913 gtry
*try_stmt
= as_a
<gtry
*> (stmt
);
1914 stmt
= gimple_seq_last_nondebug_stmt (gimple_try_eval (try_stmt
));
1915 gimple
*last_eval
= last_stmt_in_scope (stmt
);
1916 if (gimple_stmt_may_fallthru (last_eval
)
1917 && (last_eval
== NULL
1918 || !gimple_call_internal_p (last_eval
, IFN_FALLTHROUGH
))
1919 && gimple_try_kind (try_stmt
) == GIMPLE_TRY_FINALLY
)
1921 stmt
= gimple_seq_last_nondebug_stmt (gimple_try_cleanup (try_stmt
));
1922 return last_stmt_in_scope (stmt
);
1936 /* Collect interesting labels in LABELS and return the statement preceding
1937 another case label, or a user-defined label. */
1940 collect_fallthrough_labels (gimple_stmt_iterator
*gsi_p
,
1941 auto_vec
<struct label_entry
> *labels
)
1943 gimple
*prev
= NULL
;
1947 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_BIND
)
1949 /* Recognize the special GIMPLE_BIND added by gimplify_switch_expr,
1950 which starts on a GIMPLE_SWITCH and ends with a break label.
1951 Handle that as a single statement that can fall through. */
1952 gbind
*bind
= as_a
<gbind
*> (gsi_stmt (*gsi_p
));
1953 gimple
*first
= gimple_seq_first_stmt (gimple_bind_body (bind
));
1954 gimple
*last
= gimple_seq_last_stmt (gimple_bind_body (bind
));
1956 && gimple_code (first
) == GIMPLE_SWITCH
1957 && gimple_code (last
) == GIMPLE_LABEL
)
1959 tree label
= gimple_label_label (as_a
<glabel
*> (last
));
1960 if (SWITCH_BREAK_LABEL_P (label
))
1968 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_BIND
1969 || gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_TRY
)
1971 /* Nested scope. Only look at the last statement of
1972 the innermost scope. */
1973 location_t bind_loc
= gimple_location (gsi_stmt (*gsi_p
));
1974 gimple
*last
= last_stmt_in_scope (gsi_stmt (*gsi_p
));
1978 /* It might be a label without a location. Use the
1979 location of the scope then. */
1980 if (!gimple_has_location (prev
))
1981 gimple_set_location (prev
, bind_loc
);
1987 /* Ifs are tricky. */
1988 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_COND
)
1990 gcond
*cond_stmt
= as_a
<gcond
*> (gsi_stmt (*gsi_p
));
1991 tree false_lab
= gimple_cond_false_label (cond_stmt
);
1992 location_t if_loc
= gimple_location (cond_stmt
);
1995 if (i > 1) goto <D.2259>; else goto D;
1996 we can't do much with the else-branch. */
1997 if (!DECL_ARTIFICIAL (false_lab
))
2000 /* Go on until the false label, then one step back. */
2001 for (; !gsi_end_p (*gsi_p
); gsi_next (gsi_p
))
2003 gimple
*stmt
= gsi_stmt (*gsi_p
);
2004 if (gimple_code (stmt
) == GIMPLE_LABEL
2005 && gimple_label_label (as_a
<glabel
*> (stmt
)) == false_lab
)
2009 /* Not found? Oops. */
2010 if (gsi_end_p (*gsi_p
))
2013 struct label_entry l
= { false_lab
, if_loc
};
2014 labels
->safe_push (l
);
2016 /* Go to the last statement of the then branch. */
2019 /* if (i != 0) goto <D.1759>; else goto <D.1760>;
2025 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_GOTO
2026 && !gimple_has_location (gsi_stmt (*gsi_p
)))
2028 /* Look at the statement before, it might be
2029 attribute fallthrough, in which case don't warn. */
2031 bool fallthru_before_dest
2032 = gimple_call_internal_p (gsi_stmt (*gsi_p
), IFN_FALLTHROUGH
);
2034 tree goto_dest
= gimple_goto_dest (gsi_stmt (*gsi_p
));
2035 if (!fallthru_before_dest
)
2037 struct label_entry l
= { goto_dest
, if_loc
};
2038 labels
->safe_push (l
);
2041 /* And move back. */
2045 /* Remember the last statement. Skip labels that are of no interest
2047 if (gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_LABEL
)
2049 tree label
= gimple_label_label (as_a
<glabel
*> (gsi_stmt (*gsi_p
)));
2050 if (find_label_entry (labels
, label
))
2051 prev
= gsi_stmt (*gsi_p
);
2053 else if (gimple_call_internal_p (gsi_stmt (*gsi_p
), IFN_ASAN_MARK
))
2055 else if (!is_gimple_debug (gsi_stmt (*gsi_p
)))
2056 prev
= gsi_stmt (*gsi_p
);
2059 while (!gsi_end_p (*gsi_p
)
2060 /* Stop if we find a case or a user-defined label. */
2061 && (gimple_code (gsi_stmt (*gsi_p
)) != GIMPLE_LABEL
2062 || !gimple_has_location (gsi_stmt (*gsi_p
))));
2067 /* Return true if the switch fallthough warning should occur. LABEL is
2068 the label statement that we're falling through to. */
2071 should_warn_for_implicit_fallthrough (gimple_stmt_iterator
*gsi_p
, tree label
)
2073 gimple_stmt_iterator gsi
= *gsi_p
;
2075 /* Don't warn if the label is marked with a "falls through" comment. */
2076 if (FALLTHROUGH_LABEL_P (label
))
2079 /* Don't warn for non-case labels followed by a statement:
2084 as these are likely intentional. */
2085 if (!case_label_p (&gimplify_ctxp
->case_labels
, label
))
2088 while (!gsi_end_p (gsi
)
2089 && gimple_code (gsi_stmt (gsi
)) == GIMPLE_LABEL
2090 && (l
= gimple_label_label (as_a
<glabel
*> (gsi_stmt (gsi
))))
2091 && !case_label_p (&gimplify_ctxp
->case_labels
, l
))
2092 gsi_next_nondebug (&gsi
);
2093 if (gsi_end_p (gsi
) || gimple_code (gsi_stmt (gsi
)) != GIMPLE_LABEL
)
2097 /* Don't warn for terminated branches, i.e. when the subsequent case labels
2098 immediately breaks. */
2101 /* Skip all immediately following labels. */
2102 while (!gsi_end_p (gsi
)
2103 && (gimple_code (gsi_stmt (gsi
)) == GIMPLE_LABEL
2104 || gimple_code (gsi_stmt (gsi
)) == GIMPLE_PREDICT
))
2105 gsi_next_nondebug (&gsi
);
2107 /* { ... something; default:; } */
2109 /* { ... something; default: break; } or
2110 { ... something; default: goto L; } */
2111 || gimple_code (gsi_stmt (gsi
)) == GIMPLE_GOTO
2112 /* { ... something; default: return; } */
2113 || gimple_code (gsi_stmt (gsi
)) == GIMPLE_RETURN
)
2119 /* Callback for walk_gimple_seq. */
2122 warn_implicit_fallthrough_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
2123 struct walk_stmt_info
*)
2125 gimple
*stmt
= gsi_stmt (*gsi_p
);
2127 *handled_ops_p
= true;
2128 switch (gimple_code (stmt
))
2133 case GIMPLE_EH_FILTER
:
2134 case GIMPLE_TRANSACTION
:
2135 /* Walk the sub-statements. */
2136 *handled_ops_p
= false;
2139 /* Find a sequence of form:
2146 and possibly warn. */
2149 /* Found a label. Skip all immediately following labels. */
2150 while (!gsi_end_p (*gsi_p
)
2151 && gimple_code (gsi_stmt (*gsi_p
)) == GIMPLE_LABEL
)
2152 gsi_next_nondebug (gsi_p
);
2154 /* There might be no more statements. */
2155 if (gsi_end_p (*gsi_p
))
2156 return integer_zero_node
;
2158 /* Vector of labels that fall through. */
2159 auto_vec
<struct label_entry
> labels
;
2160 gimple
*prev
= collect_fallthrough_labels (gsi_p
, &labels
);
2162 /* There might be no more statements. */
2163 if (gsi_end_p (*gsi_p
))
2164 return integer_zero_node
;
2166 gimple
*next
= gsi_stmt (*gsi_p
);
2168 /* If what follows is a label, then we may have a fallthrough. */
2169 if (gimple_code (next
) == GIMPLE_LABEL
2170 && gimple_has_location (next
)
2171 && (label
= gimple_label_label (as_a
<glabel
*> (next
)))
2174 struct label_entry
*l
;
2175 bool warned_p
= false;
2176 if (!should_warn_for_implicit_fallthrough (gsi_p
, label
))
2178 else if (gimple_code (prev
) == GIMPLE_LABEL
2179 && (label
= gimple_label_label (as_a
<glabel
*> (prev
)))
2180 && (l
= find_label_entry (&labels
, label
)))
2181 warned_p
= warning_at (l
->loc
, OPT_Wimplicit_fallthrough_
,
2182 "this statement may fall through");
2183 else if (!gimple_call_internal_p (prev
, IFN_FALLTHROUGH
)
2184 /* Try to be clever and don't warn when the statement
2185 can't actually fall through. */
2186 && gimple_stmt_may_fallthru (prev
)
2187 && gimple_has_location (prev
))
2188 warned_p
= warning_at (gimple_location (prev
),
2189 OPT_Wimplicit_fallthrough_
,
2190 "this statement may fall through");
2192 inform (gimple_location (next
), "here");
2194 /* Mark this label as processed so as to prevent multiple
2195 warnings in nested switches. */
2196 FALLTHROUGH_LABEL_P (label
) = true;
2198 /* So that next warn_implicit_fallthrough_r will start looking for
2199 a new sequence starting with this label. */
2210 /* Warn when a switch case falls through. */
2213 maybe_warn_implicit_fallthrough (gimple_seq seq
)
2215 if (!warn_implicit_fallthrough
)
2218 /* This warning is meant for C/C++/ObjC/ObjC++ only. */
2221 || lang_GNU_OBJC ()))
2224 struct walk_stmt_info wi
;
2225 memset (&wi
, 0, sizeof (wi
));
2226 walk_gimple_seq (seq
, warn_implicit_fallthrough_r
, NULL
, &wi
);
2229 /* Callback for walk_gimple_seq. */
2232 expand_FALLTHROUGH_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
2233 struct walk_stmt_info
*)
2235 gimple
*stmt
= gsi_stmt (*gsi_p
);
2237 *handled_ops_p
= true;
2238 switch (gimple_code (stmt
))
2243 case GIMPLE_EH_FILTER
:
2244 case GIMPLE_TRANSACTION
:
2245 /* Walk the sub-statements. */
2246 *handled_ops_p
= false;
2249 if (gimple_call_internal_p (stmt
, IFN_FALLTHROUGH
))
2251 gsi_remove (gsi_p
, true);
2252 if (gsi_end_p (*gsi_p
))
2253 return integer_zero_node
;
2256 location_t loc
= gimple_location (stmt
);
2258 gimple_stmt_iterator gsi2
= *gsi_p
;
2259 stmt
= gsi_stmt (gsi2
);
2260 if (gimple_code (stmt
) == GIMPLE_GOTO
&& !gimple_has_location (stmt
))
2262 /* Go on until the artificial label. */
2263 tree goto_dest
= gimple_goto_dest (stmt
);
2264 for (; !gsi_end_p (gsi2
); gsi_next (&gsi2
))
2266 if (gimple_code (gsi_stmt (gsi2
)) == GIMPLE_LABEL
2267 && gimple_label_label (as_a
<glabel
*> (gsi_stmt (gsi2
)))
2272 /* Not found? Stop. */
2273 if (gsi_end_p (gsi2
))
2276 /* Look one past it. */
2280 /* We're looking for a case label or default label here. */
2281 while (!gsi_end_p (gsi2
))
2283 stmt
= gsi_stmt (gsi2
);
2284 if (gimple_code (stmt
) == GIMPLE_LABEL
)
2286 tree label
= gimple_label_label (as_a
<glabel
*> (stmt
));
2287 if (gimple_has_location (stmt
) && DECL_ARTIFICIAL (label
))
2293 else if (gimple_call_internal_p (stmt
, IFN_ASAN_MARK
))
2295 else if (!is_gimple_debug (stmt
))
2296 /* Anything else is not expected. */
2301 warning_at (loc
, 0, "attribute %<fallthrough%> not preceding "
2302 "a case label or default label");
2311 /* Expand all FALLTHROUGH () calls in SEQ. */
2314 expand_FALLTHROUGH (gimple_seq
*seq_p
)
2316 struct walk_stmt_info wi
;
2317 memset (&wi
, 0, sizeof (wi
));
2318 walk_gimple_seq_mod (seq_p
, expand_FALLTHROUGH_r
, NULL
, &wi
);
2322 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
2325 static enum gimplify_status
2326 gimplify_switch_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2328 tree switch_expr
= *expr_p
;
2329 gimple_seq switch_body_seq
= NULL
;
2330 enum gimplify_status ret
;
2331 tree index_type
= TREE_TYPE (switch_expr
);
2332 if (index_type
== NULL_TREE
)
2333 index_type
= TREE_TYPE (SWITCH_COND (switch_expr
));
2335 ret
= gimplify_expr (&SWITCH_COND (switch_expr
), pre_p
, NULL
, is_gimple_val
,
2337 if (ret
== GS_ERROR
|| ret
== GS_UNHANDLED
)
2340 if (SWITCH_BODY (switch_expr
))
2343 vec
<tree
> saved_labels
;
2344 hash_set
<tree
> *saved_live_switch_vars
= NULL
;
2345 tree default_case
= NULL_TREE
;
2346 gswitch
*switch_stmt
;
2348 /* Save old labels, get new ones from body, then restore the old
2349 labels. Save all the things from the switch body to append after. */
2350 saved_labels
= gimplify_ctxp
->case_labels
;
2351 gimplify_ctxp
->case_labels
.create (8);
2353 /* Do not create live_switch_vars if SWITCH_BODY is not a BIND_EXPR. */
2354 saved_live_switch_vars
= gimplify_ctxp
->live_switch_vars
;
2355 tree_code body_type
= TREE_CODE (SWITCH_BODY (switch_expr
));
2356 if (body_type
== BIND_EXPR
|| body_type
== STATEMENT_LIST
)
2357 gimplify_ctxp
->live_switch_vars
= new hash_set
<tree
> (4);
2359 gimplify_ctxp
->live_switch_vars
= NULL
;
2361 bool old_in_switch_expr
= gimplify_ctxp
->in_switch_expr
;
2362 gimplify_ctxp
->in_switch_expr
= true;
2364 gimplify_stmt (&SWITCH_BODY (switch_expr
), &switch_body_seq
);
2366 gimplify_ctxp
->in_switch_expr
= old_in_switch_expr
;
2367 maybe_warn_switch_unreachable (switch_body_seq
);
2368 maybe_warn_implicit_fallthrough (switch_body_seq
);
2369 /* Only do this for the outermost GIMPLE_SWITCH. */
2370 if (!gimplify_ctxp
->in_switch_expr
)
2371 expand_FALLTHROUGH (&switch_body_seq
);
2373 labels
= gimplify_ctxp
->case_labels
;
2374 gimplify_ctxp
->case_labels
= saved_labels
;
2376 if (gimplify_ctxp
->live_switch_vars
)
2378 gcc_assert (gimplify_ctxp
->live_switch_vars
->elements () == 0);
2379 delete gimplify_ctxp
->live_switch_vars
;
2381 gimplify_ctxp
->live_switch_vars
= saved_live_switch_vars
;
2383 preprocess_case_label_vec_for_gimple (labels
, index_type
,
2386 bool add_bind
= false;
2389 glabel
*new_default
;
2392 = build_case_label (NULL_TREE
, NULL_TREE
,
2393 create_artificial_label (UNKNOWN_LOCATION
));
2394 if (old_in_switch_expr
)
2396 SWITCH_BREAK_LABEL_P (CASE_LABEL (default_case
)) = 1;
2399 new_default
= gimple_build_label (CASE_LABEL (default_case
));
2400 gimplify_seq_add_stmt (&switch_body_seq
, new_default
);
2402 else if (old_in_switch_expr
)
2404 gimple
*last
= gimple_seq_last_stmt (switch_body_seq
);
2405 if (last
&& gimple_code (last
) == GIMPLE_LABEL
)
2407 tree label
= gimple_label_label (as_a
<glabel
*> (last
));
2408 if (SWITCH_BREAK_LABEL_P (label
))
2413 switch_stmt
= gimple_build_switch (SWITCH_COND (switch_expr
),
2414 default_case
, labels
);
2415 /* For the benefit of -Wimplicit-fallthrough, if switch_body_seq
2416 ends with a GIMPLE_LABEL holding SWITCH_BREAK_LABEL_P LABEL_DECL,
2417 wrap the GIMPLE_SWITCH up to that GIMPLE_LABEL into a GIMPLE_BIND,
2418 so that we can easily find the start and end of the switch
2422 gimple_seq bind_body
= NULL
;
2423 gimplify_seq_add_stmt (&bind_body
, switch_stmt
);
2424 gimple_seq_add_seq (&bind_body
, switch_body_seq
);
2425 gbind
*bind
= gimple_build_bind (NULL_TREE
, bind_body
, NULL_TREE
);
2426 gimple_set_location (bind
, EXPR_LOCATION (switch_expr
));
2427 gimplify_seq_add_stmt (pre_p
, bind
);
2431 gimplify_seq_add_stmt (pre_p
, switch_stmt
);
2432 gimplify_seq_add_seq (pre_p
, switch_body_seq
);
2442 /* Gimplify the LABEL_EXPR pointed to by EXPR_P. */
2444 static enum gimplify_status
2445 gimplify_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2447 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p
))
2448 == current_function_decl
);
2450 tree label
= LABEL_EXPR_LABEL (*expr_p
);
2451 glabel
*label_stmt
= gimple_build_label (label
);
2452 gimple_set_location (label_stmt
, EXPR_LOCATION (*expr_p
));
2453 gimplify_seq_add_stmt (pre_p
, label_stmt
);
2455 if (lookup_attribute ("cold", DECL_ATTRIBUTES (label
)))
2456 gimple_seq_add_stmt (pre_p
, gimple_build_predict (PRED_COLD_LABEL
,
2458 else if (lookup_attribute ("hot", DECL_ATTRIBUTES (label
)))
2459 gimple_seq_add_stmt (pre_p
, gimple_build_predict (PRED_HOT_LABEL
,
2465 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
2467 static enum gimplify_status
2468 gimplify_case_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2470 struct gimplify_ctx
*ctxp
;
2473 /* Invalid programs can play Duff's Device type games with, for example,
2474 #pragma omp parallel. At least in the C front end, we don't
2475 detect such invalid branches until after gimplification, in the
2476 diagnose_omp_blocks pass. */
2477 for (ctxp
= gimplify_ctxp
; ; ctxp
= ctxp
->prev_context
)
2478 if (ctxp
->case_labels
.exists ())
2481 label_stmt
= gimple_build_label (CASE_LABEL (*expr_p
));
2482 gimple_set_location (label_stmt
, EXPR_LOCATION (*expr_p
));
2483 ctxp
->case_labels
.safe_push (*expr_p
);
2484 gimplify_seq_add_stmt (pre_p
, label_stmt
);
2489 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
2493 build_and_jump (tree
*label_p
)
2495 if (label_p
== NULL
)
2496 /* If there's nowhere to jump, just fall through. */
2499 if (*label_p
== NULL_TREE
)
2501 tree label
= create_artificial_label (UNKNOWN_LOCATION
);
2505 return build1 (GOTO_EXPR
, void_type_node
, *label_p
);
2508 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
2509 This also involves building a label to jump to and communicating it to
2510 gimplify_loop_expr through gimplify_ctxp->exit_label. */
2512 static enum gimplify_status
2513 gimplify_exit_expr (tree
*expr_p
)
2515 tree cond
= TREE_OPERAND (*expr_p
, 0);
2518 expr
= build_and_jump (&gimplify_ctxp
->exit_label
);
2519 expr
= build3 (COND_EXPR
, void_type_node
, cond
, expr
, NULL_TREE
);
2525 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
2526 different from its canonical type, wrap the whole thing inside a
2527 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
2530 The canonical type of a COMPONENT_REF is the type of the field being
2531 referenced--unless the field is a bit-field which can be read directly
2532 in a smaller mode, in which case the canonical type is the
2533 sign-appropriate type corresponding to that mode. */
2536 canonicalize_component_ref (tree
*expr_p
)
2538 tree expr
= *expr_p
;
2541 gcc_assert (TREE_CODE (expr
) == COMPONENT_REF
);
2543 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
2544 type
= TREE_TYPE (get_unwidened (expr
, NULL_TREE
));
2546 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
2548 /* One could argue that all the stuff below is not necessary for
2549 the non-bitfield case and declare it a FE error if type
2550 adjustment would be needed. */
2551 if (TREE_TYPE (expr
) != type
)
2553 #ifdef ENABLE_TYPES_CHECKING
2554 tree old_type
= TREE_TYPE (expr
);
2558 /* We need to preserve qualifiers and propagate them from
2560 type_quals
= TYPE_QUALS (type
)
2561 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr
, 0)));
2562 if (TYPE_QUALS (type
) != type_quals
)
2563 type
= build_qualified_type (TYPE_MAIN_VARIANT (type
), type_quals
);
2565 /* Set the type of the COMPONENT_REF to the underlying type. */
2566 TREE_TYPE (expr
) = type
;
2568 #ifdef ENABLE_TYPES_CHECKING
2569 /* It is now a FE error, if the conversion from the canonical
2570 type to the original expression type is not useless. */
2571 gcc_assert (useless_type_conversion_p (old_type
, type
));
2576 /* If a NOP conversion is changing a pointer to array of foo to a pointer
2577 to foo, embed that change in the ADDR_EXPR by converting
2582 where L is the lower bound. For simplicity, only do this for constant
2584 The constraint is that the type of &array[L] is trivially convertible
2588 canonicalize_addr_expr (tree
*expr_p
)
2590 tree expr
= *expr_p
;
2591 tree addr_expr
= TREE_OPERAND (expr
, 0);
2592 tree datype
, ddatype
, pddatype
;
2594 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
2595 if (!POINTER_TYPE_P (TREE_TYPE (expr
))
2596 || TREE_CODE (addr_expr
) != ADDR_EXPR
)
2599 /* The addr_expr type should be a pointer to an array. */
2600 datype
= TREE_TYPE (TREE_TYPE (addr_expr
));
2601 if (TREE_CODE (datype
) != ARRAY_TYPE
)
2604 /* The pointer to element type shall be trivially convertible to
2605 the expression pointer type. */
2606 ddatype
= TREE_TYPE (datype
);
2607 pddatype
= build_pointer_type (ddatype
);
2608 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)),
2612 /* The lower bound and element sizes must be constant. */
2613 if (!TYPE_SIZE_UNIT (ddatype
)
2614 || TREE_CODE (TYPE_SIZE_UNIT (ddatype
)) != INTEGER_CST
2615 || !TYPE_DOMAIN (datype
) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))
2616 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))) != INTEGER_CST
)
2619 /* All checks succeeded. Build a new node to merge the cast. */
2620 *expr_p
= build4 (ARRAY_REF
, ddatype
, TREE_OPERAND (addr_expr
, 0),
2621 TYPE_MIN_VALUE (TYPE_DOMAIN (datype
)),
2622 NULL_TREE
, NULL_TREE
);
2623 *expr_p
= build1 (ADDR_EXPR
, pddatype
, *expr_p
);
2625 /* We can have stripped a required restrict qualifier above. */
2626 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
2627 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
2630 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
2631 underneath as appropriate. */
2633 static enum gimplify_status
2634 gimplify_conversion (tree
*expr_p
)
2636 location_t loc
= EXPR_LOCATION (*expr_p
);
2637 gcc_assert (CONVERT_EXPR_P (*expr_p
));
2639 /* Then strip away all but the outermost conversion. */
2640 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p
, 0));
2642 /* And remove the outermost conversion if it's useless. */
2643 if (tree_ssa_useless_type_conversion (*expr_p
))
2644 *expr_p
= TREE_OPERAND (*expr_p
, 0);
2646 /* If we still have a conversion at the toplevel,
2647 then canonicalize some constructs. */
2648 if (CONVERT_EXPR_P (*expr_p
))
2650 tree sub
= TREE_OPERAND (*expr_p
, 0);
2652 /* If a NOP conversion is changing the type of a COMPONENT_REF
2653 expression, then canonicalize its type now in order to expose more
2654 redundant conversions. */
2655 if (TREE_CODE (sub
) == COMPONENT_REF
)
2656 canonicalize_component_ref (&TREE_OPERAND (*expr_p
, 0));
2658 /* If a NOP conversion is changing a pointer to array of foo
2659 to a pointer to foo, embed that change in the ADDR_EXPR. */
2660 else if (TREE_CODE (sub
) == ADDR_EXPR
)
2661 canonicalize_addr_expr (expr_p
);
2664 /* If we have a conversion to a non-register type force the
2665 use of a VIEW_CONVERT_EXPR instead. */
2666 if (CONVERT_EXPR_P (*expr_p
) && !is_gimple_reg_type (TREE_TYPE (*expr_p
)))
2667 *expr_p
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (*expr_p
),
2668 TREE_OPERAND (*expr_p
, 0));
2670 /* Canonicalize CONVERT_EXPR to NOP_EXPR. */
2671 if (TREE_CODE (*expr_p
) == CONVERT_EXPR
)
2672 TREE_SET_CODE (*expr_p
, NOP_EXPR
);
2677 /* Nonlocal VLAs seen in the current function. */
2678 static hash_set
<tree
> *nonlocal_vlas
;
2680 /* The VAR_DECLs created for nonlocal VLAs for debug info purposes. */
2681 static tree nonlocal_vla_vars
;
2683 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
2684 DECL_VALUE_EXPR, and it's worth re-examining things. */
2686 static enum gimplify_status
2687 gimplify_var_or_parm_decl (tree
*expr_p
)
2689 tree decl
= *expr_p
;
2691 /* ??? If this is a local variable, and it has not been seen in any
2692 outer BIND_EXPR, then it's probably the result of a duplicate
2693 declaration, for which we've already issued an error. It would
2694 be really nice if the front end wouldn't leak these at all.
2695 Currently the only known culprit is C++ destructors, as seen
2696 in g++.old-deja/g++.jason/binding.C. */
2698 && !DECL_SEEN_IN_BIND_EXPR_P (decl
)
2699 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)
2700 && decl_function_context (decl
) == current_function_decl
)
2702 gcc_assert (seen_error ());
2706 /* When within an OMP context, notice uses of variables. */
2707 if (gimplify_omp_ctxp
&& omp_notice_variable (gimplify_omp_ctxp
, decl
, true))
2710 /* If the decl is an alias for another expression, substitute it now. */
2711 if (DECL_HAS_VALUE_EXPR_P (decl
))
2713 tree value_expr
= DECL_VALUE_EXPR (decl
);
2715 /* For referenced nonlocal VLAs add a decl for debugging purposes
2716 to the current function. */
2718 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
2719 && nonlocal_vlas
!= NULL
2720 && TREE_CODE (value_expr
) == INDIRECT_REF
2721 && TREE_CODE (TREE_OPERAND (value_expr
, 0)) == VAR_DECL
2722 && decl_function_context (decl
) != current_function_decl
)
2724 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
2726 && (ctx
->region_type
== ORT_WORKSHARE
2727 || ctx
->region_type
== ORT_SIMD
2728 || ctx
->region_type
== ORT_ACC
))
2729 ctx
= ctx
->outer_context
;
2730 if (!ctx
&& !nonlocal_vlas
->add (decl
))
2732 tree copy
= copy_node (decl
);
2734 lang_hooks
.dup_lang_specific_decl (copy
);
2735 SET_DECL_RTL (copy
, 0);
2736 TREE_USED (copy
) = 1;
2737 DECL_CHAIN (copy
) = nonlocal_vla_vars
;
2738 nonlocal_vla_vars
= copy
;
2739 SET_DECL_VALUE_EXPR (copy
, unshare_expr (value_expr
));
2740 DECL_HAS_VALUE_EXPR_P (copy
) = 1;
2744 *expr_p
= unshare_expr (value_expr
);
2751 /* Recalculate the value of the TREE_SIDE_EFFECTS flag for T. */
2754 recalculate_side_effects (tree t
)
2756 enum tree_code code
= TREE_CODE (t
);
2757 int len
= TREE_OPERAND_LENGTH (t
);
2760 switch (TREE_CODE_CLASS (code
))
2762 case tcc_expression
:
2768 case PREDECREMENT_EXPR
:
2769 case PREINCREMENT_EXPR
:
2770 case POSTDECREMENT_EXPR
:
2771 case POSTINCREMENT_EXPR
:
2772 /* All of these have side-effects, no matter what their
2781 case tcc_comparison
: /* a comparison expression */
2782 case tcc_unary
: /* a unary arithmetic expression */
2783 case tcc_binary
: /* a binary arithmetic expression */
2784 case tcc_reference
: /* a reference */
2785 case tcc_vl_exp
: /* a function call */
2786 TREE_SIDE_EFFECTS (t
) = TREE_THIS_VOLATILE (t
);
2787 for (i
= 0; i
< len
; ++i
)
2789 tree op
= TREE_OPERAND (t
, i
);
2790 if (op
&& TREE_SIDE_EFFECTS (op
))
2791 TREE_SIDE_EFFECTS (t
) = 1;
2796 /* No side-effects. */
2804 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
2808 : min_lval '[' val ']'
2810 | compound_lval '[' val ']'
2811 | compound_lval '.' ID
2813 This is not part of the original SIMPLE definition, which separates
2814 array and member references, but it seems reasonable to handle them
2815 together. Also, this way we don't run into problems with union
2816 aliasing; gcc requires that for accesses through a union to alias, the
2817 union reference must be explicit, which was not always the case when we
2818 were splitting up array and member refs.
2820 PRE_P points to the sequence where side effects that must happen before
2821 *EXPR_P should be stored.
2823 POST_P points to the sequence where side effects that must happen after
2824 *EXPR_P should be stored. */
2826 static enum gimplify_status
2827 gimplify_compound_lval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2828 fallback_t fallback
)
2831 enum gimplify_status ret
= GS_ALL_DONE
, tret
;
2833 location_t loc
= EXPR_LOCATION (*expr_p
);
2834 tree expr
= *expr_p
;
2836 /* Create a stack of the subexpressions so later we can walk them in
2837 order from inner to outer. */
2838 auto_vec
<tree
, 10> expr_stack
;
2840 /* We can handle anything that get_inner_reference can deal with. */
2841 for (p
= expr_p
; ; p
= &TREE_OPERAND (*p
, 0))
2844 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2845 if (TREE_CODE (*p
) == INDIRECT_REF
)
2846 *p
= fold_indirect_ref_loc (loc
, *p
);
2848 if (handled_component_p (*p
))
2850 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2851 additional COMPONENT_REFs. */
2852 else if ((VAR_P (*p
) || TREE_CODE (*p
) == PARM_DECL
)
2853 && gimplify_var_or_parm_decl (p
) == GS_OK
)
2858 expr_stack
.safe_push (*p
);
2861 gcc_assert (expr_stack
.length ());
2863 /* Now EXPR_STACK is a stack of pointers to all the refs we've
2864 walked through and P points to the innermost expression.
2866 Java requires that we elaborated nodes in source order. That
2867 means we must gimplify the inner expression followed by each of
2868 the indices, in order. But we can't gimplify the inner
2869 expression until we deal with any variable bounds, sizes, or
2870 positions in order to deal with PLACEHOLDER_EXPRs.
2872 So we do this in three steps. First we deal with the annotations
2873 for any variables in the components, then we gimplify the base,
2874 then we gimplify any indices, from left to right. */
2875 for (i
= expr_stack
.length () - 1; i
>= 0; i
--)
2877 tree t
= expr_stack
[i
];
2879 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2881 /* Gimplify the low bound and element type size and put them into
2882 the ARRAY_REF. If these values are set, they have already been
2884 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2886 tree low
= unshare_expr (array_ref_low_bound (t
));
2887 if (!is_gimple_min_invariant (low
))
2889 TREE_OPERAND (t
, 2) = low
;
2890 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2891 post_p
, is_gimple_reg
,
2893 ret
= MIN (ret
, tret
);
2898 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2899 is_gimple_reg
, fb_rvalue
);
2900 ret
= MIN (ret
, tret
);
2903 if (TREE_OPERAND (t
, 3) == NULL_TREE
)
2905 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0)));
2906 tree elmt_size
= unshare_expr (array_ref_element_size (t
));
2907 tree factor
= size_int (TYPE_ALIGN_UNIT (elmt_type
));
2909 /* Divide the element size by the alignment of the element
2912 = size_binop_loc (loc
, EXACT_DIV_EXPR
, elmt_size
, factor
);
2914 if (!is_gimple_min_invariant (elmt_size
))
2916 TREE_OPERAND (t
, 3) = elmt_size
;
2917 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
,
2918 post_p
, is_gimple_reg
,
2920 ret
= MIN (ret
, tret
);
2925 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
, post_p
,
2926 is_gimple_reg
, fb_rvalue
);
2927 ret
= MIN (ret
, tret
);
2930 else if (TREE_CODE (t
) == COMPONENT_REF
)
2932 /* Set the field offset into T and gimplify it. */
2933 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2935 tree offset
= unshare_expr (component_ref_field_offset (t
));
2936 tree field
= TREE_OPERAND (t
, 1);
2938 = size_int (DECL_OFFSET_ALIGN (field
) / BITS_PER_UNIT
);
2940 /* Divide the offset by its alignment. */
2941 offset
= size_binop_loc (loc
, EXACT_DIV_EXPR
, offset
, factor
);
2943 if (!is_gimple_min_invariant (offset
))
2945 TREE_OPERAND (t
, 2) = offset
;
2946 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2947 post_p
, is_gimple_reg
,
2949 ret
= MIN (ret
, tret
);
2954 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2955 is_gimple_reg
, fb_rvalue
);
2956 ret
= MIN (ret
, tret
);
2961 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2962 so as to match the min_lval predicate. Failure to do so may result
2963 in the creation of large aggregate temporaries. */
2964 tret
= gimplify_expr (p
, pre_p
, post_p
, is_gimple_min_lval
,
2965 fallback
| fb_lvalue
);
2966 ret
= MIN (ret
, tret
);
2968 /* And finally, the indices and operands of ARRAY_REF. During this
2969 loop we also remove any useless conversions. */
2970 for (; expr_stack
.length () > 0; )
2972 tree t
= expr_stack
.pop ();
2974 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2976 /* Gimplify the dimension. */
2977 if (!is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
2979 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2980 is_gimple_val
, fb_rvalue
);
2981 ret
= MIN (ret
, tret
);
2985 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t
, 0));
2987 /* The innermost expression P may have originally had
2988 TREE_SIDE_EFFECTS set which would have caused all the outer
2989 expressions in *EXPR_P leading to P to also have had
2990 TREE_SIDE_EFFECTS set. */
2991 recalculate_side_effects (t
);
2994 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2995 if ((fallback
& fb_rvalue
) && TREE_CODE (*expr_p
) == COMPONENT_REF
)
2997 canonicalize_component_ref (expr_p
);
3000 expr_stack
.release ();
3002 gcc_assert (*expr_p
== expr
|| ret
!= GS_ALL_DONE
);
3007 /* Gimplify the self modifying expression pointed to by EXPR_P
3010 PRE_P points to the list where side effects that must happen before
3011 *EXPR_P should be stored.
3013 POST_P points to the list where side effects that must happen after
3014 *EXPR_P should be stored.
3016 WANT_VALUE is nonzero iff we want to use the value of this expression
3017 in another expression.
3019 ARITH_TYPE is the type the computation should be performed in. */
3021 enum gimplify_status
3022 gimplify_self_mod_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3023 bool want_value
, tree arith_type
)
3025 enum tree_code code
;
3026 tree lhs
, lvalue
, rhs
, t1
;
3027 gimple_seq post
= NULL
, *orig_post_p
= post_p
;
3029 enum tree_code arith_code
;
3030 enum gimplify_status ret
;
3031 location_t loc
= EXPR_LOCATION (*expr_p
);
3033 code
= TREE_CODE (*expr_p
);
3035 gcc_assert (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
3036 || code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
);
3038 /* Prefix or postfix? */
3039 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
3040 /* Faster to treat as prefix if result is not used. */
3041 postfix
= want_value
;
3045 /* For postfix, make sure the inner expression's post side effects
3046 are executed after side effects from this expression. */
3050 /* Add or subtract? */
3051 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
3052 arith_code
= PLUS_EXPR
;
3054 arith_code
= MINUS_EXPR
;
3056 /* Gimplify the LHS into a GIMPLE lvalue. */
3057 lvalue
= TREE_OPERAND (*expr_p
, 0);
3058 ret
= gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
3059 if (ret
== GS_ERROR
)
3062 /* Extract the operands to the arithmetic operation. */
3064 rhs
= TREE_OPERAND (*expr_p
, 1);
3066 /* For postfix operator, we evaluate the LHS to an rvalue and then use
3067 that as the result value and in the postqueue operation. */
3070 ret
= gimplify_expr (&lhs
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
3071 if (ret
== GS_ERROR
)
3074 lhs
= get_initialized_tmp_var (lhs
, pre_p
, NULL
);
3077 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
3078 if (POINTER_TYPE_P (TREE_TYPE (lhs
)))
3080 rhs
= convert_to_ptrofftype_loc (loc
, rhs
);
3081 if (arith_code
== MINUS_EXPR
)
3082 rhs
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
3083 t1
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (*expr_p
), lhs
, rhs
);
3086 t1
= fold_convert (TREE_TYPE (*expr_p
),
3087 fold_build2 (arith_code
, arith_type
,
3088 fold_convert (arith_type
, lhs
),
3089 fold_convert (arith_type
, rhs
)));
3093 gimplify_assign (lvalue
, t1
, pre_p
);
3094 gimplify_seq_add_seq (orig_post_p
, post
);
3100 *expr_p
= build2 (MODIFY_EXPR
, TREE_TYPE (lvalue
), lvalue
, t1
);
3105 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
3108 maybe_with_size_expr (tree
*expr_p
)
3110 tree expr
= *expr_p
;
3111 tree type
= TREE_TYPE (expr
);
3114 /* If we've already wrapped this or the type is error_mark_node, we can't do
3116 if (TREE_CODE (expr
) == WITH_SIZE_EXPR
3117 || type
== error_mark_node
)
3120 /* If the size isn't known or is a constant, we have nothing to do. */
3121 size
= TYPE_SIZE_UNIT (type
);
3122 if (!size
|| poly_int_tree_p (size
))
3125 /* Otherwise, make a WITH_SIZE_EXPR. */
3126 size
= unshare_expr (size
);
3127 size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (size
, expr
);
3128 *expr_p
= build2 (WITH_SIZE_EXPR
, type
, expr
, size
);
3131 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
3132 Store any side-effects in PRE_P. CALL_LOCATION is the location of
3133 the CALL_EXPR. If ALLOW_SSA is set the actual parameter may be
3134 gimplified to an SSA name. */
3136 enum gimplify_status
3137 gimplify_arg (tree
*arg_p
, gimple_seq
*pre_p
, location_t call_location
,
3140 bool (*test
) (tree
);
3143 /* In general, we allow lvalues for function arguments to avoid
3144 extra overhead of copying large aggregates out of even larger
3145 aggregates into temporaries only to copy the temporaries to
3146 the argument list. Make optimizers happy by pulling out to
3147 temporaries those types that fit in registers. */
3148 if (is_gimple_reg_type (TREE_TYPE (*arg_p
)))
3149 test
= is_gimple_val
, fb
= fb_rvalue
;
3152 test
= is_gimple_lvalue
, fb
= fb_either
;
3153 /* Also strip a TARGET_EXPR that would force an extra copy. */
3154 if (TREE_CODE (*arg_p
) == TARGET_EXPR
)
3156 tree init
= TARGET_EXPR_INITIAL (*arg_p
);
3158 && !VOID_TYPE_P (TREE_TYPE (init
)))
3163 /* If this is a variable sized type, we must remember the size. */
3164 maybe_with_size_expr (arg_p
);
3166 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
3167 /* Make sure arguments have the same location as the function call
3169 protected_set_expr_location (*arg_p
, call_location
);
3171 /* There is a sequence point before a function call. Side effects in
3172 the argument list must occur before the actual call. So, when
3173 gimplifying arguments, force gimplify_expr to use an internal
3174 post queue which is then appended to the end of PRE_P. */
3175 return gimplify_expr (arg_p
, pre_p
, NULL
, test
, fb
, allow_ssa
);
3178 /* Don't fold inside offloading or taskreg regions: it can break code by
3179 adding decl references that weren't in the source. We'll do it during
3180 omplower pass instead. */
3183 maybe_fold_stmt (gimple_stmt_iterator
*gsi
)
3185 struct gimplify_omp_ctx
*ctx
;
3186 for (ctx
= gimplify_omp_ctxp
; ctx
; ctx
= ctx
->outer_context
)
3187 if ((ctx
->region_type
& (ORT_TARGET
| ORT_PARALLEL
| ORT_TASK
)) != 0)
3189 return fold_stmt (gsi
);
3192 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
3193 WANT_VALUE is true if the result of the call is desired. */
3195 static enum gimplify_status
3196 gimplify_call_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
3198 tree fndecl
, parms
, p
, fnptrtype
;
3199 enum gimplify_status ret
;
3202 bool builtin_va_start_p
= false;
3203 location_t loc
= EXPR_LOCATION (*expr_p
);
3205 gcc_assert (TREE_CODE (*expr_p
) == CALL_EXPR
);
3207 /* For reliable diagnostics during inlining, it is necessary that
3208 every call_expr be annotated with file and line. */
3209 if (! EXPR_HAS_LOCATION (*expr_p
))
3210 SET_EXPR_LOCATION (*expr_p
, input_location
);
3212 /* Gimplify internal functions created in the FEs. */
3213 if (CALL_EXPR_FN (*expr_p
) == NULL_TREE
)
3218 nargs
= call_expr_nargs (*expr_p
);
3219 enum internal_fn ifn
= CALL_EXPR_IFN (*expr_p
);
3220 auto_vec
<tree
> vargs (nargs
);
3222 for (i
= 0; i
< nargs
; i
++)
3224 gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
3225 EXPR_LOCATION (*expr_p
));
3226 vargs
.quick_push (CALL_EXPR_ARG (*expr_p
, i
));
3229 gcall
*call
= gimple_build_call_internal_vec (ifn
, vargs
);
3230 gimple_call_set_nothrow (call
, TREE_NOTHROW (*expr_p
));
3231 gimplify_seq_add_stmt (pre_p
, call
);
3235 /* This may be a call to a builtin function.
3237 Builtin function calls may be transformed into different
3238 (and more efficient) builtin function calls under certain
3239 circumstances. Unfortunately, gimplification can muck things
3240 up enough that the builtin expanders are not aware that certain
3241 transformations are still valid.
3243 So we attempt transformation/gimplification of the call before
3244 we gimplify the CALL_EXPR. At this time we do not manage to
3245 transform all calls in the same manner as the expanders do, but
3246 we do transform most of them. */
3247 fndecl
= get_callee_fndecl (*expr_p
);
3249 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
3250 switch (DECL_FUNCTION_CODE (fndecl
))
3252 CASE_BUILT_IN_ALLOCA
:
3253 /* If the call has been built for a variable-sized object, then we
3254 want to restore the stack level when the enclosing BIND_EXPR is
3255 exited to reclaim the allocated space; otherwise, we precisely
3256 need to do the opposite and preserve the latest stack level. */
3257 if (CALL_ALLOCA_FOR_VAR_P (*expr_p
))
3258 gimplify_ctxp
->save_stack
= true;
3260 gimplify_ctxp
->keep_stack
= true;
3263 case BUILT_IN_VA_START
:
3265 builtin_va_start_p
= TRUE
;
3266 if (call_expr_nargs (*expr_p
) < 2)
3268 error ("too few arguments to function %<va_start%>");
3269 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
3273 if (fold_builtin_next_arg (*expr_p
, true))
3275 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
3284 if (fndecl
&& DECL_BUILT_IN (fndecl
))
3286 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
3287 if (new_tree
&& new_tree
!= *expr_p
)
3289 /* There was a transformation of this call which computes the
3290 same value, but in a more efficient way. Return and try
3297 /* Remember the original function pointer type. */
3298 fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*expr_p
));
3300 /* There is a sequence point before the call, so any side effects in
3301 the calling expression must occur before the actual call. Force
3302 gimplify_expr to use an internal post queue. */
3303 ret
= gimplify_expr (&CALL_EXPR_FN (*expr_p
), pre_p
, NULL
,
3304 is_gimple_call_addr
, fb_rvalue
);
3306 nargs
= call_expr_nargs (*expr_p
);
3308 /* Get argument types for verification. */
3309 fndecl
= get_callee_fndecl (*expr_p
);
3312 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
3314 parms
= TYPE_ARG_TYPES (TREE_TYPE (fnptrtype
));
3316 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
3317 p
= DECL_ARGUMENTS (fndecl
);
3322 for (i
= 0; i
< nargs
&& p
; i
++, p
= TREE_CHAIN (p
))
3325 /* If the last argument is __builtin_va_arg_pack () and it is not
3326 passed as a named argument, decrease the number of CALL_EXPR
3327 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
3330 && TREE_CODE (CALL_EXPR_ARG (*expr_p
, nargs
- 1)) == CALL_EXPR
)
3332 tree last_arg
= CALL_EXPR_ARG (*expr_p
, nargs
- 1);
3333 tree last_arg_fndecl
= get_callee_fndecl (last_arg
);
3336 && TREE_CODE (last_arg_fndecl
) == FUNCTION_DECL
3337 && DECL_BUILT_IN_CLASS (last_arg_fndecl
) == BUILT_IN_NORMAL
3338 && DECL_FUNCTION_CODE (last_arg_fndecl
) == BUILT_IN_VA_ARG_PACK
)
3340 tree call
= *expr_p
;
3343 *expr_p
= build_call_array_loc (loc
, TREE_TYPE (call
),
3344 CALL_EXPR_FN (call
),
3345 nargs
, CALL_EXPR_ARGP (call
));
3347 /* Copy all CALL_EXPR flags, location and block, except
3348 CALL_EXPR_VA_ARG_PACK flag. */
3349 CALL_EXPR_STATIC_CHAIN (*expr_p
) = CALL_EXPR_STATIC_CHAIN (call
);
3350 CALL_EXPR_TAILCALL (*expr_p
) = CALL_EXPR_TAILCALL (call
);
3351 CALL_EXPR_RETURN_SLOT_OPT (*expr_p
)
3352 = CALL_EXPR_RETURN_SLOT_OPT (call
);
3353 CALL_FROM_THUNK_P (*expr_p
) = CALL_FROM_THUNK_P (call
);
3354 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (call
));
3356 /* Set CALL_EXPR_VA_ARG_PACK. */
3357 CALL_EXPR_VA_ARG_PACK (*expr_p
) = 1;
3361 /* If the call returns twice then after building the CFG the call
3362 argument computations will no longer dominate the call because
3363 we add an abnormal incoming edge to the call. So do not use SSA
3365 bool returns_twice
= call_expr_flags (*expr_p
) & ECF_RETURNS_TWICE
;
3367 /* Gimplify the function arguments. */
3370 for (i
= (PUSH_ARGS_REVERSED
? nargs
- 1 : 0);
3371 PUSH_ARGS_REVERSED
? i
>= 0 : i
< nargs
;
3372 PUSH_ARGS_REVERSED
? i
-- : i
++)
3374 enum gimplify_status t
;
3376 /* Avoid gimplifying the second argument to va_start, which needs to
3377 be the plain PARM_DECL. */
3378 if ((i
!= 1) || !builtin_va_start_p
)
3380 t
= gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
3381 EXPR_LOCATION (*expr_p
), ! returns_twice
);
3389 /* Gimplify the static chain. */
3390 if (CALL_EXPR_STATIC_CHAIN (*expr_p
))
3392 if (fndecl
&& !DECL_STATIC_CHAIN (fndecl
))
3393 CALL_EXPR_STATIC_CHAIN (*expr_p
) = NULL
;
3396 enum gimplify_status t
;
3397 t
= gimplify_arg (&CALL_EXPR_STATIC_CHAIN (*expr_p
), pre_p
,
3398 EXPR_LOCATION (*expr_p
), ! returns_twice
);
3404 /* Verify the function result. */
3405 if (want_value
&& fndecl
3406 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype
))))
3408 error_at (loc
, "using result of function returning %<void%>");
3412 /* Try this again in case gimplification exposed something. */
3413 if (ret
!= GS_ERROR
)
3415 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
3417 if (new_tree
&& new_tree
!= *expr_p
)
3419 /* There was a transformation of this call which computes the
3420 same value, but in a more efficient way. Return and try
3428 *expr_p
= error_mark_node
;
3432 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
3433 decl. This allows us to eliminate redundant or useless
3434 calls to "const" functions. */
3435 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
3437 int flags
= call_expr_flags (*expr_p
);
3438 if (flags
& (ECF_CONST
| ECF_PURE
)
3439 /* An infinite loop is considered a side effect. */
3440 && !(flags
& (ECF_LOOPING_CONST_OR_PURE
)))
3441 TREE_SIDE_EFFECTS (*expr_p
) = 0;
3444 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
3445 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
3446 form and delegate the creation of a GIMPLE_CALL to
3447 gimplify_modify_expr. This is always possible because when
3448 WANT_VALUE is true, the caller wants the result of this call into
3449 a temporary, which means that we will emit an INIT_EXPR in
3450 internal_get_tmp_var which will then be handled by
3451 gimplify_modify_expr. */
3454 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
3455 have to do is replicate it as a GIMPLE_CALL tuple. */
3456 gimple_stmt_iterator gsi
;
3457 call
= gimple_build_call_from_tree (*expr_p
, fnptrtype
);
3458 notice_special_calls (call
);
3459 gimplify_seq_add_stmt (pre_p
, call
);
3460 gsi
= gsi_last (*pre_p
);
3461 maybe_fold_stmt (&gsi
);
3462 *expr_p
= NULL_TREE
;
3465 /* Remember the original function type. */
3466 CALL_EXPR_FN (*expr_p
) = build1 (NOP_EXPR
, fnptrtype
,
3467 CALL_EXPR_FN (*expr_p
));
3472 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
3473 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
3475 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
3476 condition is true or false, respectively. If null, we should generate
3477 our own to skip over the evaluation of this specific expression.
3479 LOCUS is the source location of the COND_EXPR.
3481 This function is the tree equivalent of do_jump.
3483 shortcut_cond_r should only be called by shortcut_cond_expr. */
3486 shortcut_cond_r (tree pred
, tree
*true_label_p
, tree
*false_label_p
,
3489 tree local_label
= NULL_TREE
;
3490 tree t
, expr
= NULL
;
3492 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
3493 retain the shortcut semantics. Just insert the gotos here;
3494 shortcut_cond_expr will append the real blocks later. */
3495 if (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
3497 location_t new_locus
;
3499 /* Turn if (a && b) into
3501 if (a); else goto no;
3502 if (b) goto yes; else goto no;
3505 if (false_label_p
== NULL
)
3506 false_label_p
= &local_label
;
3508 /* Keep the original source location on the first 'if'. */
3509 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), NULL
, false_label_p
, locus
);
3510 append_to_statement_list (t
, &expr
);
3512 /* Set the source location of the && on the second 'if'. */
3513 new_locus
= rexpr_location (pred
, locus
);
3514 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
3516 append_to_statement_list (t
, &expr
);
3518 else if (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
3520 location_t new_locus
;
3522 /* Turn if (a || b) into
3525 if (b) goto yes; else goto no;
3528 if (true_label_p
== NULL
)
3529 true_label_p
= &local_label
;
3531 /* Keep the original source location on the first 'if'. */
3532 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), true_label_p
, NULL
, locus
);
3533 append_to_statement_list (t
, &expr
);
3535 /* Set the source location of the || on the second 'if'. */
3536 new_locus
= rexpr_location (pred
, locus
);
3537 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
3539 append_to_statement_list (t
, &expr
);
3541 else if (TREE_CODE (pred
) == COND_EXPR
3542 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 1)))
3543 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 2))))
3545 location_t new_locus
;
3547 /* As long as we're messing with gotos, turn if (a ? b : c) into
3549 if (b) goto yes; else goto no;
3551 if (c) goto yes; else goto no;
3553 Don't do this if one of the arms has void type, which can happen
3554 in C++ when the arm is throw. */
3556 /* Keep the original source location on the first 'if'. Set the source
3557 location of the ? on the second 'if'. */
3558 new_locus
= rexpr_location (pred
, locus
);
3559 expr
= build3 (COND_EXPR
, void_type_node
, TREE_OPERAND (pred
, 0),
3560 shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
,
3561 false_label_p
, locus
),
3562 shortcut_cond_r (TREE_OPERAND (pred
, 2), true_label_p
,
3563 false_label_p
, new_locus
));
3567 expr
= build3 (COND_EXPR
, void_type_node
, pred
,
3568 build_and_jump (true_label_p
),
3569 build_and_jump (false_label_p
));
3570 SET_EXPR_LOCATION (expr
, locus
);
3575 t
= build1 (LABEL_EXPR
, void_type_node
, local_label
);
3576 append_to_statement_list (t
, &expr
);
3582 /* If EXPR is a GOTO_EXPR, return it. If it is a STATEMENT_LIST, skip
3583 any of its leading DEBUG_BEGIN_STMTS and recurse on the subsequent
3584 statement, if it is the last one. Otherwise, return NULL. */
3587 find_goto (tree expr
)
3592 if (TREE_CODE (expr
) == GOTO_EXPR
)
3595 if (TREE_CODE (expr
) != STATEMENT_LIST
)
3598 tree_stmt_iterator i
= tsi_start (expr
);
3600 while (!tsi_end_p (i
) && TREE_CODE (tsi_stmt (i
)) == DEBUG_BEGIN_STMT
)
3603 if (!tsi_one_before_end_p (i
))
3606 return find_goto (tsi_stmt (i
));
3609 /* Same as find_goto, except that it returns NULL if the destination
3610 is not a LABEL_DECL. */
3613 find_goto_label (tree expr
)
3615 tree dest
= find_goto (expr
);
3616 if (dest
&& TREE_CODE (GOTO_DESTINATION (dest
)) == LABEL_DECL
)
3621 /* Given a conditional expression EXPR with short-circuit boolean
3622 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
3623 predicate apart into the equivalent sequence of conditionals. */
3626 shortcut_cond_expr (tree expr
)
3628 tree pred
= TREE_OPERAND (expr
, 0);
3629 tree then_
= TREE_OPERAND (expr
, 1);
3630 tree else_
= TREE_OPERAND (expr
, 2);
3631 tree true_label
, false_label
, end_label
, t
;
3633 tree
*false_label_p
;
3634 bool emit_end
, emit_false
, jump_over_else
;
3635 bool then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
3636 bool else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
3638 /* First do simple transformations. */
3641 /* If there is no 'else', turn
3644 if (a) if (b) then c. */
3645 while (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
3647 /* Keep the original source location on the first 'if'. */
3648 location_t locus
= EXPR_LOC_OR_LOC (expr
, input_location
);
3649 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
3650 /* Set the source location of the && on the second 'if'. */
3651 if (rexpr_has_location (pred
))
3652 SET_EXPR_LOCATION (expr
, rexpr_location (pred
));
3653 then_
= shortcut_cond_expr (expr
);
3654 then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
3655 pred
= TREE_OPERAND (pred
, 0);
3656 expr
= build3 (COND_EXPR
, void_type_node
, pred
, then_
, NULL_TREE
);
3657 SET_EXPR_LOCATION (expr
, locus
);
3663 /* If there is no 'then', turn
3666 if (a); else if (b); else d. */
3667 while (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
3669 /* Keep the original source location on the first 'if'. */
3670 location_t locus
= EXPR_LOC_OR_LOC (expr
, input_location
);
3671 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
3672 /* Set the source location of the || on the second 'if'. */
3673 if (rexpr_has_location (pred
))
3674 SET_EXPR_LOCATION (expr
, rexpr_location (pred
));
3675 else_
= shortcut_cond_expr (expr
);
3676 else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
3677 pred
= TREE_OPERAND (pred
, 0);
3678 expr
= build3 (COND_EXPR
, void_type_node
, pred
, NULL_TREE
, else_
);
3679 SET_EXPR_LOCATION (expr
, locus
);
3683 /* If we're done, great. */
3684 if (TREE_CODE (pred
) != TRUTH_ANDIF_EXPR
3685 && TREE_CODE (pred
) != TRUTH_ORIF_EXPR
)
3688 /* Otherwise we need to mess with gotos. Change
3691 if (a); else goto no;
3694 and recursively gimplify the condition. */
3696 true_label
= false_label
= end_label
= NULL_TREE
;
3698 /* If our arms just jump somewhere, hijack those labels so we don't
3699 generate jumps to jumps. */
3701 if (tree then_goto
= find_goto_label (then_
))
3703 true_label
= GOTO_DESTINATION (then_goto
);
3708 if (tree else_goto
= find_goto_label (else_
))
3710 false_label
= GOTO_DESTINATION (else_goto
);
3715 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
3717 true_label_p
= &true_label
;
3719 true_label_p
= NULL
;
3721 /* The 'else' branch also needs a label if it contains interesting code. */
3722 if (false_label
|| else_se
)
3723 false_label_p
= &false_label
;
3725 false_label_p
= NULL
;
3727 /* If there was nothing else in our arms, just forward the label(s). */
3728 if (!then_se
&& !else_se
)
3729 return shortcut_cond_r (pred
, true_label_p
, false_label_p
,
3730 EXPR_LOC_OR_LOC (expr
, input_location
));
3732 /* If our last subexpression already has a terminal label, reuse it. */
3734 t
= expr_last (else_
);
3736 t
= expr_last (then_
);
3739 if (t
&& TREE_CODE (t
) == LABEL_EXPR
)
3740 end_label
= LABEL_EXPR_LABEL (t
);
3742 /* If we don't care about jumping to the 'else' branch, jump to the end
3743 if the condition is false. */
3745 false_label_p
= &end_label
;
3747 /* We only want to emit these labels if we aren't hijacking them. */
3748 emit_end
= (end_label
== NULL_TREE
);
3749 emit_false
= (false_label
== NULL_TREE
);
3751 /* We only emit the jump over the else clause if we have to--if the
3752 then clause may fall through. Otherwise we can wind up with a
3753 useless jump and a useless label at the end of gimplified code,
3754 which will cause us to think that this conditional as a whole
3755 falls through even if it doesn't. If we then inline a function
3756 which ends with such a condition, that can cause us to issue an
3757 inappropriate warning about control reaching the end of a
3758 non-void function. */
3759 jump_over_else
= block_may_fallthru (then_
);
3761 pred
= shortcut_cond_r (pred
, true_label_p
, false_label_p
,
3762 EXPR_LOC_OR_LOC (expr
, input_location
));
3765 append_to_statement_list (pred
, &expr
);
3767 append_to_statement_list (then_
, &expr
);
3772 tree last
= expr_last (expr
);
3773 t
= build_and_jump (&end_label
);
3774 if (rexpr_has_location (last
))
3775 SET_EXPR_LOCATION (t
, rexpr_location (last
));
3776 append_to_statement_list (t
, &expr
);
3780 t
= build1 (LABEL_EXPR
, void_type_node
, false_label
);
3781 append_to_statement_list (t
, &expr
);
3783 append_to_statement_list (else_
, &expr
);
3785 if (emit_end
&& end_label
)
3787 t
= build1 (LABEL_EXPR
, void_type_node
, end_label
);
3788 append_to_statement_list (t
, &expr
);
3794 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
3797 gimple_boolify (tree expr
)
3799 tree type
= TREE_TYPE (expr
);
3800 location_t loc
= EXPR_LOCATION (expr
);
3802 if (TREE_CODE (expr
) == NE_EXPR
3803 && TREE_CODE (TREE_OPERAND (expr
, 0)) == CALL_EXPR
3804 && integer_zerop (TREE_OPERAND (expr
, 1)))
3806 tree call
= TREE_OPERAND (expr
, 0);
3807 tree fn
= get_callee_fndecl (call
);
3809 /* For __builtin_expect ((long) (x), y) recurse into x as well
3810 if x is truth_value_p. */
3812 && DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
3813 && DECL_FUNCTION_CODE (fn
) == BUILT_IN_EXPECT
3814 && call_expr_nargs (call
) == 2)
3816 tree arg
= CALL_EXPR_ARG (call
, 0);
3819 if (TREE_CODE (arg
) == NOP_EXPR
3820 && TREE_TYPE (arg
) == TREE_TYPE (call
))
3821 arg
= TREE_OPERAND (arg
, 0);
3822 if (truth_value_p (TREE_CODE (arg
)))
3824 arg
= gimple_boolify (arg
);
3825 CALL_EXPR_ARG (call
, 0)
3826 = fold_convert_loc (loc
, TREE_TYPE (call
), arg
);
3832 switch (TREE_CODE (expr
))
3834 case TRUTH_AND_EXPR
:
3836 case TRUTH_XOR_EXPR
:
3837 case TRUTH_ANDIF_EXPR
:
3838 case TRUTH_ORIF_EXPR
:
3839 /* Also boolify the arguments of truth exprs. */
3840 TREE_OPERAND (expr
, 1) = gimple_boolify (TREE_OPERAND (expr
, 1));
3843 case TRUTH_NOT_EXPR
:
3844 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3846 /* These expressions always produce boolean results. */
3847 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3848 TREE_TYPE (expr
) = boolean_type_node
;
3852 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (expr
, 1)))
3854 case annot_expr_ivdep_kind
:
3855 case annot_expr_unroll_kind
:
3856 case annot_expr_no_vector_kind
:
3857 case annot_expr_vector_kind
:
3858 case annot_expr_parallel_kind
:
3859 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3860 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3861 TREE_TYPE (expr
) = boolean_type_node
;
3868 if (COMPARISON_CLASS_P (expr
))
3870 /* There expressions always prduce boolean results. */
3871 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3872 TREE_TYPE (expr
) = boolean_type_node
;
3875 /* Other expressions that get here must have boolean values, but
3876 might need to be converted to the appropriate mode. */
3877 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
3879 return fold_convert_loc (loc
, boolean_type_node
, expr
);
3883 /* Given a conditional expression *EXPR_P without side effects, gimplify
3884 its operands. New statements are inserted to PRE_P. */
3886 static enum gimplify_status
3887 gimplify_pure_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
)
3889 tree expr
= *expr_p
, cond
;
3890 enum gimplify_status ret
, tret
;
3891 enum tree_code code
;
3893 cond
= gimple_boolify (COND_EXPR_COND (expr
));
3895 /* We need to handle && and || specially, as their gimplification
3896 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
3897 code
= TREE_CODE (cond
);
3898 if (code
== TRUTH_ANDIF_EXPR
)
3899 TREE_SET_CODE (cond
, TRUTH_AND_EXPR
);
3900 else if (code
== TRUTH_ORIF_EXPR
)
3901 TREE_SET_CODE (cond
, TRUTH_OR_EXPR
);
3902 ret
= gimplify_expr (&cond
, pre_p
, NULL
, is_gimple_condexpr
, fb_rvalue
);
3903 COND_EXPR_COND (*expr_p
) = cond
;
3905 tret
= gimplify_expr (&COND_EXPR_THEN (expr
), pre_p
, NULL
,
3906 is_gimple_val
, fb_rvalue
);
3907 ret
= MIN (ret
, tret
);
3908 tret
= gimplify_expr (&COND_EXPR_ELSE (expr
), pre_p
, NULL
,
3909 is_gimple_val
, fb_rvalue
);
3911 return MIN (ret
, tret
);
3914 /* Return true if evaluating EXPR could trap.
3915 EXPR is GENERIC, while tree_could_trap_p can be called
3919 generic_expr_could_trap_p (tree expr
)
3923 if (!expr
|| is_gimple_val (expr
))
3926 if (!EXPR_P (expr
) || tree_could_trap_p (expr
))
3929 n
= TREE_OPERAND_LENGTH (expr
);
3930 for (i
= 0; i
< n
; i
++)
3931 if (generic_expr_could_trap_p (TREE_OPERAND (expr
, i
)))
3937 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3946 The second form is used when *EXPR_P is of type void.
3948 PRE_P points to the list where side effects that must happen before
3949 *EXPR_P should be stored. */
3951 static enum gimplify_status
3952 gimplify_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
, fallback_t fallback
)
3954 tree expr
= *expr_p
;
3955 tree type
= TREE_TYPE (expr
);
3956 location_t loc
= EXPR_LOCATION (expr
);
3957 tree tmp
, arm1
, arm2
;
3958 enum gimplify_status ret
;
3959 tree label_true
, label_false
, label_cont
;
3960 bool have_then_clause_p
, have_else_clause_p
;
3962 enum tree_code pred_code
;
3963 gimple_seq seq
= NULL
;
3965 /* If this COND_EXPR has a value, copy the values into a temporary within
3967 if (!VOID_TYPE_P (type
))
3969 tree then_
= TREE_OPERAND (expr
, 1), else_
= TREE_OPERAND (expr
, 2);
3972 /* If either an rvalue is ok or we do not require an lvalue, create the
3973 temporary. But we cannot do that if the type is addressable. */
3974 if (((fallback
& fb_rvalue
) || !(fallback
& fb_lvalue
))
3975 && !TREE_ADDRESSABLE (type
))
3977 if (gimplify_ctxp
->allow_rhs_cond_expr
3978 /* If either branch has side effects or could trap, it can't be
3979 evaluated unconditionally. */
3980 && !TREE_SIDE_EFFECTS (then_
)
3981 && !generic_expr_could_trap_p (then_
)
3982 && !TREE_SIDE_EFFECTS (else_
)
3983 && !generic_expr_could_trap_p (else_
))
3984 return gimplify_pure_cond_expr (expr_p
, pre_p
);
3986 tmp
= create_tmp_var (type
, "iftmp");
3990 /* Otherwise, only create and copy references to the values. */
3993 type
= build_pointer_type (type
);
3995 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3996 then_
= build_fold_addr_expr_loc (loc
, then_
);
3998 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3999 else_
= build_fold_addr_expr_loc (loc
, else_
);
4002 = build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0), then_
, else_
);
4004 tmp
= create_tmp_var (type
, "iftmp");
4005 result
= build_simple_mem_ref_loc (loc
, tmp
);
4008 /* Build the new then clause, `tmp = then_;'. But don't build the
4009 assignment if the value is void; in C++ it can be if it's a throw. */
4010 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
4011 TREE_OPERAND (expr
, 1) = build2 (MODIFY_EXPR
, type
, tmp
, then_
);
4013 /* Similarly, build the new else clause, `tmp = else_;'. */
4014 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
4015 TREE_OPERAND (expr
, 2) = build2 (MODIFY_EXPR
, type
, tmp
, else_
);
4017 TREE_TYPE (expr
) = void_type_node
;
4018 recalculate_side_effects (expr
);
4020 /* Move the COND_EXPR to the prequeue. */
4021 gimplify_stmt (&expr
, pre_p
);
4027 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
4028 STRIP_TYPE_NOPS (TREE_OPERAND (expr
, 0));
4029 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == COMPOUND_EXPR
)
4030 gimplify_compound_expr (&TREE_OPERAND (expr
, 0), pre_p
, true);
4032 /* Make sure the condition has BOOLEAN_TYPE. */
4033 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
4035 /* Break apart && and || conditions. */
4036 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ANDIF_EXPR
4037 || TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ORIF_EXPR
)
4039 expr
= shortcut_cond_expr (expr
);
4041 if (expr
!= *expr_p
)
4045 /* We can't rely on gimplify_expr to re-gimplify the expanded
4046 form properly, as cleanups might cause the target labels to be
4047 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
4048 set up a conditional context. */
4049 gimple_push_condition ();
4050 gimplify_stmt (expr_p
, &seq
);
4051 gimple_pop_condition (pre_p
);
4052 gimple_seq_add_seq (pre_p
, seq
);
4058 /* Now do the normal gimplification. */
4060 /* Gimplify condition. */
4061 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, NULL
, is_gimple_condexpr
,
4063 if (ret
== GS_ERROR
)
4065 gcc_assert (TREE_OPERAND (expr
, 0) != NULL_TREE
);
4067 gimple_push_condition ();
4069 have_then_clause_p
= have_else_clause_p
= false;
4070 label_true
= find_goto_label (TREE_OPERAND (expr
, 1));
4072 && DECL_CONTEXT (GOTO_DESTINATION (label_true
)) == current_function_decl
4073 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
4074 have different locations, otherwise we end up with incorrect
4075 location information on the branches. */
4077 || !EXPR_HAS_LOCATION (expr
)
4078 || !rexpr_has_location (label_true
)
4079 || EXPR_LOCATION (expr
) == rexpr_location (label_true
)))
4081 have_then_clause_p
= true;
4082 label_true
= GOTO_DESTINATION (label_true
);
4085 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
4086 label_false
= find_goto_label (TREE_OPERAND (expr
, 2));
4088 && DECL_CONTEXT (GOTO_DESTINATION (label_false
)) == current_function_decl
4089 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
4090 have different locations, otherwise we end up with incorrect
4091 location information on the branches. */
4093 || !EXPR_HAS_LOCATION (expr
)
4094 || !rexpr_has_location (label_false
)
4095 || EXPR_LOCATION (expr
) == rexpr_location (label_false
)))
4097 have_else_clause_p
= true;
4098 label_false
= GOTO_DESTINATION (label_false
);
4101 label_false
= create_artificial_label (UNKNOWN_LOCATION
);
4103 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr
), &pred_code
, &arm1
,
4105 cond_stmt
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
,
4107 gimple_set_no_warning (cond_stmt
, TREE_NO_WARNING (COND_EXPR_COND (expr
)));
4108 gimplify_seq_add_stmt (&seq
, cond_stmt
);
4109 gimple_stmt_iterator gsi
= gsi_last (seq
);
4110 maybe_fold_stmt (&gsi
);
4112 label_cont
= NULL_TREE
;
4113 if (!have_then_clause_p
)
4115 /* For if (...) {} else { code; } put label_true after
4117 if (TREE_OPERAND (expr
, 1) == NULL_TREE
4118 && !have_else_clause_p
4119 && TREE_OPERAND (expr
, 2) != NULL_TREE
)
4120 label_cont
= label_true
;
4123 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_true
));
4124 have_then_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 1), &seq
);
4125 /* For if (...) { code; } else {} or
4126 if (...) { code; } else goto label; or
4127 if (...) { code; return; } else { ... }
4128 label_cont isn't needed. */
4129 if (!have_else_clause_p
4130 && TREE_OPERAND (expr
, 2) != NULL_TREE
4131 && gimple_seq_may_fallthru (seq
))
4134 label_cont
= create_artificial_label (UNKNOWN_LOCATION
);
4136 g
= gimple_build_goto (label_cont
);
4138 /* GIMPLE_COND's are very low level; they have embedded
4139 gotos. This particular embedded goto should not be marked
4140 with the location of the original COND_EXPR, as it would
4141 correspond to the COND_EXPR's condition, not the ELSE or the
4142 THEN arms. To avoid marking it with the wrong location, flag
4143 it as "no location". */
4144 gimple_set_do_not_emit_location (g
);
4146 gimplify_seq_add_stmt (&seq
, g
);
4150 if (!have_else_clause_p
)
4152 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_false
));
4153 have_else_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 2), &seq
);
4156 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_cont
));
4158 gimple_pop_condition (pre_p
);
4159 gimple_seq_add_seq (pre_p
, seq
);
4161 if (ret
== GS_ERROR
)
4163 else if (have_then_clause_p
|| have_else_clause_p
)
4167 /* Both arms are empty; replace the COND_EXPR with its predicate. */
4168 expr
= TREE_OPERAND (expr
, 0);
4169 gimplify_stmt (&expr
, pre_p
);
4176 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
4177 to be marked addressable.
4179 We cannot rely on such an expression being directly markable if a temporary
4180 has been created by the gimplification. In this case, we create another
4181 temporary and initialize it with a copy, which will become a store after we
4182 mark it addressable. This can happen if the front-end passed us something
4183 that it could not mark addressable yet, like a Fortran pass-by-reference
4184 parameter (int) floatvar. */
4187 prepare_gimple_addressable (tree
*expr_p
, gimple_seq
*seq_p
)
4189 while (handled_component_p (*expr_p
))
4190 expr_p
= &TREE_OPERAND (*expr_p
, 0);
4191 if (is_gimple_reg (*expr_p
))
4193 /* Do not allow an SSA name as the temporary. */
4194 tree var
= get_initialized_tmp_var (*expr_p
, seq_p
, NULL
, false);
4195 DECL_GIMPLE_REG_P (var
) = 0;
4200 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
4201 a call to __builtin_memcpy. */
4203 static enum gimplify_status
4204 gimplify_modify_expr_to_memcpy (tree
*expr_p
, tree size
, bool want_value
,
4207 tree t
, to
, to_ptr
, from
, from_ptr
;
4209 location_t loc
= EXPR_LOCATION (*expr_p
);
4211 to
= TREE_OPERAND (*expr_p
, 0);
4212 from
= TREE_OPERAND (*expr_p
, 1);
4214 /* Mark the RHS addressable. Beware that it may not be possible to do so
4215 directly if a temporary has been created by the gimplification. */
4216 prepare_gimple_addressable (&from
, seq_p
);
4218 mark_addressable (from
);
4219 from_ptr
= build_fold_addr_expr_loc (loc
, from
);
4220 gimplify_arg (&from_ptr
, seq_p
, loc
);
4222 mark_addressable (to
);
4223 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
4224 gimplify_arg (&to_ptr
, seq_p
, loc
);
4226 t
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
4228 gs
= gimple_build_call (t
, 3, to_ptr
, from_ptr
, size
);
4232 /* tmp = memcpy() */
4233 t
= create_tmp_var (TREE_TYPE (to_ptr
));
4234 gimple_call_set_lhs (gs
, t
);
4235 gimplify_seq_add_stmt (seq_p
, gs
);
4237 *expr_p
= build_simple_mem_ref (t
);
4241 gimplify_seq_add_stmt (seq_p
, gs
);
4246 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
4247 a call to __builtin_memset. In this case we know that the RHS is
4248 a CONSTRUCTOR with an empty element list. */
4250 static enum gimplify_status
4251 gimplify_modify_expr_to_memset (tree
*expr_p
, tree size
, bool want_value
,
4254 tree t
, from
, to
, to_ptr
;
4256 location_t loc
= EXPR_LOCATION (*expr_p
);
4258 /* Assert our assumptions, to abort instead of producing wrong code
4259 silently if they are not met. Beware that the RHS CONSTRUCTOR might
4260 not be immediately exposed. */
4261 from
= TREE_OPERAND (*expr_p
, 1);
4262 if (TREE_CODE (from
) == WITH_SIZE_EXPR
)
4263 from
= TREE_OPERAND (from
, 0);
4265 gcc_assert (TREE_CODE (from
) == CONSTRUCTOR
4266 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from
)));
4269 to
= TREE_OPERAND (*expr_p
, 0);
4271 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
4272 gimplify_arg (&to_ptr
, seq_p
, loc
);
4273 t
= builtin_decl_implicit (BUILT_IN_MEMSET
);
4275 gs
= gimple_build_call (t
, 3, to_ptr
, integer_zero_node
, size
);
4279 /* tmp = memset() */
4280 t
= create_tmp_var (TREE_TYPE (to_ptr
));
4281 gimple_call_set_lhs (gs
, t
);
4282 gimplify_seq_add_stmt (seq_p
, gs
);
4284 *expr_p
= build1 (INDIRECT_REF
, TREE_TYPE (to
), t
);
4288 gimplify_seq_add_stmt (seq_p
, gs
);
4293 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
4294 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
4295 assignment. Return non-null if we detect a potential overlap. */
4297 struct gimplify_init_ctor_preeval_data
4299 /* The base decl of the lhs object. May be NULL, in which case we
4300 have to assume the lhs is indirect. */
4303 /* The alias set of the lhs object. */
4304 alias_set_type lhs_alias_set
;
4308 gimplify_init_ctor_preeval_1 (tree
*tp
, int *walk_subtrees
, void *xdata
)
4310 struct gimplify_init_ctor_preeval_data
*data
4311 = (struct gimplify_init_ctor_preeval_data
*) xdata
;
4314 /* If we find the base object, obviously we have overlap. */
4315 if (data
->lhs_base_decl
== t
)
4318 /* If the constructor component is indirect, determine if we have a
4319 potential overlap with the lhs. The only bits of information we
4320 have to go on at this point are addressability and alias sets. */
4321 if ((INDIRECT_REF_P (t
)
4322 || TREE_CODE (t
) == MEM_REF
)
4323 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
4324 && alias_sets_conflict_p (data
->lhs_alias_set
, get_alias_set (t
)))
4327 /* If the constructor component is a call, determine if it can hide a
4328 potential overlap with the lhs through an INDIRECT_REF like above.
4329 ??? Ugh - this is completely broken. In fact this whole analysis
4330 doesn't look conservative. */
4331 if (TREE_CODE (t
) == CALL_EXPR
)
4333 tree type
, fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t
)));
4335 for (type
= TYPE_ARG_TYPES (fntype
); type
; type
= TREE_CHAIN (type
))
4336 if (POINTER_TYPE_P (TREE_VALUE (type
))
4337 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
4338 && alias_sets_conflict_p (data
->lhs_alias_set
,
4340 (TREE_TYPE (TREE_VALUE (type
)))))
4344 if (IS_TYPE_OR_DECL_P (t
))
4349 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
4350 force values that overlap with the lhs (as described by *DATA)
4351 into temporaries. */
4354 gimplify_init_ctor_preeval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4355 struct gimplify_init_ctor_preeval_data
*data
)
4357 enum gimplify_status one
;
4359 /* If the value is constant, then there's nothing to pre-evaluate. */
4360 if (TREE_CONSTANT (*expr_p
))
4362 /* Ensure it does not have side effects, it might contain a reference to
4363 the object we're initializing. */
4364 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p
));
4368 /* If the type has non-trivial constructors, we can't pre-evaluate. */
4369 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p
)))
4372 /* Recurse for nested constructors. */
4373 if (TREE_CODE (*expr_p
) == CONSTRUCTOR
)
4375 unsigned HOST_WIDE_INT ix
;
4376 constructor_elt
*ce
;
4377 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (*expr_p
);
4379 FOR_EACH_VEC_SAFE_ELT (v
, ix
, ce
)
4380 gimplify_init_ctor_preeval (&ce
->value
, pre_p
, post_p
, data
);
4385 /* If this is a variable sized type, we must remember the size. */
4386 maybe_with_size_expr (expr_p
);
4388 /* Gimplify the constructor element to something appropriate for the rhs
4389 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
4390 the gimplifier will consider this a store to memory. Doing this
4391 gimplification now means that we won't have to deal with complicated
4392 language-specific trees, nor trees like SAVE_EXPR that can induce
4393 exponential search behavior. */
4394 one
= gimplify_expr (expr_p
, pre_p
, post_p
, is_gimple_mem_rhs
, fb_rvalue
);
4395 if (one
== GS_ERROR
)
4401 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
4402 with the lhs, since "a = { .x=a }" doesn't make sense. This will
4403 always be true for all scalars, since is_gimple_mem_rhs insists on a
4404 temporary variable for them. */
4405 if (DECL_P (*expr_p
))
4408 /* If this is of variable size, we have no choice but to assume it doesn't
4409 overlap since we can't make a temporary for it. */
4410 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p
))) != INTEGER_CST
)
4413 /* Otherwise, we must search for overlap ... */
4414 if (!walk_tree (expr_p
, gimplify_init_ctor_preeval_1
, data
, NULL
))
4417 /* ... and if found, force the value into a temporary. */
4418 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
4421 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
4422 a RANGE_EXPR in a CONSTRUCTOR for an array.
4426 object[var] = value;
4433 We increment var _after_ the loop exit check because we might otherwise
4434 fail if upper == TYPE_MAX_VALUE (type for upper).
4436 Note that we never have to deal with SAVE_EXPRs here, because this has
4437 already been taken care of for us, in gimplify_init_ctor_preeval(). */
4439 static void gimplify_init_ctor_eval (tree
, vec
<constructor_elt
, va_gc
> *,
4440 gimple_seq
*, bool);
4443 gimplify_init_ctor_eval_range (tree object
, tree lower
, tree upper
,
4444 tree value
, tree array_elt_type
,
4445 gimple_seq
*pre_p
, bool cleared
)
4447 tree loop_entry_label
, loop_exit_label
, fall_thru_label
;
4448 tree var
, var_type
, cref
, tmp
;
4450 loop_entry_label
= create_artificial_label (UNKNOWN_LOCATION
);
4451 loop_exit_label
= create_artificial_label (UNKNOWN_LOCATION
);
4452 fall_thru_label
= create_artificial_label (UNKNOWN_LOCATION
);
4454 /* Create and initialize the index variable. */
4455 var_type
= TREE_TYPE (upper
);
4456 var
= create_tmp_var (var_type
);
4457 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, lower
));
4459 /* Add the loop entry label. */
4460 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_entry_label
));
4462 /* Build the reference. */
4463 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
4464 var
, NULL_TREE
, NULL_TREE
);
4466 /* If we are a constructor, just call gimplify_init_ctor_eval to do
4467 the store. Otherwise just assign value to the reference. */
4469 if (TREE_CODE (value
) == CONSTRUCTOR
)
4470 /* NB we might have to call ourself recursively through
4471 gimplify_init_ctor_eval if the value is a constructor. */
4472 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
4475 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (cref
, value
));
4477 /* We exit the loop when the index var is equal to the upper bound. */
4478 gimplify_seq_add_stmt (pre_p
,
4479 gimple_build_cond (EQ_EXPR
, var
, upper
,
4480 loop_exit_label
, fall_thru_label
));
4482 gimplify_seq_add_stmt (pre_p
, gimple_build_label (fall_thru_label
));
4484 /* Otherwise, increment the index var... */
4485 tmp
= build2 (PLUS_EXPR
, var_type
, var
,
4486 fold_convert (var_type
, integer_one_node
));
4487 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, tmp
));
4489 /* ...and jump back to the loop entry. */
4490 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (loop_entry_label
));
4492 /* Add the loop exit label. */
4493 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_exit_label
));
4496 /* Return true if FDECL is accessing a field that is zero sized. */
4499 zero_sized_field_decl (const_tree fdecl
)
4501 if (TREE_CODE (fdecl
) == FIELD_DECL
&& DECL_SIZE (fdecl
)
4502 && integer_zerop (DECL_SIZE (fdecl
)))
4507 /* Return true if TYPE is zero sized. */
4510 zero_sized_type (const_tree type
)
4512 if (AGGREGATE_TYPE_P (type
) && TYPE_SIZE (type
)
4513 && integer_zerop (TYPE_SIZE (type
)))
4518 /* A subroutine of gimplify_init_constructor. Generate individual
4519 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
4520 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
4521 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
4525 gimplify_init_ctor_eval (tree object
, vec
<constructor_elt
, va_gc
> *elts
,
4526 gimple_seq
*pre_p
, bool cleared
)
4528 tree array_elt_type
= NULL
;
4529 unsigned HOST_WIDE_INT ix
;
4530 tree purpose
, value
;
4532 if (TREE_CODE (TREE_TYPE (object
)) == ARRAY_TYPE
)
4533 array_elt_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object
)));
4535 FOR_EACH_CONSTRUCTOR_ELT (elts
, ix
, purpose
, value
)
4539 /* NULL values are created above for gimplification errors. */
4543 if (cleared
&& initializer_zerop (value
))
4546 /* ??? Here's to hoping the front end fills in all of the indices,
4547 so we don't have to figure out what's missing ourselves. */
4548 gcc_assert (purpose
);
4550 /* Skip zero-sized fields, unless value has side-effects. This can
4551 happen with calls to functions returning a zero-sized type, which
4552 we shouldn't discard. As a number of downstream passes don't
4553 expect sets of zero-sized fields, we rely on the gimplification of
4554 the MODIFY_EXPR we make below to drop the assignment statement. */
4555 if (! TREE_SIDE_EFFECTS (value
) && zero_sized_field_decl (purpose
))
4558 /* If we have a RANGE_EXPR, we have to build a loop to assign the
4560 if (TREE_CODE (purpose
) == RANGE_EXPR
)
4562 tree lower
= TREE_OPERAND (purpose
, 0);
4563 tree upper
= TREE_OPERAND (purpose
, 1);
4565 /* If the lower bound is equal to upper, just treat it as if
4566 upper was the index. */
4567 if (simple_cst_equal (lower
, upper
))
4571 gimplify_init_ctor_eval_range (object
, lower
, upper
, value
,
4572 array_elt_type
, pre_p
, cleared
);
4579 /* Do not use bitsizetype for ARRAY_REF indices. */
4580 if (TYPE_DOMAIN (TREE_TYPE (object
)))
4582 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object
))),
4584 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
4585 purpose
, NULL_TREE
, NULL_TREE
);
4589 gcc_assert (TREE_CODE (purpose
) == FIELD_DECL
);
4590 cref
= build3 (COMPONENT_REF
, TREE_TYPE (purpose
),
4591 unshare_expr (object
), purpose
, NULL_TREE
);
4594 if (TREE_CODE (value
) == CONSTRUCTOR
4595 && TREE_CODE (TREE_TYPE (value
)) != VECTOR_TYPE
)
4596 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
4600 tree init
= build2 (INIT_EXPR
, TREE_TYPE (cref
), cref
, value
);
4601 gimplify_and_add (init
, pre_p
);
4607 /* Return the appropriate RHS predicate for this LHS. */
4610 rhs_predicate_for (tree lhs
)
4612 if (is_gimple_reg (lhs
))
4613 return is_gimple_reg_rhs_or_call
;
4615 return is_gimple_mem_rhs_or_call
;
4618 /* Return the initial guess for an appropriate RHS predicate for this LHS,
4619 before the LHS has been gimplified. */
4621 static gimple_predicate
4622 initial_rhs_predicate_for (tree lhs
)
4624 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
4625 return is_gimple_reg_rhs_or_call
;
4627 return is_gimple_mem_rhs_or_call
;
4630 /* Gimplify a C99 compound literal expression. This just means adding
4631 the DECL_EXPR before the current statement and using its anonymous
4634 static enum gimplify_status
4635 gimplify_compound_literal_expr (tree
*expr_p
, gimple_seq
*pre_p
,
4636 bool (*gimple_test_f
) (tree
),
4637 fallback_t fallback
)
4639 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p
);
4640 tree decl
= DECL_EXPR_DECL (decl_s
);
4641 tree init
= DECL_INITIAL (decl
);
4642 /* Mark the decl as addressable if the compound literal
4643 expression is addressable now, otherwise it is marked too late
4644 after we gimplify the initialization expression. */
4645 if (TREE_ADDRESSABLE (*expr_p
))
4646 TREE_ADDRESSABLE (decl
) = 1;
4647 /* Otherwise, if we don't need an lvalue and have a literal directly
4648 substitute it. Check if it matches the gimple predicate, as
4649 otherwise we'd generate a new temporary, and we can as well just
4650 use the decl we already have. */
4651 else if (!TREE_ADDRESSABLE (decl
)
4653 && (fallback
& fb_lvalue
) == 0
4654 && gimple_test_f (init
))
4660 /* Preliminarily mark non-addressed complex variables as eligible
4661 for promotion to gimple registers. We'll transform their uses
4663 if ((TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
4664 || TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
)
4665 && !TREE_THIS_VOLATILE (decl
)
4666 && !needs_to_live_in_memory (decl
))
4667 DECL_GIMPLE_REG_P (decl
) = 1;
4669 /* If the decl is not addressable, then it is being used in some
4670 expression or on the right hand side of a statement, and it can
4671 be put into a readonly data section. */
4672 if (!TREE_ADDRESSABLE (decl
) && (fallback
& fb_lvalue
) == 0)
4673 TREE_READONLY (decl
) = 1;
4675 /* This decl isn't mentioned in the enclosing block, so add it to the
4676 list of temps. FIXME it seems a bit of a kludge to say that
4677 anonymous artificial vars aren't pushed, but everything else is. */
4678 if (DECL_NAME (decl
) == NULL_TREE
&& !DECL_SEEN_IN_BIND_EXPR_P (decl
))
4679 gimple_add_tmp_var (decl
);
4681 gimplify_and_add (decl_s
, pre_p
);
4686 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
4687 return a new CONSTRUCTOR if something changed. */
4690 optimize_compound_literals_in_ctor (tree orig_ctor
)
4692 tree ctor
= orig_ctor
;
4693 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
4694 unsigned int idx
, num
= vec_safe_length (elts
);
4696 for (idx
= 0; idx
< num
; idx
++)
4698 tree value
= (*elts
)[idx
].value
;
4699 tree newval
= value
;
4700 if (TREE_CODE (value
) == CONSTRUCTOR
)
4701 newval
= optimize_compound_literals_in_ctor (value
);
4702 else if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
4704 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (value
);
4705 tree decl
= DECL_EXPR_DECL (decl_s
);
4706 tree init
= DECL_INITIAL (decl
);
4708 if (!TREE_ADDRESSABLE (value
)
4709 && !TREE_ADDRESSABLE (decl
)
4711 && TREE_CODE (init
) == CONSTRUCTOR
)
4712 newval
= optimize_compound_literals_in_ctor (init
);
4714 if (newval
== value
)
4717 if (ctor
== orig_ctor
)
4719 ctor
= copy_node (orig_ctor
);
4720 CONSTRUCTOR_ELTS (ctor
) = vec_safe_copy (elts
);
4721 elts
= CONSTRUCTOR_ELTS (ctor
);
4723 (*elts
)[idx
].value
= newval
;
4728 /* A subroutine of gimplify_modify_expr. Break out elements of a
4729 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
4731 Note that we still need to clear any elements that don't have explicit
4732 initializers, so if not all elements are initialized we keep the
4733 original MODIFY_EXPR, we just remove all of the constructor elements.
4735 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
4736 GS_ERROR if we would have to create a temporary when gimplifying
4737 this constructor. Otherwise, return GS_OK.
4739 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
4741 static enum gimplify_status
4742 gimplify_init_constructor (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4743 bool want_value
, bool notify_temp_creation
)
4745 tree object
, ctor
, type
;
4746 enum gimplify_status ret
;
4747 vec
<constructor_elt
, va_gc
> *elts
;
4749 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == CONSTRUCTOR
);
4751 if (!notify_temp_creation
)
4753 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
4754 is_gimple_lvalue
, fb_lvalue
);
4755 if (ret
== GS_ERROR
)
4759 object
= TREE_OPERAND (*expr_p
, 0);
4760 ctor
= TREE_OPERAND (*expr_p
, 1)
4761 = optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p
, 1));
4762 type
= TREE_TYPE (ctor
);
4763 elts
= CONSTRUCTOR_ELTS (ctor
);
4766 switch (TREE_CODE (type
))
4770 case QUAL_UNION_TYPE
:
4773 struct gimplify_init_ctor_preeval_data preeval_data
;
4774 HOST_WIDE_INT num_ctor_elements
, num_nonzero_elements
;
4775 bool cleared
, complete_p
, valid_const_initializer
;
4777 /* Aggregate types must lower constructors to initialization of
4778 individual elements. The exception is that a CONSTRUCTOR node
4779 with no elements indicates zero-initialization of the whole. */
4780 if (vec_safe_is_empty (elts
))
4782 if (notify_temp_creation
)
4787 /* Fetch information about the constructor to direct later processing.
4788 We might want to make static versions of it in various cases, and
4789 can only do so if it known to be a valid constant initializer. */
4790 valid_const_initializer
4791 = categorize_ctor_elements (ctor
, &num_nonzero_elements
,
4792 &num_ctor_elements
, &complete_p
);
4794 /* If a const aggregate variable is being initialized, then it
4795 should never be a lose to promote the variable to be static. */
4796 if (valid_const_initializer
4797 && num_nonzero_elements
> 1
4798 && TREE_READONLY (object
)
4800 && (flag_merge_constants
>= 2 || !TREE_ADDRESSABLE (object
)))
4802 if (notify_temp_creation
)
4804 DECL_INITIAL (object
) = ctor
;
4805 TREE_STATIC (object
) = 1;
4806 if (!DECL_NAME (object
))
4807 DECL_NAME (object
) = create_tmp_var_name ("C");
4808 walk_tree (&DECL_INITIAL (object
), force_labels_r
, NULL
, NULL
);
4810 /* ??? C++ doesn't automatically append a .<number> to the
4811 assembler name, and even when it does, it looks at FE private
4812 data structures to figure out what that number should be,
4813 which are not set for this variable. I suppose this is
4814 important for local statics for inline functions, which aren't
4815 "local" in the object file sense. So in order to get a unique
4816 TU-local symbol, we must invoke the lhd version now. */
4817 lhd_set_decl_assembler_name (object
);
4819 *expr_p
= NULL_TREE
;
4823 /* If there are "lots" of initialized elements, even discounting
4824 those that are not address constants (and thus *must* be
4825 computed at runtime), then partition the constructor into
4826 constant and non-constant parts. Block copy the constant
4827 parts in, then generate code for the non-constant parts. */
4828 /* TODO. There's code in cp/typeck.c to do this. */
4830 if (int_size_in_bytes (TREE_TYPE (ctor
)) < 0)
4831 /* store_constructor will ignore the clearing of variable-sized
4832 objects. Initializers for such objects must explicitly set
4833 every field that needs to be set. */
4835 else if (!complete_p
&& !CONSTRUCTOR_NO_CLEARING (ctor
))
4836 /* If the constructor isn't complete, clear the whole object
4837 beforehand, unless CONSTRUCTOR_NO_CLEARING is set on it.
4839 ??? This ought not to be needed. For any element not present
4840 in the initializer, we should simply set them to zero. Except
4841 we'd need to *find* the elements that are not present, and that
4842 requires trickery to avoid quadratic compile-time behavior in
4843 large cases or excessive memory use in small cases. */
4845 else if (num_ctor_elements
- num_nonzero_elements
4846 > CLEAR_RATIO (optimize_function_for_speed_p (cfun
))
4847 && num_nonzero_elements
< num_ctor_elements
/ 4)
4848 /* If there are "lots" of zeros, it's more efficient to clear
4849 the memory and then set the nonzero elements. */
4854 /* If there are "lots" of initialized elements, and all of them
4855 are valid address constants, then the entire initializer can
4856 be dropped to memory, and then memcpy'd out. Don't do this
4857 for sparse arrays, though, as it's more efficient to follow
4858 the standard CONSTRUCTOR behavior of memset followed by
4859 individual element initialization. Also don't do this for small
4860 all-zero initializers (which aren't big enough to merit
4861 clearing), and don't try to make bitwise copies of
4862 TREE_ADDRESSABLE types.
4864 We cannot apply such transformation when compiling chkp static
4865 initializer because creation of initializer image in the memory
4866 will require static initialization of bounds for it. It should
4867 result in another gimplification of similar initializer and we
4868 may fall into infinite loop. */
4869 if (valid_const_initializer
4870 && !(cleared
|| num_nonzero_elements
== 0)
4871 && !TREE_ADDRESSABLE (type
)
4872 && (!current_function_decl
4873 || !lookup_attribute ("chkp ctor",
4874 DECL_ATTRIBUTES (current_function_decl
))))
4876 HOST_WIDE_INT size
= int_size_in_bytes (type
);
4879 /* ??? We can still get unbounded array types, at least
4880 from the C++ front end. This seems wrong, but attempt
4881 to work around it for now. */
4884 size
= int_size_in_bytes (TREE_TYPE (object
));
4886 TREE_TYPE (ctor
) = type
= TREE_TYPE (object
);
4889 /* Find the maximum alignment we can assume for the object. */
4890 /* ??? Make use of DECL_OFFSET_ALIGN. */
4891 if (DECL_P (object
))
4892 align
= DECL_ALIGN (object
);
4894 align
= TYPE_ALIGN (type
);
4896 /* Do a block move either if the size is so small as to make
4897 each individual move a sub-unit move on average, or if it
4898 is so large as to make individual moves inefficient. */
4900 && num_nonzero_elements
> 1
4901 && (size
< num_nonzero_elements
4902 || !can_move_by_pieces (size
, align
)))
4904 if (notify_temp_creation
)
4907 walk_tree (&ctor
, force_labels_r
, NULL
, NULL
);
4908 ctor
= tree_output_constant_def (ctor
);
4909 if (!useless_type_conversion_p (type
, TREE_TYPE (ctor
)))
4910 ctor
= build1 (VIEW_CONVERT_EXPR
, type
, ctor
);
4911 TREE_OPERAND (*expr_p
, 1) = ctor
;
4913 /* This is no longer an assignment of a CONSTRUCTOR, but
4914 we still may have processing to do on the LHS. So
4915 pretend we didn't do anything here to let that happen. */
4916 return GS_UNHANDLED
;
4920 /* If the target is volatile, we have non-zero elements and more than
4921 one field to assign, initialize the target from a temporary. */
4922 if (TREE_THIS_VOLATILE (object
)
4923 && !TREE_ADDRESSABLE (type
)
4924 && num_nonzero_elements
> 0
4925 && vec_safe_length (elts
) > 1)
4927 tree temp
= create_tmp_var (TYPE_MAIN_VARIANT (type
));
4928 TREE_OPERAND (*expr_p
, 0) = temp
;
4929 *expr_p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*expr_p
),
4931 build2 (MODIFY_EXPR
, void_type_node
,
4936 if (notify_temp_creation
)
4939 /* If there are nonzero elements and if needed, pre-evaluate to capture
4940 elements overlapping with the lhs into temporaries. We must do this
4941 before clearing to fetch the values before they are zeroed-out. */
4942 if (num_nonzero_elements
> 0 && TREE_CODE (*expr_p
) != INIT_EXPR
)
4944 preeval_data
.lhs_base_decl
= get_base_address (object
);
4945 if (!DECL_P (preeval_data
.lhs_base_decl
))
4946 preeval_data
.lhs_base_decl
= NULL
;
4947 preeval_data
.lhs_alias_set
= get_alias_set (object
);
4949 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p
, 1),
4950 pre_p
, post_p
, &preeval_data
);
4953 bool ctor_has_side_effects_p
4954 = TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p
, 1));
4958 /* Zap the CONSTRUCTOR element list, which simplifies this case.
4959 Note that we still have to gimplify, in order to handle the
4960 case of variable sized types. Avoid shared tree structures. */
4961 CONSTRUCTOR_ELTS (ctor
) = NULL
;
4962 TREE_SIDE_EFFECTS (ctor
) = 0;
4963 object
= unshare_expr (object
);
4964 gimplify_stmt (expr_p
, pre_p
);
4967 /* If we have not block cleared the object, or if there are nonzero
4968 elements in the constructor, or if the constructor has side effects,
4969 add assignments to the individual scalar fields of the object. */
4971 || num_nonzero_elements
> 0
4972 || ctor_has_side_effects_p
)
4973 gimplify_init_ctor_eval (object
, elts
, pre_p
, cleared
);
4975 *expr_p
= NULL_TREE
;
4983 if (notify_temp_creation
)
4986 /* Extract the real and imaginary parts out of the ctor. */
4987 gcc_assert (elts
->length () == 2);
4988 r
= (*elts
)[0].value
;
4989 i
= (*elts
)[1].value
;
4990 if (r
== NULL
|| i
== NULL
)
4992 tree zero
= build_zero_cst (TREE_TYPE (type
));
4999 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
5000 represent creation of a complex value. */
5001 if (TREE_CONSTANT (r
) && TREE_CONSTANT (i
))
5003 ctor
= build_complex (type
, r
, i
);
5004 TREE_OPERAND (*expr_p
, 1) = ctor
;
5008 ctor
= build2 (COMPLEX_EXPR
, type
, r
, i
);
5009 TREE_OPERAND (*expr_p
, 1) = ctor
;
5010 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1),
5013 rhs_predicate_for (TREE_OPERAND (*expr_p
, 0)),
5021 unsigned HOST_WIDE_INT ix
;
5022 constructor_elt
*ce
;
5024 if (notify_temp_creation
)
5027 /* Go ahead and simplify constant constructors to VECTOR_CST. */
5028 if (TREE_CONSTANT (ctor
))
5030 bool constant_p
= true;
5033 /* Even when ctor is constant, it might contain non-*_CST
5034 elements, such as addresses or trapping values like
5035 1.0/0.0 - 1.0/0.0. Such expressions don't belong
5036 in VECTOR_CST nodes. */
5037 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
5038 if (!CONSTANT_CLASS_P (value
))
5046 TREE_OPERAND (*expr_p
, 1) = build_vector_from_ctor (type
, elts
);
5050 TREE_CONSTANT (ctor
) = 0;
5053 /* Vector types use CONSTRUCTOR all the way through gimple
5054 compilation as a general initializer. */
5055 FOR_EACH_VEC_SAFE_ELT (elts
, ix
, ce
)
5057 enum gimplify_status tret
;
5058 tret
= gimplify_expr (&ce
->value
, pre_p
, post_p
, is_gimple_val
,
5060 if (tret
== GS_ERROR
)
5062 else if (TREE_STATIC (ctor
)
5063 && !initializer_constant_valid_p (ce
->value
,
5064 TREE_TYPE (ce
->value
)))
5065 TREE_STATIC (ctor
) = 0;
5067 if (!is_gimple_reg (TREE_OPERAND (*expr_p
, 0)))
5068 TREE_OPERAND (*expr_p
, 1) = get_formal_tmp_var (ctor
, pre_p
);
5073 /* So how did we get a CONSTRUCTOR for a scalar type? */
5077 if (ret
== GS_ERROR
)
5079 /* If we have gimplified both sides of the initializer but have
5080 not emitted an assignment, do so now. */
5083 tree lhs
= TREE_OPERAND (*expr_p
, 0);
5084 tree rhs
= TREE_OPERAND (*expr_p
, 1);
5085 if (want_value
&& object
== lhs
)
5086 lhs
= unshare_expr (lhs
);
5087 gassign
*init
= gimple_build_assign (lhs
, rhs
);
5088 gimplify_seq_add_stmt (pre_p
, init
);
5102 /* Given a pointer value OP0, return a simplified version of an
5103 indirection through OP0, or NULL_TREE if no simplification is
5104 possible. This may only be applied to a rhs of an expression.
5105 Note that the resulting type may be different from the type pointed
5106 to in the sense that it is still compatible from the langhooks
5110 gimple_fold_indirect_ref_rhs (tree t
)
5112 return gimple_fold_indirect_ref (t
);
5115 /* Subroutine of gimplify_modify_expr to do simplifications of
5116 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
5117 something changes. */
5119 static enum gimplify_status
5120 gimplify_modify_expr_rhs (tree
*expr_p
, tree
*from_p
, tree
*to_p
,
5121 gimple_seq
*pre_p
, gimple_seq
*post_p
,
5124 enum gimplify_status ret
= GS_UNHANDLED
;
5130 switch (TREE_CODE (*from_p
))
5133 /* If we're assigning from a read-only variable initialized with
5134 a constructor, do the direct assignment from the constructor,
5135 but only if neither source nor target are volatile since this
5136 latter assignment might end up being done on a per-field basis. */
5137 if (DECL_INITIAL (*from_p
)
5138 && TREE_READONLY (*from_p
)
5139 && !TREE_THIS_VOLATILE (*from_p
)
5140 && !TREE_THIS_VOLATILE (*to_p
)
5141 && TREE_CODE (DECL_INITIAL (*from_p
)) == CONSTRUCTOR
)
5143 tree old_from
= *from_p
;
5144 enum gimplify_status subret
;
5146 /* Move the constructor into the RHS. */
5147 *from_p
= unshare_expr (DECL_INITIAL (*from_p
));
5149 /* Let's see if gimplify_init_constructor will need to put
5151 subret
= gimplify_init_constructor (expr_p
, NULL
, NULL
,
5153 if (subret
== GS_ERROR
)
5155 /* If so, revert the change. */
5167 /* If we have code like
5171 where the type of "x" is a (possibly cv-qualified variant
5172 of "A"), treat the entire expression as identical to "x".
5173 This kind of code arises in C++ when an object is bound
5174 to a const reference, and if "x" is a TARGET_EXPR we want
5175 to take advantage of the optimization below. */
5176 bool volatile_p
= TREE_THIS_VOLATILE (*from_p
);
5177 tree t
= gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p
, 0));
5180 if (TREE_THIS_VOLATILE (t
) != volatile_p
)
5183 t
= build_simple_mem_ref_loc (EXPR_LOCATION (*from_p
),
5184 build_fold_addr_expr (t
));
5185 if (REFERENCE_CLASS_P (t
))
5186 TREE_THIS_VOLATILE (t
) = volatile_p
;
5197 /* If we are initializing something from a TARGET_EXPR, strip the
5198 TARGET_EXPR and initialize it directly, if possible. This can't
5199 be done if the initializer is void, since that implies that the
5200 temporary is set in some non-trivial way.
5202 ??? What about code that pulls out the temp and uses it
5203 elsewhere? I think that such code never uses the TARGET_EXPR as
5204 an initializer. If I'm wrong, we'll die because the temp won't
5205 have any RTL. In that case, I guess we'll need to replace
5206 references somehow. */
5207 tree init
= TARGET_EXPR_INITIAL (*from_p
);
5210 && (TREE_CODE (*expr_p
) != MODIFY_EXPR
5211 || !TARGET_EXPR_NO_ELIDE (*from_p
))
5212 && !VOID_TYPE_P (TREE_TYPE (init
)))
5222 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
5224 gimplify_compound_expr (from_p
, pre_p
, true);
5230 /* If we already made some changes, let the front end have a
5231 crack at this before we break it down. */
5232 if (ret
!= GS_UNHANDLED
)
5234 /* If we're initializing from a CONSTRUCTOR, break this into
5235 individual MODIFY_EXPRs. */
5236 return gimplify_init_constructor (expr_p
, pre_p
, post_p
, want_value
,
5240 /* If we're assigning to a non-register type, push the assignment
5241 down into the branches. This is mandatory for ADDRESSABLE types,
5242 since we cannot generate temporaries for such, but it saves a
5243 copy in other cases as well. */
5244 if (!is_gimple_reg_type (TREE_TYPE (*from_p
)))
5246 /* This code should mirror the code in gimplify_cond_expr. */
5247 enum tree_code code
= TREE_CODE (*expr_p
);
5248 tree cond
= *from_p
;
5249 tree result
= *to_p
;
5251 ret
= gimplify_expr (&result
, pre_p
, post_p
,
5252 is_gimple_lvalue
, fb_lvalue
);
5253 if (ret
!= GS_ERROR
)
5256 /* If we are going to write RESULT more than once, clear
5257 TREE_READONLY flag, otherwise we might incorrectly promote
5258 the variable to static const and initialize it at compile
5259 time in one of the branches. */
5261 && TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
5262 && TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
5263 TREE_READONLY (result
) = 0;
5264 if (TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
)
5265 TREE_OPERAND (cond
, 1)
5266 = build2 (code
, void_type_node
, result
,
5267 TREE_OPERAND (cond
, 1));
5268 if (TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
5269 TREE_OPERAND (cond
, 2)
5270 = build2 (code
, void_type_node
, unshare_expr (result
),
5271 TREE_OPERAND (cond
, 2));
5273 TREE_TYPE (cond
) = void_type_node
;
5274 recalculate_side_effects (cond
);
5278 gimplify_and_add (cond
, pre_p
);
5279 *expr_p
= unshare_expr (result
);
5288 /* For calls that return in memory, give *to_p as the CALL_EXPR's
5289 return slot so that we don't generate a temporary. */
5290 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p
)
5291 && aggregate_value_p (*from_p
, *from_p
))
5295 if (!(rhs_predicate_for (*to_p
))(*from_p
))
5296 /* If we need a temporary, *to_p isn't accurate. */
5298 /* It's OK to use the return slot directly unless it's an NRV. */
5299 else if (TREE_CODE (*to_p
) == RESULT_DECL
5300 && DECL_NAME (*to_p
) == NULL_TREE
5301 && needs_to_live_in_memory (*to_p
))
5303 else if (is_gimple_reg_type (TREE_TYPE (*to_p
))
5304 || (DECL_P (*to_p
) && DECL_REGISTER (*to_p
)))
5305 /* Don't force regs into memory. */
5307 else if (TREE_CODE (*expr_p
) == INIT_EXPR
)
5308 /* It's OK to use the target directly if it's being
5311 else if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (*to_p
)))
5313 /* Always use the target and thus RSO for variable-sized types.
5314 GIMPLE cannot deal with a variable-sized assignment
5315 embedded in a call statement. */
5317 else if (TREE_CODE (*to_p
) != SSA_NAME
5318 && (!is_gimple_variable (*to_p
)
5319 || needs_to_live_in_memory (*to_p
)))
5320 /* Don't use the original target if it's already addressable;
5321 if its address escapes, and the called function uses the
5322 NRV optimization, a conforming program could see *to_p
5323 change before the called function returns; see c++/19317.
5324 When optimizing, the return_slot pass marks more functions
5325 as safe after we have escape info. */
5332 CALL_EXPR_RETURN_SLOT_OPT (*from_p
) = 1;
5333 mark_addressable (*to_p
);
5338 case WITH_SIZE_EXPR
:
5339 /* Likewise for calls that return an aggregate of non-constant size,
5340 since we would not be able to generate a temporary at all. */
5341 if (TREE_CODE (TREE_OPERAND (*from_p
, 0)) == CALL_EXPR
)
5343 *from_p
= TREE_OPERAND (*from_p
, 0);
5344 /* We don't change ret in this case because the
5345 WITH_SIZE_EXPR might have been added in
5346 gimplify_modify_expr, so returning GS_OK would lead to an
5352 /* If we're initializing from a container, push the initialization
5354 case CLEANUP_POINT_EXPR
:
5356 case STATEMENT_LIST
:
5358 tree wrap
= *from_p
;
5361 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_min_lval
,
5363 if (ret
!= GS_ERROR
)
5366 t
= voidify_wrapper_expr (wrap
, *expr_p
);
5367 gcc_assert (t
== *expr_p
);
5371 gimplify_and_add (wrap
, pre_p
);
5372 *expr_p
= unshare_expr (*to_p
);
5379 case COMPOUND_LITERAL_EXPR
:
5381 tree complit
= TREE_OPERAND (*expr_p
, 1);
5382 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (complit
);
5383 tree decl
= DECL_EXPR_DECL (decl_s
);
5384 tree init
= DECL_INITIAL (decl
);
5386 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
5387 into struct T x = { 0, 1, 2 } if the address of the
5388 compound literal has never been taken. */
5389 if (!TREE_ADDRESSABLE (complit
)
5390 && !TREE_ADDRESSABLE (decl
)
5393 *expr_p
= copy_node (*expr_p
);
5394 TREE_OPERAND (*expr_p
, 1) = init
;
5409 /* Return true if T looks like a valid GIMPLE statement. */
5412 is_gimple_stmt (tree t
)
5414 const enum tree_code code
= TREE_CODE (t
);
5419 /* The only valid NOP_EXPR is the empty statement. */
5420 return IS_EMPTY_STMT (t
);
5424 /* These are only valid if they're void. */
5425 return TREE_TYPE (t
) == NULL
|| VOID_TYPE_P (TREE_TYPE (t
));
5431 case CASE_LABEL_EXPR
:
5432 case TRY_CATCH_EXPR
:
5433 case TRY_FINALLY_EXPR
:
5434 case EH_FILTER_EXPR
:
5437 case STATEMENT_LIST
:
5441 case OACC_HOST_DATA
:
5444 case OACC_ENTER_DATA
:
5445 case OACC_EXIT_DATA
:
5450 case OMP_DISTRIBUTE
:
5461 case OMP_TARGET_DATA
:
5462 case OMP_TARGET_UPDATE
:
5463 case OMP_TARGET_ENTER_DATA
:
5464 case OMP_TARGET_EXIT_DATA
:
5467 /* These are always void. */
5473 /* These are valid regardless of their type. */
5482 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
5483 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
5484 DECL_GIMPLE_REG_P set.
5486 IMPORTANT NOTE: This promotion is performed by introducing a load of the
5487 other, unmodified part of the complex object just before the total store.
5488 As a consequence, if the object is still uninitialized, an undefined value
5489 will be loaded into a register, which may result in a spurious exception
5490 if the register is floating-point and the value happens to be a signaling
5491 NaN for example. Then the fully-fledged complex operations lowering pass
5492 followed by a DCE pass are necessary in order to fix things up. */
5494 static enum gimplify_status
5495 gimplify_modify_expr_complex_part (tree
*expr_p
, gimple_seq
*pre_p
,
5498 enum tree_code code
, ocode
;
5499 tree lhs
, rhs
, new_rhs
, other
, realpart
, imagpart
;
5501 lhs
= TREE_OPERAND (*expr_p
, 0);
5502 rhs
= TREE_OPERAND (*expr_p
, 1);
5503 code
= TREE_CODE (lhs
);
5504 lhs
= TREE_OPERAND (lhs
, 0);
5506 ocode
= code
== REALPART_EXPR
? IMAGPART_EXPR
: REALPART_EXPR
;
5507 other
= build1 (ocode
, TREE_TYPE (rhs
), lhs
);
5508 TREE_NO_WARNING (other
) = 1;
5509 other
= get_formal_tmp_var (other
, pre_p
);
5511 realpart
= code
== REALPART_EXPR
? rhs
: other
;
5512 imagpart
= code
== REALPART_EXPR
? other
: rhs
;
5514 if (TREE_CONSTANT (realpart
) && TREE_CONSTANT (imagpart
))
5515 new_rhs
= build_complex (TREE_TYPE (lhs
), realpart
, imagpart
);
5517 new_rhs
= build2 (COMPLEX_EXPR
, TREE_TYPE (lhs
), realpart
, imagpart
);
5519 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (lhs
, new_rhs
));
5520 *expr_p
= (want_value
) ? rhs
: NULL_TREE
;
5525 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
5531 PRE_P points to the list where side effects that must happen before
5532 *EXPR_P should be stored.
5534 POST_P points to the list where side effects that must happen after
5535 *EXPR_P should be stored.
5537 WANT_VALUE is nonzero iff we want to use the value of this expression
5538 in another expression. */
5540 static enum gimplify_status
5541 gimplify_modify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
5544 tree
*from_p
= &TREE_OPERAND (*expr_p
, 1);
5545 tree
*to_p
= &TREE_OPERAND (*expr_p
, 0);
5546 enum gimplify_status ret
= GS_UNHANDLED
;
5548 location_t loc
= EXPR_LOCATION (*expr_p
);
5549 gimple_stmt_iterator gsi
;
5551 gcc_assert (TREE_CODE (*expr_p
) == MODIFY_EXPR
5552 || TREE_CODE (*expr_p
) == INIT_EXPR
);
5554 /* Trying to simplify a clobber using normal logic doesn't work,
5555 so handle it here. */
5556 if (TREE_CLOBBER_P (*from_p
))
5558 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
5559 if (ret
== GS_ERROR
)
5561 gcc_assert (!want_value
);
5562 if (!VAR_P (*to_p
) && TREE_CODE (*to_p
) != MEM_REF
)
5564 tree addr
= get_initialized_tmp_var (build_fold_addr_expr (*to_p
),
5566 *to_p
= build_simple_mem_ref_loc (EXPR_LOCATION (*to_p
), addr
);
5568 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (*to_p
, *from_p
));
5573 /* Insert pointer conversions required by the middle-end that are not
5574 required by the frontend. This fixes middle-end type checking for
5575 for example gcc.dg/redecl-6.c. */
5576 if (POINTER_TYPE_P (TREE_TYPE (*to_p
)))
5578 STRIP_USELESS_TYPE_CONVERSION (*from_p
);
5579 if (!useless_type_conversion_p (TREE_TYPE (*to_p
), TREE_TYPE (*from_p
)))
5580 *from_p
= fold_convert_loc (loc
, TREE_TYPE (*to_p
), *from_p
);
5583 /* See if any simplifications can be done based on what the RHS is. */
5584 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
5586 if (ret
!= GS_UNHANDLED
)
5589 /* For zero sized types only gimplify the left hand side and right hand
5590 side as statements and throw away the assignment. Do this after
5591 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
5593 if (zero_sized_type (TREE_TYPE (*from_p
))
5595 /* Don't do this for calls that return addressable types, expand_call
5596 relies on those having a lhs. */
5597 && !(TREE_ADDRESSABLE (TREE_TYPE (*from_p
))
5598 && TREE_CODE (*from_p
) == CALL_EXPR
))
5600 gimplify_stmt (from_p
, pre_p
);
5601 gimplify_stmt (to_p
, pre_p
);
5602 *expr_p
= NULL_TREE
;
5606 /* If the value being copied is of variable width, compute the length
5607 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
5608 before gimplifying any of the operands so that we can resolve any
5609 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
5610 the size of the expression to be copied, not of the destination, so
5611 that is what we must do here. */
5612 maybe_with_size_expr (from_p
);
5614 /* As a special case, we have to temporarily allow for assignments
5615 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
5616 a toplevel statement, when gimplifying the GENERIC expression
5617 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
5618 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
5620 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
5621 prevent gimplify_expr from trying to create a new temporary for
5622 foo's LHS, we tell it that it should only gimplify until it
5623 reaches the CALL_EXPR. On return from gimplify_expr, the newly
5624 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
5625 and all we need to do here is set 'a' to be its LHS. */
5627 /* Gimplify the RHS first for C++17 and bug 71104. */
5628 gimple_predicate initial_pred
= initial_rhs_predicate_for (*to_p
);
5629 ret
= gimplify_expr (from_p
, pre_p
, post_p
, initial_pred
, fb_rvalue
);
5630 if (ret
== GS_ERROR
)
5633 /* Then gimplify the LHS. */
5634 /* If we gimplified the RHS to a CALL_EXPR and that call may return
5635 twice we have to make sure to gimplify into non-SSA as otherwise
5636 the abnormal edge added later will make those defs not dominate
5638 ??? Technically this applies only to the registers used in the
5639 resulting non-register *TO_P. */
5640 bool saved_into_ssa
= gimplify_ctxp
->into_ssa
;
5642 && TREE_CODE (*from_p
) == CALL_EXPR
5643 && call_expr_flags (*from_p
) & ECF_RETURNS_TWICE
)
5644 gimplify_ctxp
->into_ssa
= false;
5645 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
5646 gimplify_ctxp
->into_ssa
= saved_into_ssa
;
5647 if (ret
== GS_ERROR
)
5650 /* Now that the LHS is gimplified, re-gimplify the RHS if our initial
5651 guess for the predicate was wrong. */
5652 gimple_predicate final_pred
= rhs_predicate_for (*to_p
);
5653 if (final_pred
!= initial_pred
)
5655 ret
= gimplify_expr (from_p
, pre_p
, post_p
, final_pred
, fb_rvalue
);
5656 if (ret
== GS_ERROR
)
5660 /* In case of va_arg internal fn wrappped in a WITH_SIZE_EXPR, add the type
5661 size as argument to the call. */
5662 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
5664 tree call
= TREE_OPERAND (*from_p
, 0);
5665 tree vlasize
= TREE_OPERAND (*from_p
, 1);
5667 if (TREE_CODE (call
) == CALL_EXPR
5668 && CALL_EXPR_IFN (call
) == IFN_VA_ARG
)
5670 int nargs
= call_expr_nargs (call
);
5671 tree type
= TREE_TYPE (call
);
5672 tree ap
= CALL_EXPR_ARG (call
, 0);
5673 tree tag
= CALL_EXPR_ARG (call
, 1);
5674 tree aptag
= CALL_EXPR_ARG (call
, 2);
5675 tree newcall
= build_call_expr_internal_loc (EXPR_LOCATION (call
),
5679 TREE_OPERAND (*from_p
, 0) = newcall
;
5683 /* Now see if the above changed *from_p to something we handle specially. */
5684 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
5686 if (ret
!= GS_UNHANDLED
)
5689 /* If we've got a variable sized assignment between two lvalues (i.e. does
5690 not involve a call), then we can make things a bit more straightforward
5691 by converting the assignment to memcpy or memset. */
5692 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
5694 tree from
= TREE_OPERAND (*from_p
, 0);
5695 tree size
= TREE_OPERAND (*from_p
, 1);
5697 if (TREE_CODE (from
) == CONSTRUCTOR
)
5698 return gimplify_modify_expr_to_memset (expr_p
, size
, want_value
, pre_p
);
5700 if (is_gimple_addressable (from
))
5703 return gimplify_modify_expr_to_memcpy (expr_p
, size
, want_value
,
5708 /* Transform partial stores to non-addressable complex variables into
5709 total stores. This allows us to use real instead of virtual operands
5710 for these variables, which improves optimization. */
5711 if ((TREE_CODE (*to_p
) == REALPART_EXPR
5712 || TREE_CODE (*to_p
) == IMAGPART_EXPR
)
5713 && is_gimple_reg (TREE_OPERAND (*to_p
, 0)))
5714 return gimplify_modify_expr_complex_part (expr_p
, pre_p
, want_value
);
5716 /* Try to alleviate the effects of the gimplification creating artificial
5717 temporaries (see for example is_gimple_reg_rhs) on the debug info, but
5718 make sure not to create DECL_DEBUG_EXPR links across functions. */
5719 if (!gimplify_ctxp
->into_ssa
5721 && DECL_IGNORED_P (*from_p
)
5723 && !DECL_IGNORED_P (*to_p
)
5724 && decl_function_context (*to_p
) == current_function_decl
5725 && decl_function_context (*from_p
) == current_function_decl
)
5727 if (!DECL_NAME (*from_p
) && DECL_NAME (*to_p
))
5729 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p
)));
5730 DECL_HAS_DEBUG_EXPR_P (*from_p
) = 1;
5731 SET_DECL_DEBUG_EXPR (*from_p
, *to_p
);
5734 if (want_value
&& TREE_THIS_VOLATILE (*to_p
))
5735 *from_p
= get_initialized_tmp_var (*from_p
, pre_p
, post_p
);
5737 if (TREE_CODE (*from_p
) == CALL_EXPR
)
5739 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
5740 instead of a GIMPLE_ASSIGN. */
5742 if (CALL_EXPR_FN (*from_p
) == NULL_TREE
)
5744 /* Gimplify internal functions created in the FEs. */
5745 int nargs
= call_expr_nargs (*from_p
), i
;
5746 enum internal_fn ifn
= CALL_EXPR_IFN (*from_p
);
5747 auto_vec
<tree
> vargs (nargs
);
5749 for (i
= 0; i
< nargs
; i
++)
5751 gimplify_arg (&CALL_EXPR_ARG (*from_p
, i
), pre_p
,
5752 EXPR_LOCATION (*from_p
));
5753 vargs
.quick_push (CALL_EXPR_ARG (*from_p
, i
));
5755 call_stmt
= gimple_build_call_internal_vec (ifn
, vargs
);
5756 gimple_call_set_nothrow (call_stmt
, TREE_NOTHROW (*from_p
));
5757 gimple_set_location (call_stmt
, EXPR_LOCATION (*expr_p
));
5761 tree fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*from_p
));
5762 CALL_EXPR_FN (*from_p
) = TREE_OPERAND (CALL_EXPR_FN (*from_p
), 0);
5763 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p
));
5764 tree fndecl
= get_callee_fndecl (*from_p
);
5766 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
5767 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_EXPECT
5768 && call_expr_nargs (*from_p
) == 3)
5769 call_stmt
= gimple_build_call_internal (IFN_BUILTIN_EXPECT
, 3,
5770 CALL_EXPR_ARG (*from_p
, 0),
5771 CALL_EXPR_ARG (*from_p
, 1),
5772 CALL_EXPR_ARG (*from_p
, 2));
5775 call_stmt
= gimple_build_call_from_tree (*from_p
, fnptrtype
);
5778 notice_special_calls (call_stmt
);
5779 if (!gimple_call_noreturn_p (call_stmt
) || !should_remove_lhs_p (*to_p
))
5780 gimple_call_set_lhs (call_stmt
, *to_p
);
5781 else if (TREE_CODE (*to_p
) == SSA_NAME
)
5782 /* The above is somewhat premature, avoid ICEing later for a
5783 SSA name w/o a definition. We may have uses in the GIMPLE IL.
5784 ??? This doesn't make it a default-def. */
5785 SSA_NAME_DEF_STMT (*to_p
) = gimple_build_nop ();
5791 assign
= gimple_build_assign (*to_p
, *from_p
);
5792 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
5793 if (COMPARISON_CLASS_P (*from_p
))
5794 gimple_set_no_warning (assign
, TREE_NO_WARNING (*from_p
));
5797 if (gimplify_ctxp
->into_ssa
&& is_gimple_reg (*to_p
))
5799 /* We should have got an SSA name from the start. */
5800 gcc_assert (TREE_CODE (*to_p
) == SSA_NAME
5801 || ! gimple_in_ssa_p (cfun
));
5804 gimplify_seq_add_stmt (pre_p
, assign
);
5805 gsi
= gsi_last (*pre_p
);
5806 maybe_fold_stmt (&gsi
);
5810 *expr_p
= TREE_THIS_VOLATILE (*to_p
) ? *from_p
: unshare_expr (*to_p
);
5819 /* Gimplify a comparison between two variable-sized objects. Do this
5820 with a call to BUILT_IN_MEMCMP. */
5822 static enum gimplify_status
5823 gimplify_variable_sized_compare (tree
*expr_p
)
5825 location_t loc
= EXPR_LOCATION (*expr_p
);
5826 tree op0
= TREE_OPERAND (*expr_p
, 0);
5827 tree op1
= TREE_OPERAND (*expr_p
, 1);
5828 tree t
, arg
, dest
, src
, expr
;
5830 arg
= TYPE_SIZE_UNIT (TREE_TYPE (op0
));
5831 arg
= unshare_expr (arg
);
5832 arg
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg
, op0
);
5833 src
= build_fold_addr_expr_loc (loc
, op1
);
5834 dest
= build_fold_addr_expr_loc (loc
, op0
);
5835 t
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
5836 t
= build_call_expr_loc (loc
, t
, 3, dest
, src
, arg
);
5839 = build2 (TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), t
, integer_zero_node
);
5840 SET_EXPR_LOCATION (expr
, loc
);
5846 /* Gimplify a comparison between two aggregate objects of integral scalar
5847 mode as a comparison between the bitwise equivalent scalar values. */
5849 static enum gimplify_status
5850 gimplify_scalar_mode_aggregate_compare (tree
*expr_p
)
5852 location_t loc
= EXPR_LOCATION (*expr_p
);
5853 tree op0
= TREE_OPERAND (*expr_p
, 0);
5854 tree op1
= TREE_OPERAND (*expr_p
, 1);
5856 tree type
= TREE_TYPE (op0
);
5857 tree scalar_type
= lang_hooks
.types
.type_for_mode (TYPE_MODE (type
), 1);
5859 op0
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op0
);
5860 op1
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op1
);
5863 = fold_build2_loc (loc
, TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), op0
, op1
);
5868 /* Gimplify an expression sequence. This function gimplifies each
5869 expression and rewrites the original expression with the last
5870 expression of the sequence in GIMPLE form.
5872 PRE_P points to the list where the side effects for all the
5873 expressions in the sequence will be emitted.
5875 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
5877 static enum gimplify_status
5878 gimplify_compound_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
5884 tree
*sub_p
= &TREE_OPERAND (t
, 0);
5886 if (TREE_CODE (*sub_p
) == COMPOUND_EXPR
)
5887 gimplify_compound_expr (sub_p
, pre_p
, false);
5889 gimplify_stmt (sub_p
, pre_p
);
5891 t
= TREE_OPERAND (t
, 1);
5893 while (TREE_CODE (t
) == COMPOUND_EXPR
);
5900 gimplify_stmt (expr_p
, pre_p
);
5905 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
5906 gimplify. After gimplification, EXPR_P will point to a new temporary
5907 that holds the original value of the SAVE_EXPR node.
5909 PRE_P points to the list where side effects that must happen before
5910 *EXPR_P should be stored. */
5912 static enum gimplify_status
5913 gimplify_save_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5915 enum gimplify_status ret
= GS_ALL_DONE
;
5918 gcc_assert (TREE_CODE (*expr_p
) == SAVE_EXPR
);
5919 val
= TREE_OPERAND (*expr_p
, 0);
5921 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
5922 if (!SAVE_EXPR_RESOLVED_P (*expr_p
))
5924 /* The operand may be a void-valued expression. It is
5925 being executed only for its side-effects. */
5926 if (TREE_TYPE (val
) == void_type_node
)
5928 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
5929 is_gimple_stmt
, fb_none
);
5933 /* The temporary may not be an SSA name as later abnormal and EH
5934 control flow may invalidate use/def domination. When in SSA
5935 form then assume there are no such issues and SAVE_EXPRs only
5936 appear via GENERIC foldings. */
5937 val
= get_initialized_tmp_var (val
, pre_p
, post_p
,
5938 gimple_in_ssa_p (cfun
));
5940 TREE_OPERAND (*expr_p
, 0) = val
;
5941 SAVE_EXPR_RESOLVED_P (*expr_p
) = 1;
5949 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
5956 PRE_P points to the list where side effects that must happen before
5957 *EXPR_P should be stored.
5959 POST_P points to the list where side effects that must happen after
5960 *EXPR_P should be stored. */
5962 static enum gimplify_status
5963 gimplify_addr_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5965 tree expr
= *expr_p
;
5966 tree op0
= TREE_OPERAND (expr
, 0);
5967 enum gimplify_status ret
;
5968 location_t loc
= EXPR_LOCATION (*expr_p
);
5970 switch (TREE_CODE (op0
))
5974 /* Check if we are dealing with an expression of the form '&*ptr'.
5975 While the front end folds away '&*ptr' into 'ptr', these
5976 expressions may be generated internally by the compiler (e.g.,
5977 builtins like __builtin_va_end). */
5978 /* Caution: the silent array decomposition semantics we allow for
5979 ADDR_EXPR means we can't always discard the pair. */
5980 /* Gimplification of the ADDR_EXPR operand may drop
5981 cv-qualification conversions, so make sure we add them if
5984 tree op00
= TREE_OPERAND (op0
, 0);
5985 tree t_expr
= TREE_TYPE (expr
);
5986 tree t_op00
= TREE_TYPE (op00
);
5988 if (!useless_type_conversion_p (t_expr
, t_op00
))
5989 op00
= fold_convert_loc (loc
, TREE_TYPE (expr
), op00
);
5995 case VIEW_CONVERT_EXPR
:
5996 /* Take the address of our operand and then convert it to the type of
5999 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
6000 all clear. The impact of this transformation is even less clear. */
6002 /* If the operand is a useless conversion, look through it. Doing so
6003 guarantees that the ADDR_EXPR and its operand will remain of the
6005 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0
, 0)))
6006 op0
= TREE_OPERAND (op0
, 0);
6008 *expr_p
= fold_convert_loc (loc
, TREE_TYPE (expr
),
6009 build_fold_addr_expr_loc (loc
,
6010 TREE_OPERAND (op0
, 0)));
6015 if (integer_zerop (TREE_OPERAND (op0
, 1)))
6016 goto do_indirect_ref
;
6021 /* If we see a call to a declared builtin or see its address
6022 being taken (we can unify those cases here) then we can mark
6023 the builtin for implicit generation by GCC. */
6024 if (TREE_CODE (op0
) == FUNCTION_DECL
6025 && DECL_BUILT_IN_CLASS (op0
) == BUILT_IN_NORMAL
6026 && builtin_decl_declared_p (DECL_FUNCTION_CODE (op0
)))
6027 set_builtin_decl_implicit_p (DECL_FUNCTION_CODE (op0
), true);
6029 /* We use fb_either here because the C frontend sometimes takes
6030 the address of a call that returns a struct; see
6031 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
6032 the implied temporary explicit. */
6034 /* Make the operand addressable. */
6035 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, post_p
,
6036 is_gimple_addressable
, fb_either
);
6037 if (ret
== GS_ERROR
)
6040 /* Then mark it. Beware that it may not be possible to do so directly
6041 if a temporary has been created by the gimplification. */
6042 prepare_gimple_addressable (&TREE_OPERAND (expr
, 0), pre_p
);
6044 op0
= TREE_OPERAND (expr
, 0);
6046 /* For various reasons, the gimplification of the expression
6047 may have made a new INDIRECT_REF. */
6048 if (TREE_CODE (op0
) == INDIRECT_REF
)
6049 goto do_indirect_ref
;
6051 mark_addressable (TREE_OPERAND (expr
, 0));
6053 /* The FEs may end up building ADDR_EXPRs early on a decl with
6054 an incomplete type. Re-build ADDR_EXPRs in canonical form
6056 if (!types_compatible_p (TREE_TYPE (op0
), TREE_TYPE (TREE_TYPE (expr
))))
6057 *expr_p
= build_fold_addr_expr (op0
);
6059 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
6060 recompute_tree_invariant_for_addr_expr (*expr_p
);
6062 /* If we re-built the ADDR_EXPR add a conversion to the original type
6064 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
6065 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
6073 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
6074 value; output operands should be a gimple lvalue. */
6076 static enum gimplify_status
6077 gimplify_asm_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
6081 const char **oconstraints
;
6084 const char *constraint
;
6085 bool allows_mem
, allows_reg
, is_inout
;
6086 enum gimplify_status ret
, tret
;
6088 vec
<tree
, va_gc
> *inputs
;
6089 vec
<tree
, va_gc
> *outputs
;
6090 vec
<tree
, va_gc
> *clobbers
;
6091 vec
<tree
, va_gc
> *labels
;
6095 noutputs
= list_length (ASM_OUTPUTS (expr
));
6096 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
6104 link_next
= NULL_TREE
;
6105 for (i
= 0, link
= ASM_OUTPUTS (expr
); link
; ++i
, link
= link_next
)
6108 size_t constraint_len
;
6110 link_next
= TREE_CHAIN (link
);
6114 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
6115 constraint_len
= strlen (constraint
);
6116 if (constraint_len
== 0)
6119 ok
= parse_output_constraint (&constraint
, i
, 0, 0,
6120 &allows_mem
, &allows_reg
, &is_inout
);
6127 if (!allows_reg
&& allows_mem
)
6128 mark_addressable (TREE_VALUE (link
));
6130 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
6131 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
6132 fb_lvalue
| fb_mayfail
);
6133 if (tret
== GS_ERROR
)
6135 error ("invalid lvalue in asm output %d", i
);
6139 /* If the constraint does not allow memory make sure we gimplify
6140 it to a register if it is not already but its base is. This
6141 happens for complex and vector components. */
6144 tree op
= TREE_VALUE (link
);
6145 if (! is_gimple_val (op
)
6146 && is_gimple_reg_type (TREE_TYPE (op
))
6147 && is_gimple_reg (get_base_address (op
)))
6149 tree tem
= create_tmp_reg (TREE_TYPE (op
));
6153 ass
= build2 (MODIFY_EXPR
, TREE_TYPE (tem
),
6154 tem
, unshare_expr (op
));
6155 gimplify_and_add (ass
, pre_p
);
6157 ass
= build2 (MODIFY_EXPR
, TREE_TYPE (tem
), op
, tem
);
6158 gimplify_and_add (ass
, post_p
);
6160 TREE_VALUE (link
) = tem
;
6165 vec_safe_push (outputs
, link
);
6166 TREE_CHAIN (link
) = NULL_TREE
;
6170 /* An input/output operand. To give the optimizers more
6171 flexibility, split it into separate input and output
6174 /* Buffer big enough to format a 32-bit UINT_MAX into. */
6177 /* Turn the in/out constraint into an output constraint. */
6178 char *p
= xstrdup (constraint
);
6180 TREE_VALUE (TREE_PURPOSE (link
)) = build_string (constraint_len
, p
);
6182 /* And add a matching input constraint. */
6185 sprintf (buf
, "%u", i
);
6187 /* If there are multiple alternatives in the constraint,
6188 handle each of them individually. Those that allow register
6189 will be replaced with operand number, the others will stay
6191 if (strchr (p
, ',') != NULL
)
6193 size_t len
= 0, buflen
= strlen (buf
);
6194 char *beg
, *end
, *str
, *dst
;
6198 end
= strchr (beg
, ',');
6200 end
= strchr (beg
, '\0');
6201 if ((size_t) (end
- beg
) < buflen
)
6204 len
+= end
- beg
+ 1;
6211 str
= (char *) alloca (len
);
6212 for (beg
= p
+ 1, dst
= str
;;)
6215 bool mem_p
, reg_p
, inout_p
;
6217 end
= strchr (beg
, ',');
6222 parse_output_constraint (&tem
, i
, 0, 0,
6223 &mem_p
, ®_p
, &inout_p
);
6228 memcpy (dst
, buf
, buflen
);
6237 memcpy (dst
, beg
, len
);
6246 input
= build_string (dst
- str
, str
);
6249 input
= build_string (strlen (buf
), buf
);
6252 input
= build_string (constraint_len
- 1, constraint
+ 1);
6256 input
= build_tree_list (build_tree_list (NULL_TREE
, input
),
6257 unshare_expr (TREE_VALUE (link
)));
6258 ASM_INPUTS (expr
) = chainon (ASM_INPUTS (expr
), input
);
6262 link_next
= NULL_TREE
;
6263 for (link
= ASM_INPUTS (expr
); link
; ++i
, link
= link_next
)
6265 link_next
= TREE_CHAIN (link
);
6266 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
6267 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
6268 oconstraints
, &allows_mem
, &allows_reg
);
6270 /* If we can't make copies, we can only accept memory. */
6271 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link
))))
6277 error ("impossible constraint in %<asm%>");
6278 error ("non-memory input %d must stay in memory", i
);
6283 /* If the operand is a memory input, it should be an lvalue. */
6284 if (!allows_reg
&& allows_mem
)
6286 tree inputv
= TREE_VALUE (link
);
6287 STRIP_NOPS (inputv
);
6288 if (TREE_CODE (inputv
) == PREDECREMENT_EXPR
6289 || TREE_CODE (inputv
) == PREINCREMENT_EXPR
6290 || TREE_CODE (inputv
) == POSTDECREMENT_EXPR
6291 || TREE_CODE (inputv
) == POSTINCREMENT_EXPR
6292 || TREE_CODE (inputv
) == MODIFY_EXPR
)
6293 TREE_VALUE (link
) = error_mark_node
;
6294 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
6295 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
6296 if (tret
!= GS_ERROR
)
6298 /* Unlike output operands, memory inputs are not guaranteed
6299 to be lvalues by the FE, and while the expressions are
6300 marked addressable there, if it is e.g. a statement
6301 expression, temporaries in it might not end up being
6302 addressable. They might be already used in the IL and thus
6303 it is too late to make them addressable now though. */
6304 tree x
= TREE_VALUE (link
);
6305 while (handled_component_p (x
))
6306 x
= TREE_OPERAND (x
, 0);
6307 if (TREE_CODE (x
) == MEM_REF
6308 && TREE_CODE (TREE_OPERAND (x
, 0)) == ADDR_EXPR
)
6309 x
= TREE_OPERAND (TREE_OPERAND (x
, 0), 0);
6311 || TREE_CODE (x
) == PARM_DECL
6312 || TREE_CODE (x
) == RESULT_DECL
)
6313 && !TREE_ADDRESSABLE (x
)
6314 && is_gimple_reg (x
))
6316 warning_at (EXPR_LOC_OR_LOC (TREE_VALUE (link
),
6318 "memory input %d is not directly addressable",
6320 prepare_gimple_addressable (&TREE_VALUE (link
), pre_p
);
6323 mark_addressable (TREE_VALUE (link
));
6324 if (tret
== GS_ERROR
)
6326 error_at (EXPR_LOC_OR_LOC (TREE_VALUE (link
), input_location
),
6327 "memory input %d is not directly addressable", i
);
6333 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
6334 is_gimple_asm_val
, fb_rvalue
);
6335 if (tret
== GS_ERROR
)
6339 TREE_CHAIN (link
) = NULL_TREE
;
6340 vec_safe_push (inputs
, link
);
6343 link_next
= NULL_TREE
;
6344 for (link
= ASM_CLOBBERS (expr
); link
; ++i
, link
= link_next
)
6346 link_next
= TREE_CHAIN (link
);
6347 TREE_CHAIN (link
) = NULL_TREE
;
6348 vec_safe_push (clobbers
, link
);
6351 link_next
= NULL_TREE
;
6352 for (link
= ASM_LABELS (expr
); link
; ++i
, link
= link_next
)
6354 link_next
= TREE_CHAIN (link
);
6355 TREE_CHAIN (link
) = NULL_TREE
;
6356 vec_safe_push (labels
, link
);
6359 /* Do not add ASMs with errors to the gimple IL stream. */
6360 if (ret
!= GS_ERROR
)
6362 stmt
= gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr
)),
6363 inputs
, outputs
, clobbers
, labels
);
6365 gimple_asm_set_volatile (stmt
, ASM_VOLATILE_P (expr
) || noutputs
== 0);
6366 gimple_asm_set_input (stmt
, ASM_INPUT_P (expr
));
6368 gimplify_seq_add_stmt (pre_p
, stmt
);
6374 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
6375 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
6376 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
6377 return to this function.
6379 FIXME should we complexify the prequeue handling instead? Or use flags
6380 for all the cleanups and let the optimizer tighten them up? The current
6381 code seems pretty fragile; it will break on a cleanup within any
6382 non-conditional nesting. But any such nesting would be broken, anyway;
6383 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
6384 and continues out of it. We can do that at the RTL level, though, so
6385 having an optimizer to tighten up try/finally regions would be a Good
6388 static enum gimplify_status
6389 gimplify_cleanup_point_expr (tree
*expr_p
, gimple_seq
*pre_p
)
6391 gimple_stmt_iterator iter
;
6392 gimple_seq body_sequence
= NULL
;
6394 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
6396 /* We only care about the number of conditions between the innermost
6397 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
6398 any cleanups collected outside the CLEANUP_POINT_EXPR. */
6399 int old_conds
= gimplify_ctxp
->conditions
;
6400 gimple_seq old_cleanups
= gimplify_ctxp
->conditional_cleanups
;
6401 bool old_in_cleanup_point_expr
= gimplify_ctxp
->in_cleanup_point_expr
;
6402 gimplify_ctxp
->conditions
= 0;
6403 gimplify_ctxp
->conditional_cleanups
= NULL
;
6404 gimplify_ctxp
->in_cleanup_point_expr
= true;
6406 gimplify_stmt (&TREE_OPERAND (*expr_p
, 0), &body_sequence
);
6408 gimplify_ctxp
->conditions
= old_conds
;
6409 gimplify_ctxp
->conditional_cleanups
= old_cleanups
;
6410 gimplify_ctxp
->in_cleanup_point_expr
= old_in_cleanup_point_expr
;
6412 for (iter
= gsi_start (body_sequence
); !gsi_end_p (iter
); )
6414 gimple
*wce
= gsi_stmt (iter
);
6416 if (gimple_code (wce
) == GIMPLE_WITH_CLEANUP_EXPR
)
6418 if (gsi_one_before_end_p (iter
))
6420 /* Note that gsi_insert_seq_before and gsi_remove do not
6421 scan operands, unlike some other sequence mutators. */
6422 if (!gimple_wce_cleanup_eh_only (wce
))
6423 gsi_insert_seq_before_without_update (&iter
,
6424 gimple_wce_cleanup (wce
),
6426 gsi_remove (&iter
, true);
6433 enum gimple_try_flags kind
;
6435 if (gimple_wce_cleanup_eh_only (wce
))
6436 kind
= GIMPLE_TRY_CATCH
;
6438 kind
= GIMPLE_TRY_FINALLY
;
6439 seq
= gsi_split_seq_after (iter
);
6441 gtry
= gimple_build_try (seq
, gimple_wce_cleanup (wce
), kind
);
6442 /* Do not use gsi_replace here, as it may scan operands.
6443 We want to do a simple structural modification only. */
6444 gsi_set_stmt (&iter
, gtry
);
6445 iter
= gsi_start (gtry
->eval
);
6452 gimplify_seq_add_seq (pre_p
, body_sequence
);
6465 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
6466 is the cleanup action required. EH_ONLY is true if the cleanup should
6467 only be executed if an exception is thrown, not on normal exit.
6468 If FORCE_UNCOND is true perform the cleanup unconditionally; this is
6469 only valid for clobbers. */
6472 gimple_push_cleanup (tree var
, tree cleanup
, bool eh_only
, gimple_seq
*pre_p
,
6473 bool force_uncond
= false)
6476 gimple_seq cleanup_stmts
= NULL
;
6478 /* Errors can result in improperly nested cleanups. Which results in
6479 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
6483 if (gimple_conditional_context ())
6485 /* If we're in a conditional context, this is more complex. We only
6486 want to run the cleanup if we actually ran the initialization that
6487 necessitates it, but we want to run it after the end of the
6488 conditional context. So we wrap the try/finally around the
6489 condition and use a flag to determine whether or not to actually
6490 run the destructor. Thus
6494 becomes (approximately)
6498 if (test) { A::A(temp); flag = 1; val = f(temp); }
6501 if (flag) A::~A(temp);
6507 gimplify_stmt (&cleanup
, &cleanup_stmts
);
6508 wce
= gimple_build_wce (cleanup_stmts
);
6509 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
6513 tree flag
= create_tmp_var (boolean_type_node
, "cleanup");
6514 gassign
*ffalse
= gimple_build_assign (flag
, boolean_false_node
);
6515 gassign
*ftrue
= gimple_build_assign (flag
, boolean_true_node
);
6517 cleanup
= build3 (COND_EXPR
, void_type_node
, flag
, cleanup
, NULL
);
6518 gimplify_stmt (&cleanup
, &cleanup_stmts
);
6519 wce
= gimple_build_wce (cleanup_stmts
);
6521 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, ffalse
);
6522 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
6523 gimplify_seq_add_stmt (pre_p
, ftrue
);
6525 /* Because of this manipulation, and the EH edges that jump
6526 threading cannot redirect, the temporary (VAR) will appear
6527 to be used uninitialized. Don't warn. */
6528 TREE_NO_WARNING (var
) = 1;
6533 gimplify_stmt (&cleanup
, &cleanup_stmts
);
6534 wce
= gimple_build_wce (cleanup_stmts
);
6535 gimple_wce_set_cleanup_eh_only (wce
, eh_only
);
6536 gimplify_seq_add_stmt (pre_p
, wce
);
6540 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
6542 static enum gimplify_status
6543 gimplify_target_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
6545 tree targ
= *expr_p
;
6546 tree temp
= TARGET_EXPR_SLOT (targ
);
6547 tree init
= TARGET_EXPR_INITIAL (targ
);
6548 enum gimplify_status ret
;
6550 bool unpoison_empty_seq
= false;
6551 gimple_stmt_iterator unpoison_it
;
6555 tree cleanup
= NULL_TREE
;
6557 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
6558 to the temps list. Handle also variable length TARGET_EXPRs. */
6559 if (TREE_CODE (DECL_SIZE (temp
)) != INTEGER_CST
)
6561 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp
)))
6562 gimplify_type_sizes (TREE_TYPE (temp
), pre_p
);
6563 gimplify_vla_decl (temp
, pre_p
);
6567 /* Save location where we need to place unpoisoning. It's possible
6568 that a variable will be converted to needs_to_live_in_memory. */
6569 unpoison_it
= gsi_last (*pre_p
);
6570 unpoison_empty_seq
= gsi_end_p (unpoison_it
);
6572 gimple_add_tmp_var (temp
);
6575 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
6576 expression is supposed to initialize the slot. */
6577 if (VOID_TYPE_P (TREE_TYPE (init
)))
6578 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
6581 tree init_expr
= build2 (INIT_EXPR
, void_type_node
, temp
, init
);
6583 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
6585 ggc_free (init_expr
);
6587 if (ret
== GS_ERROR
)
6589 /* PR c++/28266 Make sure this is expanded only once. */
6590 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
6594 gimplify_and_add (init
, pre_p
);
6596 /* If needed, push the cleanup for the temp. */
6597 if (TARGET_EXPR_CLEANUP (targ
))
6599 if (CLEANUP_EH_ONLY (targ
))
6600 gimple_push_cleanup (temp
, TARGET_EXPR_CLEANUP (targ
),
6601 CLEANUP_EH_ONLY (targ
), pre_p
);
6603 cleanup
= TARGET_EXPR_CLEANUP (targ
);
6606 /* Add a clobber for the temporary going out of scope, like
6607 gimplify_bind_expr. */
6608 if (gimplify_ctxp
->in_cleanup_point_expr
6609 && needs_to_live_in_memory (temp
))
6611 if (flag_stack_reuse
== SR_ALL
)
6613 tree clobber
= build_clobber (TREE_TYPE (temp
));
6614 clobber
= build2 (MODIFY_EXPR
, TREE_TYPE (temp
), temp
, clobber
);
6615 gimple_push_cleanup (temp
, clobber
, false, pre_p
, true);
6617 if (asan_poisoned_variables
6618 && DECL_ALIGN (temp
) <= MAX_SUPPORTED_STACK_ALIGNMENT
6619 && dbg_cnt (asan_use_after_scope
)
6620 && !gimplify_omp_ctxp
)
6622 tree asan_cleanup
= build_asan_poison_call_expr (temp
);
6625 if (unpoison_empty_seq
)
6626 unpoison_it
= gsi_start (*pre_p
);
6628 asan_poison_variable (temp
, false, &unpoison_it
,
6629 unpoison_empty_seq
);
6630 gimple_push_cleanup (temp
, asan_cleanup
, false, pre_p
);
6635 gimple_push_cleanup (temp
, cleanup
, false, pre_p
);
6637 /* Only expand this once. */
6638 TREE_OPERAND (targ
, 3) = init
;
6639 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
6642 /* We should have expanded this before. */
6643 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp
));
6649 /* Gimplification of expression trees. */
6651 /* Gimplify an expression which appears at statement context. The
6652 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
6653 NULL, a new sequence is allocated.
6655 Return true if we actually added a statement to the queue. */
6658 gimplify_stmt (tree
*stmt_p
, gimple_seq
*seq_p
)
6660 gimple_seq_node last
;
6662 last
= gimple_seq_last (*seq_p
);
6663 gimplify_expr (stmt_p
, seq_p
, NULL
, is_gimple_stmt
, fb_none
);
6664 return last
!= gimple_seq_last (*seq_p
);
6667 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
6668 to CTX. If entries already exist, force them to be some flavor of private.
6669 If there is no enclosing parallel, do nothing. */
6672 omp_firstprivatize_variable (struct gimplify_omp_ctx
*ctx
, tree decl
)
6676 if (decl
== NULL
|| !DECL_P (decl
) || ctx
->region_type
== ORT_NONE
)
6681 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
6684 if (n
->value
& GOVD_SHARED
)
6685 n
->value
= GOVD_FIRSTPRIVATE
| (n
->value
& GOVD_SEEN
);
6686 else if (n
->value
& GOVD_MAP
)
6687 n
->value
|= GOVD_MAP_TO_ONLY
;
6691 else if ((ctx
->region_type
& ORT_TARGET
) != 0)
6693 if (ctx
->target_map_scalars_firstprivate
)
6694 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
6696 omp_add_variable (ctx
, decl
, GOVD_MAP
| GOVD_MAP_TO_ONLY
);
6698 else if (ctx
->region_type
!= ORT_WORKSHARE
6699 && ctx
->region_type
!= ORT_SIMD
6700 && ctx
->region_type
!= ORT_ACC
6701 && !(ctx
->region_type
& ORT_TARGET_DATA
))
6702 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
6704 ctx
= ctx
->outer_context
;
6709 /* Similarly for each of the type sizes of TYPE. */
6712 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx
*ctx
, tree type
)
6714 if (type
== NULL
|| type
== error_mark_node
)
6716 type
= TYPE_MAIN_VARIANT (type
);
6718 if (ctx
->privatized_types
->add (type
))
6721 switch (TREE_CODE (type
))
6727 case FIXED_POINT_TYPE
:
6728 omp_firstprivatize_variable (ctx
, TYPE_MIN_VALUE (type
));
6729 omp_firstprivatize_variable (ctx
, TYPE_MAX_VALUE (type
));
6733 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
6734 omp_firstprivatize_type_sizes (ctx
, TYPE_DOMAIN (type
));
6739 case QUAL_UNION_TYPE
:
6742 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
6743 if (TREE_CODE (field
) == FIELD_DECL
)
6745 omp_firstprivatize_variable (ctx
, DECL_FIELD_OFFSET (field
));
6746 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (field
));
6752 case REFERENCE_TYPE
:
6753 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
6760 omp_firstprivatize_variable (ctx
, TYPE_SIZE (type
));
6761 omp_firstprivatize_variable (ctx
, TYPE_SIZE_UNIT (type
));
6762 lang_hooks
.types
.omp_firstprivatize_type_sizes (ctx
, type
);
6765 /* Add an entry for DECL in the OMP context CTX with FLAGS. */
6768 omp_add_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned int flags
)
6771 unsigned int nflags
;
6774 if (error_operand_p (decl
) || ctx
->region_type
== ORT_NONE
)
6777 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
6778 there are constructors involved somewhere. Exception is a shared clause,
6779 there is nothing privatized in that case. */
6780 if ((flags
& GOVD_SHARED
) == 0
6781 && (TREE_ADDRESSABLE (TREE_TYPE (decl
))
6782 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))))
6785 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
6786 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
6788 /* We shouldn't be re-adding the decl with the same data
6790 gcc_assert ((n
->value
& GOVD_DATA_SHARE_CLASS
& flags
) == 0);
6791 nflags
= n
->value
| flags
;
6792 /* The only combination of data sharing classes we should see is
6793 FIRSTPRIVATE and LASTPRIVATE. However, OpenACC permits
6794 reduction variables to be used in data sharing clauses. */
6795 gcc_assert ((ctx
->region_type
& ORT_ACC
) != 0
6796 || ((nflags
& GOVD_DATA_SHARE_CLASS
)
6797 == (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
))
6798 || (flags
& GOVD_DATA_SHARE_CLASS
) == 0);
6803 /* When adding a variable-sized variable, we have to handle all sorts
6804 of additional bits of data: the pointer replacement variable, and
6805 the parameters of the type. */
6806 if (DECL_SIZE (decl
) && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6808 /* Add the pointer replacement variable as PRIVATE if the variable
6809 replacement is private, else FIRSTPRIVATE since we'll need the
6810 address of the original variable either for SHARED, or for the
6811 copy into or out of the context. */
6812 if (!(flags
& GOVD_LOCAL
))
6814 if (flags
& GOVD_MAP
)
6815 nflags
= GOVD_MAP
| GOVD_MAP_TO_ONLY
| GOVD_EXPLICIT
;
6816 else if (flags
& GOVD_PRIVATE
)
6817 nflags
= GOVD_PRIVATE
;
6818 else if ((ctx
->region_type
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0
6819 && (flags
& GOVD_FIRSTPRIVATE
))
6820 nflags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
6822 nflags
= GOVD_FIRSTPRIVATE
;
6823 nflags
|= flags
& GOVD_SEEN
;
6824 t
= DECL_VALUE_EXPR (decl
);
6825 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
6826 t
= TREE_OPERAND (t
, 0);
6827 gcc_assert (DECL_P (t
));
6828 omp_add_variable (ctx
, t
, nflags
);
6831 /* Add all of the variable and type parameters (which should have
6832 been gimplified to a formal temporary) as FIRSTPRIVATE. */
6833 omp_firstprivatize_variable (ctx
, DECL_SIZE_UNIT (decl
));
6834 omp_firstprivatize_variable (ctx
, DECL_SIZE (decl
));
6835 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
6837 /* The variable-sized variable itself is never SHARED, only some form
6838 of PRIVATE. The sharing would take place via the pointer variable
6839 which we remapped above. */
6840 if (flags
& GOVD_SHARED
)
6841 flags
= GOVD_SHARED
| GOVD_DEBUG_PRIVATE
6842 | (flags
& (GOVD_SEEN
| GOVD_EXPLICIT
));
6844 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
6845 alloca statement we generate for the variable, so make sure it
6846 is available. This isn't automatically needed for the SHARED
6847 case, since we won't be allocating local storage then.
6848 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
6849 in this case omp_notice_variable will be called later
6850 on when it is gimplified. */
6851 else if (! (flags
& (GOVD_LOCAL
| GOVD_MAP
))
6852 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl
))))
6853 omp_notice_variable (ctx
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)), true);
6855 else if ((flags
& (GOVD_MAP
| GOVD_LOCAL
)) == 0
6856 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
6858 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
6860 /* Similar to the direct variable sized case above, we'll need the
6861 size of references being privatized. */
6862 if ((flags
& GOVD_SHARED
) == 0)
6864 t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
6866 omp_notice_variable (ctx
, t
, true);
6873 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, flags
);
6875 /* For reductions clauses in OpenACC loop directives, by default create a
6876 copy clause on the enclosing parallel construct for carrying back the
6878 if (ctx
->region_type
== ORT_ACC
&& (flags
& GOVD_REDUCTION
))
6880 struct gimplify_omp_ctx
*outer_ctx
= ctx
->outer_context
;
6883 n
= splay_tree_lookup (outer_ctx
->variables
, (splay_tree_key
)decl
);
6886 /* Ignore local variables and explicitly declared clauses. */
6887 if (n
->value
& (GOVD_LOCAL
| GOVD_EXPLICIT
))
6889 else if (outer_ctx
->region_type
== ORT_ACC_KERNELS
)
6891 /* According to the OpenACC spec, such a reduction variable
6892 should already have a copy map on a kernels construct,
6893 verify that here. */
6894 gcc_assert (!(n
->value
& GOVD_FIRSTPRIVATE
)
6895 && (n
->value
& GOVD_MAP
));
6897 else if (outer_ctx
->region_type
== ORT_ACC_PARALLEL
)
6899 /* Remove firstprivate and make it a copy map. */
6900 n
->value
&= ~GOVD_FIRSTPRIVATE
;
6901 n
->value
|= GOVD_MAP
;
6904 else if (outer_ctx
->region_type
== ORT_ACC_PARALLEL
)
6906 splay_tree_insert (outer_ctx
->variables
, (splay_tree_key
)decl
,
6907 GOVD_MAP
| GOVD_SEEN
);
6910 outer_ctx
= outer_ctx
->outer_context
;
6915 /* Notice a threadprivate variable DECL used in OMP context CTX.
6916 This just prints out diagnostics about threadprivate variable uses
6917 in untied tasks. If DECL2 is non-NULL, prevent this warning
6918 on that variable. */
6921 omp_notice_threadprivate_variable (struct gimplify_omp_ctx
*ctx
, tree decl
,
6925 struct gimplify_omp_ctx
*octx
;
6927 for (octx
= ctx
; octx
; octx
= octx
->outer_context
)
6928 if ((octx
->region_type
& ORT_TARGET
) != 0)
6930 n
= splay_tree_lookup (octx
->variables
, (splay_tree_key
)decl
);
6933 error ("threadprivate variable %qE used in target region",
6935 error_at (octx
->location
, "enclosing target region");
6936 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl
, 0);
6939 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl2
, 0);
6942 if (ctx
->region_type
!= ORT_UNTIED_TASK
)
6944 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
6947 error ("threadprivate variable %qE used in untied task",
6949 error_at (ctx
->location
, "enclosing task");
6950 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, 0);
6953 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl2
, 0);
6957 /* Return true if global var DECL is device resident. */
6960 device_resident_p (tree decl
)
6962 tree attr
= lookup_attribute ("oacc declare target", DECL_ATTRIBUTES (decl
));
6967 for (tree t
= TREE_VALUE (attr
); t
; t
= TREE_PURPOSE (t
))
6969 tree c
= TREE_VALUE (t
);
6970 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_DEVICE_RESIDENT
)
6977 /* Return true if DECL has an ACC DECLARE attribute. */
6980 is_oacc_declared (tree decl
)
6982 tree t
= TREE_CODE (decl
) == MEM_REF
? TREE_OPERAND (decl
, 0) : decl
;
6983 tree declared
= lookup_attribute ("oacc declare target", DECL_ATTRIBUTES (t
));
6984 return declared
!= NULL_TREE
;
6987 /* Determine outer default flags for DECL mentioned in an OMP region
6988 but not declared in an enclosing clause.
6990 ??? Some compiler-generated variables (like SAVE_EXPRs) could be
6991 remapped firstprivate instead of shared. To some extent this is
6992 addressed in omp_firstprivatize_type_sizes, but not
6996 omp_default_clause (struct gimplify_omp_ctx
*ctx
, tree decl
,
6997 bool in_code
, unsigned flags
)
6999 enum omp_clause_default_kind default_kind
= ctx
->default_kind
;
7000 enum omp_clause_default_kind kind
;
7002 kind
= lang_hooks
.decls
.omp_predetermined_sharing (decl
);
7003 if (kind
!= OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
7004 default_kind
= kind
;
7006 switch (default_kind
)
7008 case OMP_CLAUSE_DEFAULT_NONE
:
7012 if (ctx
->region_type
& ORT_PARALLEL
)
7014 else if (ctx
->region_type
& ORT_TASK
)
7016 else if (ctx
->region_type
& ORT_TEAMS
)
7021 error ("%qE not specified in enclosing %qs",
7022 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)), rtype
);
7023 error_at (ctx
->location
, "enclosing %qs", rtype
);
7026 case OMP_CLAUSE_DEFAULT_SHARED
:
7027 flags
|= GOVD_SHARED
;
7029 case OMP_CLAUSE_DEFAULT_PRIVATE
:
7030 flags
|= GOVD_PRIVATE
;
7032 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
7033 flags
|= GOVD_FIRSTPRIVATE
;
7035 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
7036 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
7037 gcc_assert ((ctx
->region_type
& ORT_TASK
) != 0);
7038 if (struct gimplify_omp_ctx
*octx
= ctx
->outer_context
)
7040 omp_notice_variable (octx
, decl
, in_code
);
7041 for (; octx
; octx
= octx
->outer_context
)
7045 n2
= splay_tree_lookup (octx
->variables
, (splay_tree_key
) decl
);
7046 if ((octx
->region_type
& (ORT_TARGET_DATA
| ORT_TARGET
)) != 0
7047 && (n2
== NULL
|| (n2
->value
& GOVD_DATA_SHARE_CLASS
) == 0))
7049 if (n2
&& (n2
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
)
7051 flags
|= GOVD_FIRSTPRIVATE
;
7054 if ((octx
->region_type
& (ORT_PARALLEL
| ORT_TEAMS
)) != 0)
7056 flags
|= GOVD_SHARED
;
7062 if (TREE_CODE (decl
) == PARM_DECL
7063 || (!is_global_var (decl
)
7064 && DECL_CONTEXT (decl
) == current_function_decl
))
7065 flags
|= GOVD_FIRSTPRIVATE
;
7067 flags
|= GOVD_SHARED
;
7079 /* Determine outer default flags for DECL mentioned in an OACC region
7080 but not declared in an enclosing clause. */
7083 oacc_default_clause (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned flags
)
7086 bool on_device
= false;
7087 bool declared
= is_oacc_declared (decl
);
7088 tree type
= TREE_TYPE (decl
);
7090 if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
7091 type
= TREE_TYPE (type
);
7093 if ((ctx
->region_type
& (ORT_ACC_PARALLEL
| ORT_ACC_KERNELS
)) != 0
7094 && is_global_var (decl
)
7095 && device_resident_p (decl
))
7098 flags
|= GOVD_MAP_TO_ONLY
;
7101 switch (ctx
->region_type
)
7103 case ORT_ACC_KERNELS
:
7106 if (AGGREGATE_TYPE_P (type
))
7108 /* Aggregates default to 'present_or_copy', or 'present'. */
7109 if (ctx
->default_kind
!= OMP_CLAUSE_DEFAULT_PRESENT
)
7112 flags
|= GOVD_MAP
| GOVD_MAP_FORCE_PRESENT
;
7115 /* Scalars default to 'copy'. */
7116 flags
|= GOVD_MAP
| GOVD_MAP_FORCE
;
7120 case ORT_ACC_PARALLEL
:
7123 if (on_device
|| declared
)
7125 else if (AGGREGATE_TYPE_P (type
))
7127 /* Aggregates default to 'present_or_copy', or 'present'. */
7128 if (ctx
->default_kind
!= OMP_CLAUSE_DEFAULT_PRESENT
)
7131 flags
|= GOVD_MAP
| GOVD_MAP_FORCE_PRESENT
;
7134 /* Scalars default to 'firstprivate'. */
7135 flags
|= GOVD_FIRSTPRIVATE
;
7143 if (DECL_ARTIFICIAL (decl
))
7144 ; /* We can get compiler-generated decls, and should not complain
7146 else if (ctx
->default_kind
== OMP_CLAUSE_DEFAULT_NONE
)
7148 error ("%qE not specified in enclosing OpenACC %qs construct",
7149 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)), rkind
);
7150 inform (ctx
->location
, "enclosing OpenACC %qs construct", rkind
);
7152 else if (ctx
->default_kind
== OMP_CLAUSE_DEFAULT_PRESENT
)
7153 ; /* Handled above. */
7155 gcc_checking_assert (ctx
->default_kind
== OMP_CLAUSE_DEFAULT_SHARED
);
7160 /* Record the fact that DECL was used within the OMP context CTX.
7161 IN_CODE is true when real code uses DECL, and false when we should
7162 merely emit default(none) errors. Return true if DECL is going to
7163 be remapped and thus DECL shouldn't be gimplified into its
7164 DECL_VALUE_EXPR (if any). */
7167 omp_notice_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, bool in_code
)
7170 unsigned flags
= in_code
? GOVD_SEEN
: 0;
7171 bool ret
= false, shared
;
7173 if (error_operand_p (decl
))
7176 if (ctx
->region_type
== ORT_NONE
)
7177 return lang_hooks
.decls
.omp_disregard_value_expr (decl
, false);
7179 if (is_global_var (decl
))
7181 /* Threadprivate variables are predetermined. */
7182 if (DECL_THREAD_LOCAL_P (decl
))
7183 return omp_notice_threadprivate_variable (ctx
, decl
, NULL_TREE
);
7185 if (DECL_HAS_VALUE_EXPR_P (decl
))
7187 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
7189 if (value
&& DECL_P (value
) && DECL_THREAD_LOCAL_P (value
))
7190 return omp_notice_threadprivate_variable (ctx
, decl
, value
);
7193 if (gimplify_omp_ctxp
->outer_context
== NULL
7195 && oacc_get_fn_attrib (current_function_decl
))
7197 location_t loc
= DECL_SOURCE_LOCATION (decl
);
7199 if (lookup_attribute ("omp declare target link",
7200 DECL_ATTRIBUTES (decl
)))
7203 "%qE with %<link%> clause used in %<routine%> function",
7207 else if (!lookup_attribute ("omp declare target",
7208 DECL_ATTRIBUTES (decl
)))
7211 "%qE requires a %<declare%> directive for use "
7212 "in a %<routine%> function", DECL_NAME (decl
));
7218 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
7219 if ((ctx
->region_type
& ORT_TARGET
) != 0)
7221 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, true);
7224 unsigned nflags
= flags
;
7225 if (ctx
->target_map_pointers_as_0len_arrays
7226 || ctx
->target_map_scalars_firstprivate
)
7228 bool is_declare_target
= false;
7229 bool is_scalar
= false;
7230 if (is_global_var (decl
)
7231 && varpool_node::get_create (decl
)->offloadable
)
7233 struct gimplify_omp_ctx
*octx
;
7234 for (octx
= ctx
->outer_context
;
7235 octx
; octx
= octx
->outer_context
)
7237 n
= splay_tree_lookup (octx
->variables
,
7238 (splay_tree_key
)decl
);
7240 && (n
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
7241 && (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
7244 is_declare_target
= octx
== NULL
;
7246 if (!is_declare_target
&& ctx
->target_map_scalars_firstprivate
)
7247 is_scalar
= lang_hooks
.decls
.omp_scalar_p (decl
);
7248 if (is_declare_target
)
7250 else if (ctx
->target_map_pointers_as_0len_arrays
7251 && (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
7252 || (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
7253 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
)))
7255 nflags
|= GOVD_MAP
| GOVD_MAP_0LEN_ARRAY
;
7257 nflags
|= GOVD_FIRSTPRIVATE
;
7260 struct gimplify_omp_ctx
*octx
= ctx
->outer_context
;
7261 if ((ctx
->region_type
& ORT_ACC
) && octx
)
7263 /* Look in outer OpenACC contexts, to see if there's a
7264 data attribute for this variable. */
7265 omp_notice_variable (octx
, decl
, in_code
);
7267 for (; octx
; octx
= octx
->outer_context
)
7269 if (!(octx
->region_type
& (ORT_TARGET_DATA
| ORT_TARGET
)))
7272 = splay_tree_lookup (octx
->variables
,
7273 (splay_tree_key
) decl
);
7276 if (octx
->region_type
== ORT_ACC_HOST_DATA
)
7277 error ("variable %qE declared in enclosing "
7278 "%<host_data%> region", DECL_NAME (decl
));
7280 if (octx
->region_type
== ORT_ACC_DATA
7281 && (n2
->value
& GOVD_MAP_0LEN_ARRAY
))
7282 nflags
|= GOVD_MAP_0LEN_ARRAY
;
7289 tree type
= TREE_TYPE (decl
);
7292 && gimplify_omp_ctxp
->target_firstprivatize_array_bases
7293 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
7294 type
= TREE_TYPE (type
);
7296 && !lang_hooks
.types
.omp_mappable_type (type
))
7298 error ("%qD referenced in target region does not have "
7299 "a mappable type", decl
);
7300 nflags
|= GOVD_MAP
| GOVD_EXPLICIT
;
7302 else if (nflags
== flags
)
7304 if ((ctx
->region_type
& ORT_ACC
) != 0)
7305 nflags
= oacc_default_clause (ctx
, decl
, flags
);
7311 omp_add_variable (ctx
, decl
, nflags
);
7315 /* If nothing changed, there's nothing left to do. */
7316 if ((n
->value
& flags
) == flags
)
7326 if (ctx
->region_type
== ORT_WORKSHARE
7327 || ctx
->region_type
== ORT_SIMD
7328 || ctx
->region_type
== ORT_ACC
7329 || (ctx
->region_type
& ORT_TARGET_DATA
) != 0)
7332 flags
= omp_default_clause (ctx
, decl
, in_code
, flags
);
7334 if ((flags
& GOVD_PRIVATE
)
7335 && lang_hooks
.decls
.omp_private_outer_ref (decl
))
7336 flags
|= GOVD_PRIVATE_OUTER_REF
;
7338 omp_add_variable (ctx
, decl
, flags
);
7340 shared
= (flags
& GOVD_SHARED
) != 0;
7341 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
7345 if ((n
->value
& (GOVD_SEEN
| GOVD_LOCAL
)) == 0
7346 && (flags
& (GOVD_SEEN
| GOVD_LOCAL
)) == GOVD_SEEN
7347 && DECL_SIZE (decl
))
7349 if (TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
7352 tree t
= DECL_VALUE_EXPR (decl
);
7353 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
7354 t
= TREE_OPERAND (t
, 0);
7355 gcc_assert (DECL_P (t
));
7356 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
7357 n2
->value
|= GOVD_SEEN
;
7359 else if (lang_hooks
.decls
.omp_privatize_by_reference (decl
)
7360 && TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)))
7361 && (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
))))
7365 tree t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
7366 gcc_assert (DECL_P (t
));
7367 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
7369 omp_notice_variable (ctx
, t
, true);
7373 shared
= ((flags
| n
->value
) & GOVD_SHARED
) != 0;
7374 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
7376 /* If nothing changed, there's nothing left to do. */
7377 if ((n
->value
& flags
) == flags
)
7383 /* If the variable is private in the current context, then we don't
7384 need to propagate anything to an outer context. */
7385 if ((flags
& GOVD_PRIVATE
) && !(flags
& GOVD_PRIVATE_OUTER_REF
))
7387 if ((flags
& (GOVD_LINEAR
| GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
7388 == (GOVD_LINEAR
| GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
7390 if ((flags
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
7391 | GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
7392 == (GOVD_LASTPRIVATE
| GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
7394 if (ctx
->outer_context
7395 && omp_notice_variable (ctx
->outer_context
, decl
, in_code
))
7400 /* Verify that DECL is private within CTX. If there's specific information
7401 to the contrary in the innermost scope, generate an error. */
7404 omp_is_private (struct gimplify_omp_ctx
*ctx
, tree decl
, int simd
)
7408 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
7411 if (n
->value
& GOVD_SHARED
)
7413 if (ctx
== gimplify_omp_ctxp
)
7416 error ("iteration variable %qE is predetermined linear",
7419 error ("iteration variable %qE should be private",
7421 n
->value
= GOVD_PRIVATE
;
7427 else if ((n
->value
& GOVD_EXPLICIT
) != 0
7428 && (ctx
== gimplify_omp_ctxp
7429 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
7430 && gimplify_omp_ctxp
->outer_context
== ctx
)))
7432 if ((n
->value
& GOVD_FIRSTPRIVATE
) != 0)
7433 error ("iteration variable %qE should not be firstprivate",
7435 else if ((n
->value
& GOVD_REDUCTION
) != 0)
7436 error ("iteration variable %qE should not be reduction",
7438 else if (simd
== 0 && (n
->value
& GOVD_LINEAR
) != 0)
7439 error ("iteration variable %qE should not be linear",
7441 else if (simd
== 1 && (n
->value
& GOVD_LASTPRIVATE
) != 0)
7442 error ("iteration variable %qE should not be lastprivate",
7444 else if (simd
&& (n
->value
& GOVD_PRIVATE
) != 0)
7445 error ("iteration variable %qE should not be private",
7447 else if (simd
== 2 && (n
->value
& GOVD_LINEAR
) != 0)
7448 error ("iteration variable %qE is predetermined linear",
7451 return (ctx
== gimplify_omp_ctxp
7452 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
7453 && gimplify_omp_ctxp
->outer_context
== ctx
));
7456 if (ctx
->region_type
!= ORT_WORKSHARE
7457 && ctx
->region_type
!= ORT_SIMD
7458 && ctx
->region_type
!= ORT_ACC
)
7460 else if (ctx
->outer_context
)
7461 return omp_is_private (ctx
->outer_context
, decl
, simd
);
7465 /* Return true if DECL is private within a parallel region
7466 that binds to the current construct's context or in parallel
7467 region's REDUCTION clause. */
7470 omp_check_private (struct gimplify_omp_ctx
*ctx
, tree decl
, bool copyprivate
)
7476 ctx
= ctx
->outer_context
;
7479 if (is_global_var (decl
))
7482 /* References might be private, but might be shared too,
7483 when checking for copyprivate, assume they might be
7484 private, otherwise assume they might be shared. */
7488 if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
7491 /* Treat C++ privatized non-static data members outside
7492 of the privatization the same. */
7493 if (omp_member_access_dummy_var (decl
))
7499 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
7501 if ((ctx
->region_type
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0
7502 && (n
== NULL
|| (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0))
7507 if ((n
->value
& GOVD_LOCAL
) != 0
7508 && omp_member_access_dummy_var (decl
))
7510 return (n
->value
& GOVD_SHARED
) == 0;
7513 while (ctx
->region_type
== ORT_WORKSHARE
7514 || ctx
->region_type
== ORT_SIMD
7515 || ctx
->region_type
== ORT_ACC
);
7519 /* Callback for walk_tree to find a DECL_EXPR for the given DECL. */
7522 find_decl_expr (tree
*tp
, int *walk_subtrees
, void *data
)
7526 /* If this node has been visited, unmark it and keep looking. */
7527 if (TREE_CODE (t
) == DECL_EXPR
&& DECL_EXPR_DECL (t
) == (tree
) data
)
7530 if (IS_TYPE_OR_DECL_P (t
))
7535 /* Scan the OMP clauses in *LIST_P, installing mappings into a new
7536 and previous omp contexts. */
7539 gimplify_scan_omp_clauses (tree
*list_p
, gimple_seq
*pre_p
,
7540 enum omp_region_type region_type
,
7541 enum tree_code code
)
7543 struct gimplify_omp_ctx
*ctx
, *outer_ctx
;
7545 hash_map
<tree
, tree
> *struct_map_to_clause
= NULL
;
7546 tree
*prev_list_p
= NULL
;
7548 ctx
= new_omp_context (region_type
);
7549 outer_ctx
= ctx
->outer_context
;
7550 if (code
== OMP_TARGET
)
7552 if (!lang_GNU_Fortran ())
7553 ctx
->target_map_pointers_as_0len_arrays
= true;
7554 ctx
->target_map_scalars_firstprivate
= true;
7556 if (!lang_GNU_Fortran ())
7560 case OMP_TARGET_DATA
:
7561 case OMP_TARGET_ENTER_DATA
:
7562 case OMP_TARGET_EXIT_DATA
:
7564 case OACC_HOST_DATA
:
7565 ctx
->target_firstprivatize_array_bases
= true;
7570 while ((c
= *list_p
) != NULL
)
7572 bool remove
= false;
7573 bool notice_outer
= true;
7574 const char *check_non_private
= NULL
;
7578 switch (OMP_CLAUSE_CODE (c
))
7580 case OMP_CLAUSE_PRIVATE
:
7581 flags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
7582 if (lang_hooks
.decls
.omp_private_outer_ref (OMP_CLAUSE_DECL (c
)))
7584 flags
|= GOVD_PRIVATE_OUTER_REF
;
7585 OMP_CLAUSE_PRIVATE_OUTER_REF (c
) = 1;
7588 notice_outer
= false;
7590 case OMP_CLAUSE_SHARED
:
7591 flags
= GOVD_SHARED
| GOVD_EXPLICIT
;
7593 case OMP_CLAUSE_FIRSTPRIVATE
:
7594 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
7595 check_non_private
= "firstprivate";
7597 case OMP_CLAUSE_LASTPRIVATE
:
7598 flags
= GOVD_LASTPRIVATE
| GOVD_SEEN
| GOVD_EXPLICIT
;
7599 check_non_private
= "lastprivate";
7600 decl
= OMP_CLAUSE_DECL (c
);
7601 if (error_operand_p (decl
))
7604 && (outer_ctx
->region_type
== ORT_COMBINED_PARALLEL
7605 || outer_ctx
->region_type
== ORT_COMBINED_TEAMS
)
7606 && splay_tree_lookup (outer_ctx
->variables
,
7607 (splay_tree_key
) decl
) == NULL
)
7609 omp_add_variable (outer_ctx
, decl
, GOVD_SHARED
| GOVD_SEEN
);
7610 if (outer_ctx
->outer_context
)
7611 omp_notice_variable (outer_ctx
->outer_context
, decl
, true);
7614 && (outer_ctx
->region_type
& ORT_TASK
) != 0
7615 && outer_ctx
->combined_loop
7616 && splay_tree_lookup (outer_ctx
->variables
,
7617 (splay_tree_key
) decl
) == NULL
)
7619 omp_add_variable (outer_ctx
, decl
, GOVD_LASTPRIVATE
| GOVD_SEEN
);
7620 if (outer_ctx
->outer_context
)
7621 omp_notice_variable (outer_ctx
->outer_context
, decl
, true);
7624 && (outer_ctx
->region_type
== ORT_WORKSHARE
7625 || outer_ctx
->region_type
== ORT_ACC
)
7626 && outer_ctx
->combined_loop
7627 && splay_tree_lookup (outer_ctx
->variables
,
7628 (splay_tree_key
) decl
) == NULL
7629 && !omp_check_private (outer_ctx
, decl
, false))
7631 omp_add_variable (outer_ctx
, decl
, GOVD_LASTPRIVATE
| GOVD_SEEN
);
7632 if (outer_ctx
->outer_context
7633 && (outer_ctx
->outer_context
->region_type
7634 == ORT_COMBINED_PARALLEL
)
7635 && splay_tree_lookup (outer_ctx
->outer_context
->variables
,
7636 (splay_tree_key
) decl
) == NULL
)
7638 struct gimplify_omp_ctx
*octx
= outer_ctx
->outer_context
;
7639 omp_add_variable (octx
, decl
, GOVD_SHARED
| GOVD_SEEN
);
7640 if (octx
->outer_context
)
7642 octx
= octx
->outer_context
;
7643 if (octx
->region_type
== ORT_WORKSHARE
7644 && octx
->combined_loop
7645 && splay_tree_lookup (octx
->variables
,
7646 (splay_tree_key
) decl
) == NULL
7647 && !omp_check_private (octx
, decl
, false))
7649 omp_add_variable (octx
, decl
,
7650 GOVD_LASTPRIVATE
| GOVD_SEEN
);
7651 octx
= octx
->outer_context
;
7653 && octx
->region_type
== ORT_COMBINED_TEAMS
7654 && (splay_tree_lookup (octx
->variables
,
7655 (splay_tree_key
) decl
)
7658 omp_add_variable (octx
, decl
,
7659 GOVD_SHARED
| GOVD_SEEN
);
7660 octx
= octx
->outer_context
;
7664 omp_notice_variable (octx
, decl
, true);
7667 else if (outer_ctx
->outer_context
)
7668 omp_notice_variable (outer_ctx
->outer_context
, decl
, true);
7671 case OMP_CLAUSE_REDUCTION
:
7672 flags
= GOVD_REDUCTION
| GOVD_SEEN
| GOVD_EXPLICIT
;
7673 /* OpenACC permits reductions on private variables. */
7674 if (!(region_type
& ORT_ACC
))
7675 check_non_private
= "reduction";
7676 decl
= OMP_CLAUSE_DECL (c
);
7677 if (TREE_CODE (decl
) == MEM_REF
)
7679 tree type
= TREE_TYPE (decl
);
7680 if (gimplify_expr (&TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), pre_p
,
7681 NULL
, is_gimple_val
, fb_rvalue
, false)
7687 tree v
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
7690 omp_firstprivatize_variable (ctx
, v
);
7691 omp_notice_variable (ctx
, v
, true);
7693 decl
= TREE_OPERAND (decl
, 0);
7694 if (TREE_CODE (decl
) == POINTER_PLUS_EXPR
)
7696 if (gimplify_expr (&TREE_OPERAND (decl
, 1), pre_p
,
7697 NULL
, is_gimple_val
, fb_rvalue
, false)
7703 v
= TREE_OPERAND (decl
, 1);
7706 omp_firstprivatize_variable (ctx
, v
);
7707 omp_notice_variable (ctx
, v
, true);
7709 decl
= TREE_OPERAND (decl
, 0);
7711 if (TREE_CODE (decl
) == ADDR_EXPR
7712 || TREE_CODE (decl
) == INDIRECT_REF
)
7713 decl
= TREE_OPERAND (decl
, 0);
7716 case OMP_CLAUSE_LINEAR
:
7717 if (gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
), pre_p
, NULL
,
7718 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
7725 if (code
== OMP_SIMD
7726 && !OMP_CLAUSE_LINEAR_NO_COPYIN (c
))
7728 struct gimplify_omp_ctx
*octx
= outer_ctx
;
7730 && octx
->region_type
== ORT_WORKSHARE
7731 && octx
->combined_loop
7732 && !octx
->distribute
)
7734 if (octx
->outer_context
7735 && (octx
->outer_context
->region_type
7736 == ORT_COMBINED_PARALLEL
))
7737 octx
= octx
->outer_context
->outer_context
;
7739 octx
= octx
->outer_context
;
7742 && octx
->region_type
== ORT_WORKSHARE
7743 && octx
->combined_loop
7744 && octx
->distribute
)
7746 error_at (OMP_CLAUSE_LOCATION (c
),
7747 "%<linear%> clause for variable other than "
7748 "loop iterator specified on construct "
7749 "combined with %<distribute%>");
7754 /* For combined #pragma omp parallel for simd, need to put
7755 lastprivate and perhaps firstprivate too on the
7756 parallel. Similarly for #pragma omp for simd. */
7757 struct gimplify_omp_ctx
*octx
= outer_ctx
;
7761 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
7762 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
7764 decl
= OMP_CLAUSE_DECL (c
);
7765 if (error_operand_p (decl
))
7771 if (!OMP_CLAUSE_LINEAR_NO_COPYIN (c
))
7772 flags
|= GOVD_FIRSTPRIVATE
;
7773 if (!OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
7774 flags
|= GOVD_LASTPRIVATE
;
7776 && octx
->region_type
== ORT_WORKSHARE
7777 && octx
->combined_loop
)
7779 if (octx
->outer_context
7780 && (octx
->outer_context
->region_type
7781 == ORT_COMBINED_PARALLEL
))
7782 octx
= octx
->outer_context
;
7783 else if (omp_check_private (octx
, decl
, false))
7787 && (octx
->region_type
& ORT_TASK
) != 0
7788 && octx
->combined_loop
)
7791 && octx
->region_type
== ORT_COMBINED_PARALLEL
7792 && ctx
->region_type
== ORT_WORKSHARE
7793 && octx
== outer_ctx
)
7794 flags
= GOVD_SEEN
| GOVD_SHARED
;
7796 && octx
->region_type
== ORT_COMBINED_TEAMS
)
7797 flags
= GOVD_SEEN
| GOVD_SHARED
;
7799 && octx
->region_type
== ORT_COMBINED_TARGET
)
7801 flags
&= ~GOVD_LASTPRIVATE
;
7802 if (flags
== GOVD_SEEN
)
7808 = splay_tree_lookup (octx
->variables
,
7809 (splay_tree_key
) decl
);
7810 if (on
&& (on
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
7815 omp_add_variable (octx
, decl
, flags
);
7816 if (octx
->outer_context
== NULL
)
7818 octx
= octx
->outer_context
;
7823 && (!OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
7824 || !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)))
7825 omp_notice_variable (octx
, decl
, true);
7827 flags
= GOVD_LINEAR
| GOVD_EXPLICIT
;
7828 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
7829 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
7831 notice_outer
= false;
7832 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
7836 case OMP_CLAUSE_MAP
:
7837 decl
= OMP_CLAUSE_DECL (c
);
7838 if (error_operand_p (decl
))
7845 if (TREE_CODE (TREE_TYPE (decl
)) != ARRAY_TYPE
)
7848 case OMP_TARGET_DATA
:
7849 case OMP_TARGET_ENTER_DATA
:
7850 case OMP_TARGET_EXIT_DATA
:
7851 case OACC_ENTER_DATA
:
7852 case OACC_EXIT_DATA
:
7853 case OACC_HOST_DATA
:
7854 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
7855 || (OMP_CLAUSE_MAP_KIND (c
)
7856 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
7857 /* For target {,enter ,exit }data only the array slice is
7858 mapped, but not the pointer to it. */
7866 if (DECL_P (decl
) && outer_ctx
&& (region_type
& ORT_ACC
))
7868 struct gimplify_omp_ctx
*octx
;
7869 for (octx
= outer_ctx
; octx
; octx
= octx
->outer_context
)
7871 if (octx
->region_type
!= ORT_ACC_HOST_DATA
)
7874 = splay_tree_lookup (octx
->variables
,
7875 (splay_tree_key
) decl
);
7877 error_at (OMP_CLAUSE_LOCATION (c
), "variable %qE "
7878 "declared in enclosing %<host_data%> region",
7882 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
7883 OMP_CLAUSE_SIZE (c
) = DECL_P (decl
) ? DECL_SIZE_UNIT (decl
)
7884 : TYPE_SIZE_UNIT (TREE_TYPE (decl
));
7885 if (gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
7886 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
7891 else if ((OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
7892 || (OMP_CLAUSE_MAP_KIND (c
)
7893 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
7894 && TREE_CODE (OMP_CLAUSE_SIZE (c
)) != INTEGER_CST
)
7897 = get_initialized_tmp_var (OMP_CLAUSE_SIZE (c
), pre_p
, NULL
,
7899 omp_add_variable (ctx
, OMP_CLAUSE_SIZE (c
),
7900 GOVD_FIRSTPRIVATE
| GOVD_SEEN
);
7905 if (TREE_CODE (d
) == ARRAY_REF
)
7907 while (TREE_CODE (d
) == ARRAY_REF
)
7908 d
= TREE_OPERAND (d
, 0);
7909 if (TREE_CODE (d
) == COMPONENT_REF
7910 && TREE_CODE (TREE_TYPE (d
)) == ARRAY_TYPE
)
7913 pd
= &OMP_CLAUSE_DECL (c
);
7915 && TREE_CODE (decl
) == INDIRECT_REF
7916 && TREE_CODE (TREE_OPERAND (decl
, 0)) == COMPONENT_REF
7917 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl
, 0)))
7920 pd
= &TREE_OPERAND (decl
, 0);
7921 decl
= TREE_OPERAND (decl
, 0);
7923 if (TREE_CODE (decl
) == COMPONENT_REF
)
7925 while (TREE_CODE (decl
) == COMPONENT_REF
)
7926 decl
= TREE_OPERAND (decl
, 0);
7927 if (TREE_CODE (decl
) == INDIRECT_REF
7928 && DECL_P (TREE_OPERAND (decl
, 0))
7929 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl
, 0)))
7931 decl
= TREE_OPERAND (decl
, 0);
7933 if (gimplify_expr (pd
, pre_p
, NULL
, is_gimple_lvalue
, fb_lvalue
)
7941 if (error_operand_p (decl
))
7947 tree stype
= TREE_TYPE (decl
);
7948 if (TREE_CODE (stype
) == REFERENCE_TYPE
)
7949 stype
= TREE_TYPE (stype
);
7950 if (TYPE_SIZE_UNIT (stype
) == NULL
7951 || TREE_CODE (TYPE_SIZE_UNIT (stype
)) != INTEGER_CST
)
7953 error_at (OMP_CLAUSE_LOCATION (c
),
7954 "mapping field %qE of variable length "
7955 "structure", OMP_CLAUSE_DECL (c
));
7960 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_POINTER
)
7962 /* Error recovery. */
7963 if (prev_list_p
== NULL
)
7968 if (OMP_CLAUSE_CHAIN (*prev_list_p
) != c
)
7970 tree ch
= OMP_CLAUSE_CHAIN (*prev_list_p
);
7971 if (ch
== NULL_TREE
|| OMP_CLAUSE_CHAIN (ch
) != c
)
7980 poly_int64 bitsize
, bitpos
;
7982 int unsignedp
, reversep
, volatilep
= 0;
7983 tree base
= OMP_CLAUSE_DECL (c
);
7984 while (TREE_CODE (base
) == ARRAY_REF
)
7985 base
= TREE_OPERAND (base
, 0);
7986 if (TREE_CODE (base
) == INDIRECT_REF
)
7987 base
= TREE_OPERAND (base
, 0);
7988 base
= get_inner_reference (base
, &bitsize
, &bitpos
, &offset
,
7989 &mode
, &unsignedp
, &reversep
,
7991 tree orig_base
= base
;
7992 if ((TREE_CODE (base
) == INDIRECT_REF
7993 || (TREE_CODE (base
) == MEM_REF
7994 && integer_zerop (TREE_OPERAND (base
, 1))))
7995 && DECL_P (TREE_OPERAND (base
, 0))
7996 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base
, 0)))
7998 base
= TREE_OPERAND (base
, 0);
7999 gcc_assert (base
== decl
8000 && (offset
== NULL_TREE
8001 || poly_int_tree_p (offset
)));
8004 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
8005 bool ptr
= (OMP_CLAUSE_MAP_KIND (c
)
8006 == GOMP_MAP_ALWAYS_POINTER
);
8007 if (n
== NULL
|| (n
->value
& GOVD_MAP
) == 0)
8009 tree l
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8011 OMP_CLAUSE_SET_MAP_KIND (l
, GOMP_MAP_STRUCT
);
8012 if (orig_base
!= base
)
8013 OMP_CLAUSE_DECL (l
) = unshare_expr (orig_base
);
8015 OMP_CLAUSE_DECL (l
) = decl
;
8016 OMP_CLAUSE_SIZE (l
) = size_int (1);
8017 if (struct_map_to_clause
== NULL
)
8018 struct_map_to_clause
= new hash_map
<tree
, tree
>;
8019 struct_map_to_clause
->put (decl
, l
);
8022 enum gomp_map_kind mkind
8023 = code
== OMP_TARGET_EXIT_DATA
8024 ? GOMP_MAP_RELEASE
: GOMP_MAP_ALLOC
;
8025 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8027 OMP_CLAUSE_SET_MAP_KIND (c2
, mkind
);
8028 OMP_CLAUSE_DECL (c2
)
8029 = unshare_expr (OMP_CLAUSE_DECL (c
));
8030 OMP_CLAUSE_CHAIN (c2
) = *prev_list_p
;
8031 OMP_CLAUSE_SIZE (c2
)
8032 = TYPE_SIZE_UNIT (ptr_type_node
);
8033 OMP_CLAUSE_CHAIN (l
) = c2
;
8034 if (OMP_CLAUSE_CHAIN (*prev_list_p
) != c
)
8036 tree c4
= OMP_CLAUSE_CHAIN (*prev_list_p
);
8038 = build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8040 OMP_CLAUSE_SET_MAP_KIND (c3
, mkind
);
8041 OMP_CLAUSE_DECL (c3
)
8042 = unshare_expr (OMP_CLAUSE_DECL (c4
));
8043 OMP_CLAUSE_SIZE (c3
)
8044 = TYPE_SIZE_UNIT (ptr_type_node
);
8045 OMP_CLAUSE_CHAIN (c3
) = *prev_list_p
;
8046 OMP_CLAUSE_CHAIN (c2
) = c3
;
8053 OMP_CLAUSE_CHAIN (l
) = c
;
8055 list_p
= &OMP_CLAUSE_CHAIN (l
);
8057 if (orig_base
!= base
&& code
== OMP_TARGET
)
8059 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8061 enum gomp_map_kind mkind
8062 = GOMP_MAP_FIRSTPRIVATE_REFERENCE
;
8063 OMP_CLAUSE_SET_MAP_KIND (c2
, mkind
);
8064 OMP_CLAUSE_DECL (c2
) = decl
;
8065 OMP_CLAUSE_SIZE (c2
) = size_zero_node
;
8066 OMP_CLAUSE_CHAIN (c2
) = OMP_CLAUSE_CHAIN (l
);
8067 OMP_CLAUSE_CHAIN (l
) = c2
;
8069 flags
= GOVD_MAP
| GOVD_EXPLICIT
;
8070 if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c
)) || ptr
)
8076 tree
*osc
= struct_map_to_clause
->get (decl
);
8077 tree
*sc
= NULL
, *scp
= NULL
;
8078 if (GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c
)) || ptr
)
8079 n
->value
|= GOVD_SEEN
;
8080 poly_offset_int o1
, o2
;
8082 o1
= wi::to_poly_offset (offset
);
8085 if (maybe_ne (bitpos
, 0))
8086 o1
+= bits_to_bytes_round_down (bitpos
);
8087 sc
= &OMP_CLAUSE_CHAIN (*osc
);
8089 && (OMP_CLAUSE_MAP_KIND (*sc
)
8090 == GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
8091 sc
= &OMP_CLAUSE_CHAIN (*sc
);
8092 for (; *sc
!= c
; sc
= &OMP_CLAUSE_CHAIN (*sc
))
8093 if (ptr
&& sc
== prev_list_p
)
8095 else if (TREE_CODE (OMP_CLAUSE_DECL (*sc
))
8097 && (TREE_CODE (OMP_CLAUSE_DECL (*sc
))
8099 && (TREE_CODE (OMP_CLAUSE_DECL (*sc
))
8105 poly_int64 bitsize2
, bitpos2
;
8106 base
= OMP_CLAUSE_DECL (*sc
);
8107 if (TREE_CODE (base
) == ARRAY_REF
)
8109 while (TREE_CODE (base
) == ARRAY_REF
)
8110 base
= TREE_OPERAND (base
, 0);
8111 if (TREE_CODE (base
) != COMPONENT_REF
8112 || (TREE_CODE (TREE_TYPE (base
))
8116 else if (TREE_CODE (base
) == INDIRECT_REF
8117 && (TREE_CODE (TREE_OPERAND (base
, 0))
8119 && (TREE_CODE (TREE_TYPE
8120 (TREE_OPERAND (base
, 0)))
8122 base
= TREE_OPERAND (base
, 0);
8123 base
= get_inner_reference (base
, &bitsize2
,
8126 &reversep
, &volatilep
);
8127 if ((TREE_CODE (base
) == INDIRECT_REF
8128 || (TREE_CODE (base
) == MEM_REF
8129 && integer_zerop (TREE_OPERAND (base
,
8131 && DECL_P (TREE_OPERAND (base
, 0))
8132 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (base
,
8135 base
= TREE_OPERAND (base
, 0);
8140 gcc_assert (offset
== NULL_TREE
8141 || poly_int_tree_p (offset
));
8142 tree d1
= OMP_CLAUSE_DECL (*sc
);
8143 tree d2
= OMP_CLAUSE_DECL (c
);
8144 while (TREE_CODE (d1
) == ARRAY_REF
)
8145 d1
= TREE_OPERAND (d1
, 0);
8146 while (TREE_CODE (d2
) == ARRAY_REF
)
8147 d2
= TREE_OPERAND (d2
, 0);
8148 if (TREE_CODE (d1
) == INDIRECT_REF
)
8149 d1
= TREE_OPERAND (d1
, 0);
8150 if (TREE_CODE (d2
) == INDIRECT_REF
)
8151 d2
= TREE_OPERAND (d2
, 0);
8152 while (TREE_CODE (d1
) == COMPONENT_REF
)
8153 if (TREE_CODE (d2
) == COMPONENT_REF
8154 && TREE_OPERAND (d1
, 1)
8155 == TREE_OPERAND (d2
, 1))
8157 d1
= TREE_OPERAND (d1
, 0);
8158 d2
= TREE_OPERAND (d2
, 0);
8164 error_at (OMP_CLAUSE_LOCATION (c
),
8165 "%qE appears more than once in map "
8166 "clauses", OMP_CLAUSE_DECL (c
));
8171 o2
= wi::to_poly_offset (offset2
);
8174 o2
+= bits_to_bytes_round_down (bitpos2
);
8175 if (maybe_lt (o1
, o2
)
8176 || (known_eq (o1
, 2)
8177 && maybe_lt (bitpos
, bitpos2
)))
8187 OMP_CLAUSE_SIZE (*osc
)
8188 = size_binop (PLUS_EXPR
, OMP_CLAUSE_SIZE (*osc
),
8192 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8194 tree cl
= NULL_TREE
;
8195 enum gomp_map_kind mkind
8196 = code
== OMP_TARGET_EXIT_DATA
8197 ? GOMP_MAP_RELEASE
: GOMP_MAP_ALLOC
;
8198 OMP_CLAUSE_SET_MAP_KIND (c2
, mkind
);
8199 OMP_CLAUSE_DECL (c2
)
8200 = unshare_expr (OMP_CLAUSE_DECL (c
));
8201 OMP_CLAUSE_CHAIN (c2
) = scp
? *scp
: *prev_list_p
;
8202 OMP_CLAUSE_SIZE (c2
)
8203 = TYPE_SIZE_UNIT (ptr_type_node
);
8204 cl
= scp
? *prev_list_p
: c2
;
8205 if (OMP_CLAUSE_CHAIN (*prev_list_p
) != c
)
8207 tree c4
= OMP_CLAUSE_CHAIN (*prev_list_p
);
8209 = build_omp_clause (OMP_CLAUSE_LOCATION (c
),
8211 OMP_CLAUSE_SET_MAP_KIND (c3
, mkind
);
8212 OMP_CLAUSE_DECL (c3
)
8213 = unshare_expr (OMP_CLAUSE_DECL (c4
));
8214 OMP_CLAUSE_SIZE (c3
)
8215 = TYPE_SIZE_UNIT (ptr_type_node
);
8216 OMP_CLAUSE_CHAIN (c3
) = *prev_list_p
;
8218 OMP_CLAUSE_CHAIN (c2
) = c3
;
8224 if (sc
== prev_list_p
)
8231 *prev_list_p
= OMP_CLAUSE_CHAIN (c
);
8232 list_p
= prev_list_p
;
8234 OMP_CLAUSE_CHAIN (c
) = *sc
;
8241 *list_p
= OMP_CLAUSE_CHAIN (c
);
8242 OMP_CLAUSE_CHAIN (c
) = *sc
;
8249 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_ALWAYS_POINTER
8250 && OMP_CLAUSE_CHAIN (c
)
8251 && OMP_CLAUSE_CODE (OMP_CLAUSE_CHAIN (c
)) == OMP_CLAUSE_MAP
8252 && (OMP_CLAUSE_MAP_KIND (OMP_CLAUSE_CHAIN (c
))
8253 == GOMP_MAP_ALWAYS_POINTER
))
8254 prev_list_p
= list_p
;
8257 flags
= GOVD_MAP
| GOVD_EXPLICIT
;
8258 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_TO
8259 || OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_TOFROM
)
8260 flags
|= GOVD_MAP_ALWAYS_TO
;
8263 case OMP_CLAUSE_DEPEND
:
8264 if (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
)
8266 tree deps
= OMP_CLAUSE_DECL (c
);
8267 while (deps
&& TREE_CODE (deps
) == TREE_LIST
)
8269 if (TREE_CODE (TREE_PURPOSE (deps
)) == TRUNC_DIV_EXPR
8270 && DECL_P (TREE_OPERAND (TREE_PURPOSE (deps
), 1)))
8271 gimplify_expr (&TREE_OPERAND (TREE_PURPOSE (deps
), 1),
8272 pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
8273 deps
= TREE_CHAIN (deps
);
8277 else if (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SOURCE
)
8279 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == COMPOUND_EXPR
)
8281 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0), pre_p
,
8282 NULL
, is_gimple_val
, fb_rvalue
);
8283 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (OMP_CLAUSE_DECL (c
), 1);
8285 if (error_operand_p (OMP_CLAUSE_DECL (c
)))
8290 OMP_CLAUSE_DECL (c
) = build_fold_addr_expr (OMP_CLAUSE_DECL (c
));
8291 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
, NULL
,
8292 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8300 case OMP_CLAUSE_FROM
:
8301 case OMP_CLAUSE__CACHE_
:
8302 decl
= OMP_CLAUSE_DECL (c
);
8303 if (error_operand_p (decl
))
8308 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
8309 OMP_CLAUSE_SIZE (c
) = DECL_P (decl
) ? DECL_SIZE_UNIT (decl
)
8310 : TYPE_SIZE_UNIT (TREE_TYPE (decl
));
8311 if (gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
8312 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8319 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
,
8320 NULL
, is_gimple_lvalue
, fb_lvalue
)
8330 case OMP_CLAUSE_USE_DEVICE_PTR
:
8331 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
8333 case OMP_CLAUSE_IS_DEVICE_PTR
:
8334 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
8338 decl
= OMP_CLAUSE_DECL (c
);
8340 if (error_operand_p (decl
))
8345 if (DECL_NAME (decl
) == NULL_TREE
&& (flags
& GOVD_SHARED
) == 0)
8347 tree t
= omp_member_access_dummy_var (decl
);
8350 tree v
= DECL_VALUE_EXPR (decl
);
8351 DECL_NAME (decl
) = DECL_NAME (TREE_OPERAND (v
, 1));
8353 omp_notice_variable (outer_ctx
, t
, true);
8356 if (code
== OACC_DATA
8357 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
8358 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
)
8359 flags
|= GOVD_MAP_0LEN_ARRAY
;
8360 omp_add_variable (ctx
, decl
, flags
);
8361 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
8362 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
8364 omp_add_variable (ctx
, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
),
8365 GOVD_LOCAL
| GOVD_SEEN
);
8366 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
)
8367 && walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c
),
8369 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
),
8371 omp_add_variable (ctx
,
8372 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
),
8373 GOVD_LOCAL
| GOVD_SEEN
);
8374 gimplify_omp_ctxp
= ctx
;
8375 push_gimplify_context ();
8377 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
8378 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
8380 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c
),
8381 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
8382 pop_gimplify_context
8383 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
)));
8384 push_gimplify_context ();
8385 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c
),
8386 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
8387 pop_gimplify_context
8388 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
)));
8389 OMP_CLAUSE_REDUCTION_INIT (c
) = NULL_TREE
;
8390 OMP_CLAUSE_REDUCTION_MERGE (c
) = NULL_TREE
;
8392 gimplify_omp_ctxp
= outer_ctx
;
8394 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
8395 && OMP_CLAUSE_LASTPRIVATE_STMT (c
))
8397 gimplify_omp_ctxp
= ctx
;
8398 push_gimplify_context ();
8399 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c
)) != BIND_EXPR
)
8401 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
8403 TREE_SIDE_EFFECTS (bind
) = 1;
8404 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LASTPRIVATE_STMT (c
);
8405 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = bind
;
8407 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c
),
8408 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
8409 pop_gimplify_context
8410 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
)));
8411 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = NULL_TREE
;
8413 gimplify_omp_ctxp
= outer_ctx
;
8415 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
8416 && OMP_CLAUSE_LINEAR_STMT (c
))
8418 gimplify_omp_ctxp
= ctx
;
8419 push_gimplify_context ();
8420 if (TREE_CODE (OMP_CLAUSE_LINEAR_STMT (c
)) != BIND_EXPR
)
8422 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
8424 TREE_SIDE_EFFECTS (bind
) = 1;
8425 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LINEAR_STMT (c
);
8426 OMP_CLAUSE_LINEAR_STMT (c
) = bind
;
8428 gimplify_and_add (OMP_CLAUSE_LINEAR_STMT (c
),
8429 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
));
8430 pop_gimplify_context
8431 (gimple_seq_first_stmt (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
)));
8432 OMP_CLAUSE_LINEAR_STMT (c
) = NULL_TREE
;
8434 gimplify_omp_ctxp
= outer_ctx
;
8440 case OMP_CLAUSE_COPYIN
:
8441 case OMP_CLAUSE_COPYPRIVATE
:
8442 decl
= OMP_CLAUSE_DECL (c
);
8443 if (error_operand_p (decl
))
8448 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_COPYPRIVATE
8450 && !omp_check_private (ctx
, decl
, true))
8453 if (is_global_var (decl
))
8455 if (DECL_THREAD_LOCAL_P (decl
))
8457 else if (DECL_HAS_VALUE_EXPR_P (decl
))
8459 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
8463 && DECL_THREAD_LOCAL_P (value
))
8468 error_at (OMP_CLAUSE_LOCATION (c
),
8469 "copyprivate variable %qE is not threadprivate"
8470 " or private in outer context", DECL_NAME (decl
));
8474 omp_notice_variable (outer_ctx
, decl
, true);
8475 if (check_non_private
8476 && region_type
== ORT_WORKSHARE
8477 && (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_REDUCTION
8478 || decl
== OMP_CLAUSE_DECL (c
)
8479 || (TREE_CODE (OMP_CLAUSE_DECL (c
)) == MEM_REF
8480 && (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0))
8482 || (TREE_CODE (TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0))
8483 == POINTER_PLUS_EXPR
8484 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND
8485 (OMP_CLAUSE_DECL (c
), 0), 0))
8487 && omp_check_private (ctx
, decl
, false))
8489 error ("%s variable %qE is private in outer context",
8490 check_non_private
, DECL_NAME (decl
));
8496 if (OMP_CLAUSE_IF_MODIFIER (c
) != ERROR_MARK
8497 && OMP_CLAUSE_IF_MODIFIER (c
) != code
)
8500 for (int i
= 0; i
< 2; i
++)
8501 switch (i
? OMP_CLAUSE_IF_MODIFIER (c
) : code
)
8503 case OMP_PARALLEL
: p
[i
] = "parallel"; break;
8504 case OMP_TASK
: p
[i
] = "task"; break;
8505 case OMP_TASKLOOP
: p
[i
] = "taskloop"; break;
8506 case OMP_TARGET_DATA
: p
[i
] = "target data"; break;
8507 case OMP_TARGET
: p
[i
] = "target"; break;
8508 case OMP_TARGET_UPDATE
: p
[i
] = "target update"; break;
8509 case OMP_TARGET_ENTER_DATA
:
8510 p
[i
] = "target enter data"; break;
8511 case OMP_TARGET_EXIT_DATA
: p
[i
] = "target exit data"; break;
8512 default: gcc_unreachable ();
8514 error_at (OMP_CLAUSE_LOCATION (c
),
8515 "expected %qs %<if%> clause modifier rather than %qs",
8521 case OMP_CLAUSE_FINAL
:
8522 OMP_CLAUSE_OPERAND (c
, 0)
8523 = gimple_boolify (OMP_CLAUSE_OPERAND (c
, 0));
8526 case OMP_CLAUSE_SCHEDULE
:
8527 case OMP_CLAUSE_NUM_THREADS
:
8528 case OMP_CLAUSE_NUM_TEAMS
:
8529 case OMP_CLAUSE_THREAD_LIMIT
:
8530 case OMP_CLAUSE_DIST_SCHEDULE
:
8531 case OMP_CLAUSE_DEVICE
:
8532 case OMP_CLAUSE_PRIORITY
:
8533 case OMP_CLAUSE_GRAINSIZE
:
8534 case OMP_CLAUSE_NUM_TASKS
:
8535 case OMP_CLAUSE_HINT
:
8536 case OMP_CLAUSE_ASYNC
:
8537 case OMP_CLAUSE_WAIT
:
8538 case OMP_CLAUSE_NUM_GANGS
:
8539 case OMP_CLAUSE_NUM_WORKERS
:
8540 case OMP_CLAUSE_VECTOR_LENGTH
:
8541 case OMP_CLAUSE_WORKER
:
8542 case OMP_CLAUSE_VECTOR
:
8543 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
8544 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8548 case OMP_CLAUSE_GANG
:
8549 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
8550 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8552 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 1), pre_p
, NULL
,
8553 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8557 case OMP_CLAUSE_NOWAIT
:
8558 case OMP_CLAUSE_ORDERED
:
8559 case OMP_CLAUSE_UNTIED
:
8560 case OMP_CLAUSE_COLLAPSE
:
8561 case OMP_CLAUSE_TILE
:
8562 case OMP_CLAUSE_AUTO
:
8563 case OMP_CLAUSE_SEQ
:
8564 case OMP_CLAUSE_INDEPENDENT
:
8565 case OMP_CLAUSE_MERGEABLE
:
8566 case OMP_CLAUSE_PROC_BIND
:
8567 case OMP_CLAUSE_SAFELEN
:
8568 case OMP_CLAUSE_SIMDLEN
:
8569 case OMP_CLAUSE_NOGROUP
:
8570 case OMP_CLAUSE_THREADS
:
8571 case OMP_CLAUSE_SIMD
:
8574 case OMP_CLAUSE_DEFAULTMAP
:
8575 ctx
->target_map_scalars_firstprivate
= false;
8578 case OMP_CLAUSE_ALIGNED
:
8579 decl
= OMP_CLAUSE_DECL (c
);
8580 if (error_operand_p (decl
))
8585 if (gimplify_expr (&OMP_CLAUSE_ALIGNED_ALIGNMENT (c
), pre_p
, NULL
,
8586 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
8591 if (!is_global_var (decl
)
8592 && TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
8593 omp_add_variable (ctx
, decl
, GOVD_ALIGNED
);
8596 case OMP_CLAUSE_DEFAULT
:
8597 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
8604 if (code
== OACC_DATA
8605 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
8606 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
)
8609 *list_p
= OMP_CLAUSE_CHAIN (c
);
8611 list_p
= &OMP_CLAUSE_CHAIN (c
);
8614 gimplify_omp_ctxp
= ctx
;
8615 if (struct_map_to_clause
)
8616 delete struct_map_to_clause
;
8619 /* Return true if DECL is a candidate for shared to firstprivate
8620 optimization. We only consider non-addressable scalars, not
8621 too big, and not references. */
8624 omp_shared_to_firstprivate_optimizable_decl_p (tree decl
)
8626 if (TREE_ADDRESSABLE (decl
))
8628 tree type
= TREE_TYPE (decl
);
8629 if (!is_gimple_reg_type (type
)
8630 || TREE_CODE (type
) == REFERENCE_TYPE
8631 || TREE_ADDRESSABLE (type
))
8633 /* Don't optimize too large decls, as each thread/task will have
8635 HOST_WIDE_INT len
= int_size_in_bytes (type
);
8636 if (len
== -1 || len
> 4 * POINTER_SIZE
/ BITS_PER_UNIT
)
8638 if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
8643 /* Helper function of omp_find_stores_op and gimplify_adjust_omp_clauses*.
8644 For omp_shared_to_firstprivate_optimizable_decl_p decl mark it as
8645 GOVD_WRITTEN in outer contexts. */
8648 omp_mark_stores (struct gimplify_omp_ctx
*ctx
, tree decl
)
8650 for (; ctx
; ctx
= ctx
->outer_context
)
8652 splay_tree_node n
= splay_tree_lookup (ctx
->variables
,
8653 (splay_tree_key
) decl
);
8656 else if (n
->value
& GOVD_SHARED
)
8658 n
->value
|= GOVD_WRITTEN
;
8661 else if (n
->value
& GOVD_DATA_SHARE_CLASS
)
8666 /* Helper callback for walk_gimple_seq to discover possible stores
8667 to omp_shared_to_firstprivate_optimizable_decl_p decls and set
8668 GOVD_WRITTEN if they are GOVD_SHARED in some outer context
8672 omp_find_stores_op (tree
*tp
, int *walk_subtrees
, void *data
)
8674 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
8683 if (handled_component_p (op
))
8684 op
= TREE_OPERAND (op
, 0);
8685 else if ((TREE_CODE (op
) == MEM_REF
|| TREE_CODE (op
) == TARGET_MEM_REF
)
8686 && TREE_CODE (TREE_OPERAND (op
, 0)) == ADDR_EXPR
)
8687 op
= TREE_OPERAND (TREE_OPERAND (op
, 0), 0);
8692 if (!DECL_P (op
) || !omp_shared_to_firstprivate_optimizable_decl_p (op
))
8695 omp_mark_stores (gimplify_omp_ctxp
, op
);
8699 /* Helper callback for walk_gimple_seq to discover possible stores
8700 to omp_shared_to_firstprivate_optimizable_decl_p decls and set
8701 GOVD_WRITTEN if they are GOVD_SHARED in some outer context
8705 omp_find_stores_stmt (gimple_stmt_iterator
*gsi_p
,
8706 bool *handled_ops_p
,
8707 struct walk_stmt_info
*wi
)
8709 gimple
*stmt
= gsi_stmt (*gsi_p
);
8710 switch (gimple_code (stmt
))
8712 /* Don't recurse on OpenMP constructs for which
8713 gimplify_adjust_omp_clauses already handled the bodies,
8714 except handle gimple_omp_for_pre_body. */
8715 case GIMPLE_OMP_FOR
:
8716 *handled_ops_p
= true;
8717 if (gimple_omp_for_pre_body (stmt
))
8718 walk_gimple_seq (gimple_omp_for_pre_body (stmt
),
8719 omp_find_stores_stmt
, omp_find_stores_op
, wi
);
8721 case GIMPLE_OMP_PARALLEL
:
8722 case GIMPLE_OMP_TASK
:
8723 case GIMPLE_OMP_SECTIONS
:
8724 case GIMPLE_OMP_SINGLE
:
8725 case GIMPLE_OMP_TARGET
:
8726 case GIMPLE_OMP_TEAMS
:
8727 case GIMPLE_OMP_CRITICAL
:
8728 *handled_ops_p
= true;
8736 struct gimplify_adjust_omp_clauses_data
8742 /* For all variables that were not actually used within the context,
8743 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
8746 gimplify_adjust_omp_clauses_1 (splay_tree_node n
, void *data
)
8748 tree
*list_p
= ((struct gimplify_adjust_omp_clauses_data
*) data
)->list_p
;
8750 = ((struct gimplify_adjust_omp_clauses_data
*) data
)->pre_p
;
8751 tree decl
= (tree
) n
->key
;
8752 unsigned flags
= n
->value
;
8753 enum omp_clause_code code
;
8757 if (flags
& (GOVD_EXPLICIT
| GOVD_LOCAL
))
8759 if ((flags
& GOVD_SEEN
) == 0)
8761 if (flags
& GOVD_DEBUG_PRIVATE
)
8763 gcc_assert ((flags
& GOVD_DATA_SHARE_CLASS
) == GOVD_SHARED
);
8764 private_debug
= true;
8766 else if (flags
& GOVD_MAP
)
8767 private_debug
= false;
8770 = lang_hooks
.decls
.omp_private_debug_clause (decl
,
8771 !!(flags
& GOVD_SHARED
));
8773 code
= OMP_CLAUSE_PRIVATE
;
8774 else if (flags
& GOVD_MAP
)
8776 code
= OMP_CLAUSE_MAP
;
8777 if ((gimplify_omp_ctxp
->region_type
& ORT_ACC
) == 0
8778 && TYPE_ATOMIC (strip_array_types (TREE_TYPE (decl
))))
8780 error ("%<_Atomic%> %qD in implicit %<map%> clause", decl
);
8784 else if (flags
& GOVD_SHARED
)
8786 if (is_global_var (decl
))
8788 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
8792 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
8793 if (on
&& (on
->value
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
8794 | GOVD_PRIVATE
| GOVD_REDUCTION
8795 | GOVD_LINEAR
| GOVD_MAP
)) != 0)
8797 ctx
= ctx
->outer_context
;
8802 code
= OMP_CLAUSE_SHARED
;
8804 else if (flags
& GOVD_PRIVATE
)
8805 code
= OMP_CLAUSE_PRIVATE
;
8806 else if (flags
& GOVD_FIRSTPRIVATE
)
8808 code
= OMP_CLAUSE_FIRSTPRIVATE
;
8809 if ((gimplify_omp_ctxp
->region_type
& ORT_TARGET
)
8810 && (gimplify_omp_ctxp
->region_type
& ORT_ACC
) == 0
8811 && TYPE_ATOMIC (strip_array_types (TREE_TYPE (decl
))))
8813 error ("%<_Atomic%> %qD in implicit %<firstprivate%> clause on "
8814 "%<target%> construct", decl
);
8818 else if (flags
& GOVD_LASTPRIVATE
)
8819 code
= OMP_CLAUSE_LASTPRIVATE
;
8820 else if (flags
& GOVD_ALIGNED
)
8825 if (((flags
& GOVD_LASTPRIVATE
)
8826 || (code
== OMP_CLAUSE_SHARED
&& (flags
& GOVD_WRITTEN
)))
8827 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
8828 omp_mark_stores (gimplify_omp_ctxp
->outer_context
, decl
);
8830 tree chain
= *list_p
;
8831 clause
= build_omp_clause (input_location
, code
);
8832 OMP_CLAUSE_DECL (clause
) = decl
;
8833 OMP_CLAUSE_CHAIN (clause
) = chain
;
8835 OMP_CLAUSE_PRIVATE_DEBUG (clause
) = 1;
8836 else if (code
== OMP_CLAUSE_PRIVATE
&& (flags
& GOVD_PRIVATE_OUTER_REF
))
8837 OMP_CLAUSE_PRIVATE_OUTER_REF (clause
) = 1;
8838 else if (code
== OMP_CLAUSE_SHARED
8839 && (flags
& GOVD_WRITTEN
) == 0
8840 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
8841 OMP_CLAUSE_SHARED_READONLY (clause
) = 1;
8842 else if (code
== OMP_CLAUSE_FIRSTPRIVATE
&& (flags
& GOVD_EXPLICIT
) == 0)
8843 OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT (clause
) = 1;
8844 else if (code
== OMP_CLAUSE_MAP
&& (flags
& GOVD_MAP_0LEN_ARRAY
) != 0)
8846 tree nc
= build_omp_clause (input_location
, OMP_CLAUSE_MAP
);
8847 OMP_CLAUSE_DECL (nc
) = decl
;
8848 if (TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
8849 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == POINTER_TYPE
)
8850 OMP_CLAUSE_DECL (clause
)
8851 = build_simple_mem_ref_loc (input_location
, decl
);
8852 OMP_CLAUSE_DECL (clause
)
8853 = build2 (MEM_REF
, char_type_node
, OMP_CLAUSE_DECL (clause
),
8854 build_int_cst (build_pointer_type (char_type_node
), 0));
8855 OMP_CLAUSE_SIZE (clause
) = size_zero_node
;
8856 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
8857 OMP_CLAUSE_SET_MAP_KIND (clause
, GOMP_MAP_ALLOC
);
8858 OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (clause
) = 1;
8859 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_FIRSTPRIVATE_POINTER
);
8860 OMP_CLAUSE_CHAIN (nc
) = chain
;
8861 OMP_CLAUSE_CHAIN (clause
) = nc
;
8862 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
8863 gimplify_omp_ctxp
= ctx
->outer_context
;
8864 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (clause
), 0),
8865 pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
8866 gimplify_omp_ctxp
= ctx
;
8868 else if (code
== OMP_CLAUSE_MAP
)
8871 /* Not all combinations of these GOVD_MAP flags are actually valid. */
8872 switch (flags
& (GOVD_MAP_TO_ONLY
8874 | GOVD_MAP_FORCE_PRESENT
))
8877 kind
= GOMP_MAP_TOFROM
;
8879 case GOVD_MAP_FORCE
:
8880 kind
= GOMP_MAP_TOFROM
| GOMP_MAP_FLAG_FORCE
;
8882 case GOVD_MAP_TO_ONLY
:
8885 case GOVD_MAP_TO_ONLY
| GOVD_MAP_FORCE
:
8886 kind
= GOMP_MAP_TO
| GOMP_MAP_FLAG_FORCE
;
8888 case GOVD_MAP_FORCE_PRESENT
:
8889 kind
= GOMP_MAP_FORCE_PRESENT
;
8894 OMP_CLAUSE_SET_MAP_KIND (clause
, kind
);
8895 if (DECL_SIZE (decl
)
8896 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
8898 tree decl2
= DECL_VALUE_EXPR (decl
);
8899 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
8900 decl2
= TREE_OPERAND (decl2
, 0);
8901 gcc_assert (DECL_P (decl2
));
8902 tree mem
= build_simple_mem_ref (decl2
);
8903 OMP_CLAUSE_DECL (clause
) = mem
;
8904 OMP_CLAUSE_SIZE (clause
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
8905 if (gimplify_omp_ctxp
->outer_context
)
8907 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
8908 omp_notice_variable (ctx
, decl2
, true);
8909 omp_notice_variable (ctx
, OMP_CLAUSE_SIZE (clause
), true);
8911 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
),
8913 OMP_CLAUSE_DECL (nc
) = decl
;
8914 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
8915 if (gimplify_omp_ctxp
->target_firstprivatize_array_bases
)
8916 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_FIRSTPRIVATE_POINTER
);
8918 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_POINTER
);
8919 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (clause
);
8920 OMP_CLAUSE_CHAIN (clause
) = nc
;
8922 else if (gimplify_omp_ctxp
->target_firstprivatize_array_bases
8923 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
8925 OMP_CLAUSE_DECL (clause
) = build_simple_mem_ref (decl
);
8926 OMP_CLAUSE_SIZE (clause
)
8927 = unshare_expr (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
))));
8928 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
8929 gimplify_omp_ctxp
= ctx
->outer_context
;
8930 gimplify_expr (&OMP_CLAUSE_SIZE (clause
),
8931 pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
8932 gimplify_omp_ctxp
= ctx
;
8933 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
),
8935 OMP_CLAUSE_DECL (nc
) = decl
;
8936 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
8937 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_FIRSTPRIVATE_REFERENCE
);
8938 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (clause
);
8939 OMP_CLAUSE_CHAIN (clause
) = nc
;
8942 OMP_CLAUSE_SIZE (clause
) = DECL_SIZE_UNIT (decl
);
8944 if (code
== OMP_CLAUSE_FIRSTPRIVATE
&& (flags
& GOVD_LASTPRIVATE
) != 0)
8946 tree nc
= build_omp_clause (input_location
, OMP_CLAUSE_LASTPRIVATE
);
8947 OMP_CLAUSE_DECL (nc
) = decl
;
8948 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (nc
) = 1;
8949 OMP_CLAUSE_CHAIN (nc
) = chain
;
8950 OMP_CLAUSE_CHAIN (clause
) = nc
;
8951 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
8952 gimplify_omp_ctxp
= ctx
->outer_context
;
8953 lang_hooks
.decls
.omp_finish_clause (nc
, pre_p
);
8954 gimplify_omp_ctxp
= ctx
;
8957 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
8958 gimplify_omp_ctxp
= ctx
->outer_context
;
8959 lang_hooks
.decls
.omp_finish_clause (clause
, pre_p
);
8960 if (gimplify_omp_ctxp
)
8961 for (; clause
!= chain
; clause
= OMP_CLAUSE_CHAIN (clause
))
8962 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_MAP
8963 && DECL_P (OMP_CLAUSE_SIZE (clause
)))
8964 omp_notice_variable (gimplify_omp_ctxp
, OMP_CLAUSE_SIZE (clause
),
8966 gimplify_omp_ctxp
= ctx
;
8971 gimplify_adjust_omp_clauses (gimple_seq
*pre_p
, gimple_seq body
, tree
*list_p
,
8972 enum tree_code code
)
8974 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
8979 struct gimplify_omp_ctx
*octx
;
8980 for (octx
= ctx
; octx
; octx
= octx
->outer_context
)
8981 if ((octx
->region_type
& (ORT_PARALLEL
| ORT_TASK
| ORT_TEAMS
)) != 0)
8985 struct walk_stmt_info wi
;
8986 memset (&wi
, 0, sizeof (wi
));
8987 walk_gimple_seq (body
, omp_find_stores_stmt
,
8988 omp_find_stores_op
, &wi
);
8991 while ((c
= *list_p
) != NULL
)
8994 bool remove
= false;
8996 switch (OMP_CLAUSE_CODE (c
))
8998 case OMP_CLAUSE_FIRSTPRIVATE
:
8999 if ((ctx
->region_type
& ORT_TARGET
)
9000 && (ctx
->region_type
& ORT_ACC
) == 0
9001 && TYPE_ATOMIC (strip_array_types
9002 (TREE_TYPE (OMP_CLAUSE_DECL (c
)))))
9004 error_at (OMP_CLAUSE_LOCATION (c
),
9005 "%<_Atomic%> %qD in %<firstprivate%> clause on "
9006 "%<target%> construct", OMP_CLAUSE_DECL (c
));
9011 case OMP_CLAUSE_PRIVATE
:
9012 case OMP_CLAUSE_SHARED
:
9013 case OMP_CLAUSE_LINEAR
:
9014 decl
= OMP_CLAUSE_DECL (c
);
9015 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9016 remove
= !(n
->value
& GOVD_SEEN
);
9019 bool shared
= OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
;
9020 if ((n
->value
& GOVD_DEBUG_PRIVATE
)
9021 || lang_hooks
.decls
.omp_private_debug_clause (decl
, shared
))
9023 gcc_assert ((n
->value
& GOVD_DEBUG_PRIVATE
) == 0
9024 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
9026 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_PRIVATE
);
9027 OMP_CLAUSE_PRIVATE_DEBUG (c
) = 1;
9029 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
9030 && (n
->value
& GOVD_WRITTEN
) == 0
9032 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
9033 OMP_CLAUSE_SHARED_READONLY (c
) = 1;
9034 else if (DECL_P (decl
)
9035 && ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
9036 && (n
->value
& GOVD_WRITTEN
) != 0)
9037 || (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
9038 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)))
9039 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
9040 omp_mark_stores (gimplify_omp_ctxp
->outer_context
, decl
);
9044 case OMP_CLAUSE_LASTPRIVATE
:
9045 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
9046 accurately reflect the presence of a FIRSTPRIVATE clause. */
9047 decl
= OMP_CLAUSE_DECL (c
);
9048 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9049 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
9050 = (n
->value
& GOVD_FIRSTPRIVATE
) != 0;
9051 if (code
== OMP_DISTRIBUTE
9052 && OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
9055 error_at (OMP_CLAUSE_LOCATION (c
),
9056 "same variable used in %<firstprivate%> and "
9057 "%<lastprivate%> clauses on %<distribute%> "
9061 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
9063 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
9064 omp_mark_stores (gimplify_omp_ctxp
->outer_context
, decl
);
9067 case OMP_CLAUSE_ALIGNED
:
9068 decl
= OMP_CLAUSE_DECL (c
);
9069 if (!is_global_var (decl
))
9071 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9072 remove
= n
== NULL
|| !(n
->value
& GOVD_SEEN
);
9073 if (!remove
&& TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
9075 struct gimplify_omp_ctx
*octx
;
9077 && (n
->value
& (GOVD_DATA_SHARE_CLASS
9078 & ~GOVD_FIRSTPRIVATE
)))
9081 for (octx
= ctx
->outer_context
; octx
;
9082 octx
= octx
->outer_context
)
9084 n
= splay_tree_lookup (octx
->variables
,
9085 (splay_tree_key
) decl
);
9088 if (n
->value
& GOVD_LOCAL
)
9090 /* We have to avoid assigning a shared variable
9091 to itself when trying to add
9092 __builtin_assume_aligned. */
9093 if (n
->value
& GOVD_SHARED
)
9101 else if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
9103 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9104 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
9109 case OMP_CLAUSE_MAP
:
9110 if (code
== OMP_TARGET_EXIT_DATA
9111 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_ALWAYS_POINTER
)
9116 decl
= OMP_CLAUSE_DECL (c
);
9117 /* Data clauses associated with acc parallel reductions must be
9118 compatible with present_or_copy. Warn and adjust the clause
9119 if that is not the case. */
9120 if (ctx
->region_type
== ORT_ACC_PARALLEL
)
9122 tree t
= DECL_P (decl
) ? decl
: TREE_OPERAND (decl
, 0);
9126 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
9128 if (n
&& (n
->value
& GOVD_REDUCTION
))
9130 enum gomp_map_kind kind
= OMP_CLAUSE_MAP_KIND (c
);
9132 OMP_CLAUSE_MAP_IN_REDUCTION (c
) = 1;
9133 if ((kind
& GOMP_MAP_TOFROM
) != GOMP_MAP_TOFROM
9134 && kind
!= GOMP_MAP_FORCE_PRESENT
9135 && kind
!= GOMP_MAP_POINTER
)
9137 warning_at (OMP_CLAUSE_LOCATION (c
), 0,
9138 "incompatible data clause with reduction "
9139 "on %qE; promoting to present_or_copy",
9141 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_TOFROM
);
9147 if ((ctx
->region_type
& ORT_TARGET
) != 0
9148 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
)
9150 if (TREE_CODE (decl
) == INDIRECT_REF
9151 && TREE_CODE (TREE_OPERAND (decl
, 0)) == COMPONENT_REF
9152 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl
, 0)))
9154 decl
= TREE_OPERAND (decl
, 0);
9155 if (TREE_CODE (decl
) == COMPONENT_REF
)
9157 while (TREE_CODE (decl
) == COMPONENT_REF
)
9158 decl
= TREE_OPERAND (decl
, 0);
9161 n
= splay_tree_lookup (ctx
->variables
,
9162 (splay_tree_key
) decl
);
9163 if (!(n
->value
& GOVD_SEEN
))
9170 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9171 if ((ctx
->region_type
& ORT_TARGET
) != 0
9172 && !(n
->value
& GOVD_SEEN
)
9173 && GOMP_MAP_ALWAYS_P (OMP_CLAUSE_MAP_KIND (c
)) == 0
9174 && (!is_global_var (decl
)
9175 || !lookup_attribute ("omp declare target link",
9176 DECL_ATTRIBUTES (decl
))))
9179 /* For struct element mapping, if struct is never referenced
9180 in target block and none of the mapping has always modifier,
9181 remove all the struct element mappings, which immediately
9182 follow the GOMP_MAP_STRUCT map clause. */
9183 if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_STRUCT
)
9185 HOST_WIDE_INT cnt
= tree_to_shwi (OMP_CLAUSE_SIZE (c
));
9187 OMP_CLAUSE_CHAIN (c
)
9188 = OMP_CLAUSE_CHAIN (OMP_CLAUSE_CHAIN (c
));
9191 else if (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_STRUCT
9192 && code
== OMP_TARGET_EXIT_DATA
)
9194 else if (DECL_SIZE (decl
)
9195 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
9196 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_POINTER
9197 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_FIRSTPRIVATE_POINTER
9198 && (OMP_CLAUSE_MAP_KIND (c
)
9199 != GOMP_MAP_FIRSTPRIVATE_REFERENCE
))
9201 /* For GOMP_MAP_FORCE_DEVICEPTR, we'll never enter here, because
9202 for these, TREE_CODE (DECL_SIZE (decl)) will always be
9204 gcc_assert (OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_FORCE_DEVICEPTR
);
9206 tree decl2
= DECL_VALUE_EXPR (decl
);
9207 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
9208 decl2
= TREE_OPERAND (decl2
, 0);
9209 gcc_assert (DECL_P (decl2
));
9210 tree mem
= build_simple_mem_ref (decl2
);
9211 OMP_CLAUSE_DECL (c
) = mem
;
9212 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
9213 if (ctx
->outer_context
)
9215 omp_notice_variable (ctx
->outer_context
, decl2
, true);
9216 omp_notice_variable (ctx
->outer_context
,
9217 OMP_CLAUSE_SIZE (c
), true);
9219 if (((ctx
->region_type
& ORT_TARGET
) != 0
9220 || !ctx
->target_firstprivatize_array_bases
)
9221 && ((n
->value
& GOVD_SEEN
) == 0
9222 || (n
->value
& (GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
)) == 0))
9224 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
9226 OMP_CLAUSE_DECL (nc
) = decl
;
9227 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
9228 if (ctx
->target_firstprivatize_array_bases
)
9229 OMP_CLAUSE_SET_MAP_KIND (nc
,
9230 GOMP_MAP_FIRSTPRIVATE_POINTER
);
9232 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_POINTER
);
9233 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (c
);
9234 OMP_CLAUSE_CHAIN (c
) = nc
;
9240 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
9241 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
9242 gcc_assert ((n
->value
& GOVD_SEEN
) == 0
9243 || ((n
->value
& (GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
))
9249 case OMP_CLAUSE_FROM
:
9250 case OMP_CLAUSE__CACHE_
:
9251 decl
= OMP_CLAUSE_DECL (c
);
9254 if (DECL_SIZE (decl
)
9255 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
9257 tree decl2
= DECL_VALUE_EXPR (decl
);
9258 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
9259 decl2
= TREE_OPERAND (decl2
, 0);
9260 gcc_assert (DECL_P (decl2
));
9261 tree mem
= build_simple_mem_ref (decl2
);
9262 OMP_CLAUSE_DECL (c
) = mem
;
9263 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
9264 if (ctx
->outer_context
)
9266 omp_notice_variable (ctx
->outer_context
, decl2
, true);
9267 omp_notice_variable (ctx
->outer_context
,
9268 OMP_CLAUSE_SIZE (c
), true);
9271 else if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
9272 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
9275 case OMP_CLAUSE_REDUCTION
:
9276 decl
= OMP_CLAUSE_DECL (c
);
9277 /* OpenACC reductions need a present_or_copy data clause.
9278 Add one if necessary. Emit error when the reduction is private. */
9279 if (ctx
->region_type
== ORT_ACC_PARALLEL
)
9281 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
9282 if (n
->value
& (GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
))
9285 error_at (OMP_CLAUSE_LOCATION (c
), "invalid private "
9286 "reduction on %qE", DECL_NAME (decl
));
9288 else if ((n
->value
& GOVD_MAP
) == 0)
9290 tree next
= OMP_CLAUSE_CHAIN (c
);
9291 tree nc
= build_omp_clause (UNKNOWN_LOCATION
, OMP_CLAUSE_MAP
);
9292 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_TOFROM
);
9293 OMP_CLAUSE_DECL (nc
) = decl
;
9294 OMP_CLAUSE_CHAIN (c
) = nc
;
9295 lang_hooks
.decls
.omp_finish_clause (nc
, pre_p
);
9298 OMP_CLAUSE_MAP_IN_REDUCTION (nc
) = 1;
9299 if (OMP_CLAUSE_CHAIN (nc
) == NULL
)
9301 nc
= OMP_CLAUSE_CHAIN (nc
);
9303 OMP_CLAUSE_CHAIN (nc
) = next
;
9304 n
->value
|= GOVD_MAP
;
9308 && omp_shared_to_firstprivate_optimizable_decl_p (decl
))
9309 omp_mark_stores (gimplify_omp_ctxp
->outer_context
, decl
);
9311 case OMP_CLAUSE_COPYIN
:
9312 case OMP_CLAUSE_COPYPRIVATE
:
9314 case OMP_CLAUSE_NUM_THREADS
:
9315 case OMP_CLAUSE_NUM_TEAMS
:
9316 case OMP_CLAUSE_THREAD_LIMIT
:
9317 case OMP_CLAUSE_DIST_SCHEDULE
:
9318 case OMP_CLAUSE_DEVICE
:
9319 case OMP_CLAUSE_SCHEDULE
:
9320 case OMP_CLAUSE_NOWAIT
:
9321 case OMP_CLAUSE_ORDERED
:
9322 case OMP_CLAUSE_DEFAULT
:
9323 case OMP_CLAUSE_UNTIED
:
9324 case OMP_CLAUSE_COLLAPSE
:
9325 case OMP_CLAUSE_FINAL
:
9326 case OMP_CLAUSE_MERGEABLE
:
9327 case OMP_CLAUSE_PROC_BIND
:
9328 case OMP_CLAUSE_SAFELEN
:
9329 case OMP_CLAUSE_SIMDLEN
:
9330 case OMP_CLAUSE_DEPEND
:
9331 case OMP_CLAUSE_PRIORITY
:
9332 case OMP_CLAUSE_GRAINSIZE
:
9333 case OMP_CLAUSE_NUM_TASKS
:
9334 case OMP_CLAUSE_NOGROUP
:
9335 case OMP_CLAUSE_THREADS
:
9336 case OMP_CLAUSE_SIMD
:
9337 case OMP_CLAUSE_HINT
:
9338 case OMP_CLAUSE_DEFAULTMAP
:
9339 case OMP_CLAUSE_USE_DEVICE_PTR
:
9340 case OMP_CLAUSE_IS_DEVICE_PTR
:
9341 case OMP_CLAUSE_ASYNC
:
9342 case OMP_CLAUSE_WAIT
:
9343 case OMP_CLAUSE_INDEPENDENT
:
9344 case OMP_CLAUSE_NUM_GANGS
:
9345 case OMP_CLAUSE_NUM_WORKERS
:
9346 case OMP_CLAUSE_VECTOR_LENGTH
:
9347 case OMP_CLAUSE_GANG
:
9348 case OMP_CLAUSE_WORKER
:
9349 case OMP_CLAUSE_VECTOR
:
9350 case OMP_CLAUSE_AUTO
:
9351 case OMP_CLAUSE_SEQ
:
9352 case OMP_CLAUSE_TILE
:
9360 *list_p
= OMP_CLAUSE_CHAIN (c
);
9362 list_p
= &OMP_CLAUSE_CHAIN (c
);
9365 /* Add in any implicit data sharing. */
9366 struct gimplify_adjust_omp_clauses_data data
;
9367 data
.list_p
= list_p
;
9369 splay_tree_foreach (ctx
->variables
, gimplify_adjust_omp_clauses_1
, &data
);
9371 gimplify_omp_ctxp
= ctx
->outer_context
;
9372 delete_omp_context (ctx
);
9375 /* Gimplify OACC_CACHE. */
9378 gimplify_oacc_cache (tree
*expr_p
, gimple_seq
*pre_p
)
9380 tree expr
= *expr_p
;
9382 gimplify_scan_omp_clauses (&OACC_CACHE_CLAUSES (expr
), pre_p
, ORT_ACC
,
9384 gimplify_adjust_omp_clauses (pre_p
, NULL
, &OACC_CACHE_CLAUSES (expr
),
9387 /* TODO: Do something sensible with this information. */
9389 *expr_p
= NULL_TREE
;
9392 /* Helper function of gimplify_oacc_declare. The helper's purpose is to,
9393 if required, translate 'kind' in CLAUSE into an 'entry' kind and 'exit'
9394 kind. The entry kind will replace the one in CLAUSE, while the exit
9395 kind will be used in a new omp_clause and returned to the caller. */
9398 gimplify_oacc_declare_1 (tree clause
)
9400 HOST_WIDE_INT kind
, new_op
;
9404 kind
= OMP_CLAUSE_MAP_KIND (clause
);
9408 case GOMP_MAP_ALLOC
:
9409 case GOMP_MAP_FORCE_ALLOC
:
9410 case GOMP_MAP_FORCE_TO
:
9411 new_op
= GOMP_MAP_DELETE
;
9415 case GOMP_MAP_FORCE_FROM
:
9416 OMP_CLAUSE_SET_MAP_KIND (clause
, GOMP_MAP_FORCE_ALLOC
);
9417 new_op
= GOMP_MAP_FORCE_FROM
;
9421 case GOMP_MAP_FORCE_TOFROM
:
9422 OMP_CLAUSE_SET_MAP_KIND (clause
, GOMP_MAP_FORCE_TO
);
9423 new_op
= GOMP_MAP_FORCE_FROM
;
9428 OMP_CLAUSE_SET_MAP_KIND (clause
, GOMP_MAP_FORCE_ALLOC
);
9429 new_op
= GOMP_MAP_FROM
;
9433 case GOMP_MAP_TOFROM
:
9434 OMP_CLAUSE_SET_MAP_KIND (clause
, GOMP_MAP_TO
);
9435 new_op
= GOMP_MAP_FROM
;
9439 case GOMP_MAP_DEVICE_RESIDENT
:
9440 case GOMP_MAP_FORCE_DEVICEPTR
:
9441 case GOMP_MAP_FORCE_PRESENT
:
9443 case GOMP_MAP_POINTER
:
9454 c
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
), OMP_CLAUSE_MAP
);
9455 OMP_CLAUSE_SET_MAP_KIND (c
, new_op
);
9456 OMP_CLAUSE_DECL (c
) = OMP_CLAUSE_DECL (clause
);
9462 /* Gimplify OACC_DECLARE. */
9465 gimplify_oacc_declare (tree
*expr_p
, gimple_seq
*pre_p
)
9467 tree expr
= *expr_p
;
9469 tree clauses
, t
, decl
;
9471 clauses
= OACC_DECLARE_CLAUSES (expr
);
9473 gimplify_scan_omp_clauses (&clauses
, pre_p
, ORT_TARGET_DATA
, OACC_DECLARE
);
9474 gimplify_adjust_omp_clauses (pre_p
, NULL
, &clauses
, OACC_DECLARE
);
9476 for (t
= clauses
; t
; t
= OMP_CLAUSE_CHAIN (t
))
9478 decl
= OMP_CLAUSE_DECL (t
);
9480 if (TREE_CODE (decl
) == MEM_REF
)
9481 decl
= TREE_OPERAND (decl
, 0);
9483 if (VAR_P (decl
) && !is_oacc_declared (decl
))
9485 tree attr
= get_identifier ("oacc declare target");
9486 DECL_ATTRIBUTES (decl
) = tree_cons (attr
, NULL_TREE
,
9487 DECL_ATTRIBUTES (decl
));
9491 && !is_global_var (decl
)
9492 && DECL_CONTEXT (decl
) == current_function_decl
)
9494 tree c
= gimplify_oacc_declare_1 (t
);
9497 if (oacc_declare_returns
== NULL
)
9498 oacc_declare_returns
= new hash_map
<tree
, tree
>;
9500 oacc_declare_returns
->put (decl
, c
);
9504 if (gimplify_omp_ctxp
)
9505 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_SEEN
);
9508 stmt
= gimple_build_omp_target (NULL
, GF_OMP_TARGET_KIND_OACC_DECLARE
,
9511 gimplify_seq_add_stmt (pre_p
, stmt
);
9513 *expr_p
= NULL_TREE
;
9516 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
9517 gimplification of the body, as well as scanning the body for used
9518 variables. We need to do this scan now, because variable-sized
9519 decls will be decomposed during gimplification. */
9522 gimplify_omp_parallel (tree
*expr_p
, gimple_seq
*pre_p
)
9524 tree expr
= *expr_p
;
9526 gimple_seq body
= NULL
;
9528 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
), pre_p
,
9529 OMP_PARALLEL_COMBINED (expr
)
9530 ? ORT_COMBINED_PARALLEL
9531 : ORT_PARALLEL
, OMP_PARALLEL
);
9533 push_gimplify_context ();
9535 g
= gimplify_and_return_first (OMP_PARALLEL_BODY (expr
), &body
);
9536 if (gimple_code (g
) == GIMPLE_BIND
)
9537 pop_gimplify_context (g
);
9539 pop_gimplify_context (NULL
);
9541 gimplify_adjust_omp_clauses (pre_p
, body
, &OMP_PARALLEL_CLAUSES (expr
),
9544 g
= gimple_build_omp_parallel (body
,
9545 OMP_PARALLEL_CLAUSES (expr
),
9546 NULL_TREE
, NULL_TREE
);
9547 if (OMP_PARALLEL_COMBINED (expr
))
9548 gimple_omp_set_subcode (g
, GF_OMP_PARALLEL_COMBINED
);
9549 gimplify_seq_add_stmt (pre_p
, g
);
9550 *expr_p
= NULL_TREE
;
9553 /* Gimplify the contents of an OMP_TASK statement. This involves
9554 gimplification of the body, as well as scanning the body for used
9555 variables. We need to do this scan now, because variable-sized
9556 decls will be decomposed during gimplification. */
9559 gimplify_omp_task (tree
*expr_p
, gimple_seq
*pre_p
)
9561 tree expr
= *expr_p
;
9563 gimple_seq body
= NULL
;
9565 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr
), pre_p
,
9566 omp_find_clause (OMP_TASK_CLAUSES (expr
),
9568 ? ORT_UNTIED_TASK
: ORT_TASK
, OMP_TASK
);
9570 push_gimplify_context ();
9572 g
= gimplify_and_return_first (OMP_TASK_BODY (expr
), &body
);
9573 if (gimple_code (g
) == GIMPLE_BIND
)
9574 pop_gimplify_context (g
);
9576 pop_gimplify_context (NULL
);
9578 gimplify_adjust_omp_clauses (pre_p
, body
, &OMP_TASK_CLAUSES (expr
),
9581 g
= gimple_build_omp_task (body
,
9582 OMP_TASK_CLAUSES (expr
),
9583 NULL_TREE
, NULL_TREE
,
9584 NULL_TREE
, NULL_TREE
, NULL_TREE
);
9585 gimplify_seq_add_stmt (pre_p
, g
);
9586 *expr_p
= NULL_TREE
;
9589 /* Helper function of gimplify_omp_for, find OMP_FOR resp. OMP_SIMD
9590 with non-NULL OMP_FOR_INIT. */
9593 find_combined_omp_for (tree
*tp
, int *walk_subtrees
, void *)
9596 switch (TREE_CODE (*tp
))
9602 if (OMP_FOR_INIT (*tp
) != NULL_TREE
)
9606 case STATEMENT_LIST
:
9616 /* Gimplify the gross structure of an OMP_FOR statement. */
9618 static enum gimplify_status
9619 gimplify_omp_for (tree
*expr_p
, gimple_seq
*pre_p
)
9621 tree for_stmt
, orig_for_stmt
, inner_for_stmt
= NULL_TREE
, decl
, var
, t
;
9622 enum gimplify_status ret
= GS_ALL_DONE
;
9623 enum gimplify_status tret
;
9625 gimple_seq for_body
, for_pre_body
;
9627 bitmap has_decl_expr
= NULL
;
9628 enum omp_region_type ort
= ORT_WORKSHARE
;
9630 orig_for_stmt
= for_stmt
= *expr_p
;
9632 switch (TREE_CODE (for_stmt
))
9635 case OMP_DISTRIBUTE
:
9641 if (omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_UNTIED
))
9642 ort
= ORT_UNTIED_TASK
;
9653 /* Set OMP_CLAUSE_LINEAR_NO_COPYIN flag on explicit linear
9654 clause for the IV. */
9655 if (ort
== ORT_SIMD
&& TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
9657 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), 0);
9658 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
9659 decl
= TREE_OPERAND (t
, 0);
9660 for (tree c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
9661 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
9662 && OMP_CLAUSE_DECL (c
) == decl
)
9664 OMP_CLAUSE_LINEAR_NO_COPYIN (c
) = 1;
9669 if (OMP_FOR_INIT (for_stmt
) == NULL_TREE
)
9671 gcc_assert (TREE_CODE (for_stmt
) != OACC_LOOP
);
9672 inner_for_stmt
= walk_tree (&OMP_FOR_BODY (for_stmt
),
9673 find_combined_omp_for
, NULL
, NULL
);
9674 if (inner_for_stmt
== NULL_TREE
)
9676 gcc_assert (seen_error ());
9677 *expr_p
= NULL_TREE
;
9682 if (TREE_CODE (for_stmt
) != OMP_TASKLOOP
)
9683 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
), pre_p
, ort
,
9684 TREE_CODE (for_stmt
));
9686 if (TREE_CODE (for_stmt
) == OMP_DISTRIBUTE
)
9687 gimplify_omp_ctxp
->distribute
= true;
9689 /* Handle OMP_FOR_INIT. */
9690 for_pre_body
= NULL
;
9691 if (ort
== ORT_SIMD
&& OMP_FOR_PRE_BODY (for_stmt
))
9693 has_decl_expr
= BITMAP_ALLOC (NULL
);
9694 if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == DECL_EXPR
9695 && TREE_CODE (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt
)))
9698 t
= OMP_FOR_PRE_BODY (for_stmt
);
9699 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
9701 else if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == STATEMENT_LIST
)
9703 tree_stmt_iterator si
;
9704 for (si
= tsi_start (OMP_FOR_PRE_BODY (for_stmt
)); !tsi_end_p (si
);
9708 if (TREE_CODE (t
) == DECL_EXPR
9709 && TREE_CODE (DECL_EXPR_DECL (t
)) == VAR_DECL
)
9710 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
9714 if (OMP_FOR_PRE_BODY (for_stmt
))
9716 if (TREE_CODE (for_stmt
) != OMP_TASKLOOP
|| gimplify_omp_ctxp
)
9717 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
9720 struct gimplify_omp_ctx ctx
;
9721 memset (&ctx
, 0, sizeof (ctx
));
9722 ctx
.region_type
= ORT_NONE
;
9723 gimplify_omp_ctxp
= &ctx
;
9724 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
9725 gimplify_omp_ctxp
= NULL
;
9728 OMP_FOR_PRE_BODY (for_stmt
) = NULL_TREE
;
9730 if (OMP_FOR_INIT (for_stmt
) == NULL_TREE
)
9731 for_stmt
= inner_for_stmt
;
9733 /* For taskloop, need to gimplify the start, end and step before the
9734 taskloop, outside of the taskloop omp context. */
9735 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
9737 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
9739 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
9740 if (!is_gimple_constant (TREE_OPERAND (t
, 1)))
9743 = get_initialized_tmp_var (TREE_OPERAND (t
, 1),
9744 pre_p
, NULL
, false);
9745 tree c
= build_omp_clause (input_location
,
9746 OMP_CLAUSE_FIRSTPRIVATE
);
9747 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (t
, 1);
9748 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (orig_for_stmt
);
9749 OMP_FOR_CLAUSES (orig_for_stmt
) = c
;
9752 /* Handle OMP_FOR_COND. */
9753 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
9754 if (!is_gimple_constant (TREE_OPERAND (t
, 1)))
9757 = get_initialized_tmp_var (TREE_OPERAND (t
, 1),
9758 gimple_seq_empty_p (for_pre_body
)
9759 ? pre_p
: &for_pre_body
, NULL
,
9761 tree c
= build_omp_clause (input_location
,
9762 OMP_CLAUSE_FIRSTPRIVATE
);
9763 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (t
, 1);
9764 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (orig_for_stmt
);
9765 OMP_FOR_CLAUSES (orig_for_stmt
) = c
;
9768 /* Handle OMP_FOR_INCR. */
9769 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
9770 if (TREE_CODE (t
) == MODIFY_EXPR
)
9772 decl
= TREE_OPERAND (t
, 0);
9773 t
= TREE_OPERAND (t
, 1);
9774 tree
*tp
= &TREE_OPERAND (t
, 1);
9775 if (TREE_CODE (t
) == PLUS_EXPR
&& *tp
== decl
)
9776 tp
= &TREE_OPERAND (t
, 0);
9778 if (!is_gimple_constant (*tp
))
9780 gimple_seq
*seq
= gimple_seq_empty_p (for_pre_body
)
9781 ? pre_p
: &for_pre_body
;
9782 *tp
= get_initialized_tmp_var (*tp
, seq
, NULL
, false);
9783 tree c
= build_omp_clause (input_location
,
9784 OMP_CLAUSE_FIRSTPRIVATE
);
9785 OMP_CLAUSE_DECL (c
) = *tp
;
9786 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (orig_for_stmt
);
9787 OMP_FOR_CLAUSES (orig_for_stmt
) = c
;
9792 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (orig_for_stmt
), pre_p
, ort
,
9796 if (orig_for_stmt
!= for_stmt
)
9797 gimplify_omp_ctxp
->combined_loop
= true;
9800 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
9801 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt
)));
9802 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
9803 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt
)));
9805 tree c
= omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_ORDERED
);
9806 bool is_doacross
= false;
9807 if (c
&& OMP_CLAUSE_ORDERED_EXPR (c
))
9810 gimplify_omp_ctxp
->loop_iter_var
.create (TREE_VEC_LENGTH
9811 (OMP_FOR_INIT (for_stmt
))
9814 int collapse
= 1, tile
= 0;
9815 c
= omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_COLLAPSE
);
9817 collapse
= tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (c
));
9818 c
= omp_find_clause (OMP_FOR_CLAUSES (for_stmt
), OMP_CLAUSE_TILE
);
9820 tile
= list_length (OMP_CLAUSE_TILE_LIST (c
));
9821 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
9823 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
9824 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
9825 decl
= TREE_OPERAND (t
, 0);
9826 gcc_assert (DECL_P (decl
));
9827 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl
))
9828 || POINTER_TYPE_P (TREE_TYPE (decl
)));
9831 if (TREE_CODE (for_stmt
) == OMP_FOR
&& OMP_FOR_ORIG_DECLS (for_stmt
))
9832 gimplify_omp_ctxp
->loop_iter_var
.quick_push
9833 (TREE_VEC_ELT (OMP_FOR_ORIG_DECLS (for_stmt
), i
));
9835 gimplify_omp_ctxp
->loop_iter_var
.quick_push (decl
);
9836 gimplify_omp_ctxp
->loop_iter_var
.quick_push (decl
);
9839 /* Make sure the iteration variable is private. */
9841 tree c2
= NULL_TREE
;
9842 if (orig_for_stmt
!= for_stmt
)
9843 /* Do this only on innermost construct for combined ones. */;
9844 else if (ort
== ORT_SIMD
)
9846 splay_tree_node n
= splay_tree_lookup (gimplify_omp_ctxp
->variables
,
9847 (splay_tree_key
) decl
);
9848 omp_is_private (gimplify_omp_ctxp
, decl
,
9849 1 + (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
9851 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
9852 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
9853 else if (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
9855 c
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
9856 OMP_CLAUSE_LINEAR_NO_COPYIN (c
) = 1;
9857 unsigned int flags
= GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
;
9859 && bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)))
9861 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
9862 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
9864 struct gimplify_omp_ctx
*outer
9865 = gimplify_omp_ctxp
->outer_context
;
9866 if (outer
&& !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
9868 if (outer
->region_type
== ORT_WORKSHARE
9869 && outer
->combined_loop
)
9871 n
= splay_tree_lookup (outer
->variables
,
9872 (splay_tree_key
)decl
);
9873 if (n
!= NULL
&& (n
->value
& GOVD_LOCAL
) != 0)
9875 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
9876 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
9880 struct gimplify_omp_ctx
*octx
= outer
->outer_context
;
9882 && octx
->region_type
== ORT_COMBINED_PARALLEL
9883 && octx
->outer_context
9884 && (octx
->outer_context
->region_type
9886 && octx
->outer_context
->combined_loop
)
9888 octx
= octx
->outer_context
;
9889 n
= splay_tree_lookup (octx
->variables
,
9890 (splay_tree_key
)decl
);
9891 if (n
!= NULL
&& (n
->value
& GOVD_LOCAL
) != 0)
9893 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
9894 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
9901 OMP_CLAUSE_DECL (c
) = decl
;
9902 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
9903 OMP_FOR_CLAUSES (for_stmt
) = c
;
9904 omp_add_variable (gimplify_omp_ctxp
, decl
, flags
);
9905 if (outer
&& !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
9907 if (outer
->region_type
== ORT_WORKSHARE
9908 && outer
->combined_loop
)
9910 if (outer
->outer_context
9911 && (outer
->outer_context
->region_type
9912 == ORT_COMBINED_PARALLEL
))
9913 outer
= outer
->outer_context
;
9914 else if (omp_check_private (outer
, decl
, false))
9917 else if (((outer
->region_type
& ORT_TASK
) != 0)
9918 && outer
->combined_loop
9919 && !omp_check_private (gimplify_omp_ctxp
,
9922 else if (outer
->region_type
!= ORT_COMBINED_PARALLEL
)
9924 omp_notice_variable (outer
, decl
, true);
9929 n
= splay_tree_lookup (outer
->variables
,
9930 (splay_tree_key
)decl
);
9931 if (n
== NULL
|| (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
9933 omp_add_variable (outer
, decl
,
9934 GOVD_LASTPRIVATE
| GOVD_SEEN
);
9935 if (outer
->region_type
== ORT_COMBINED_PARALLEL
9936 && outer
->outer_context
9937 && (outer
->outer_context
->region_type
9939 && outer
->outer_context
->combined_loop
)
9941 outer
= outer
->outer_context
;
9942 n
= splay_tree_lookup (outer
->variables
,
9943 (splay_tree_key
)decl
);
9944 if (omp_check_private (outer
, decl
, false))
9947 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
9949 omp_add_variable (outer
, decl
,
9955 if (outer
&& outer
->outer_context
9956 && (outer
->outer_context
->region_type
9957 == ORT_COMBINED_TEAMS
))
9959 outer
= outer
->outer_context
;
9960 n
= splay_tree_lookup (outer
->variables
,
9961 (splay_tree_key
)decl
);
9963 || (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
9964 omp_add_variable (outer
, decl
,
9965 GOVD_SHARED
| GOVD_SEEN
);
9969 if (outer
&& outer
->outer_context
)
9970 omp_notice_variable (outer
->outer_context
, decl
,
9980 || !bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)));
9981 struct gimplify_omp_ctx
*outer
9982 = gimplify_omp_ctxp
->outer_context
;
9983 if (outer
&& lastprivate
)
9985 if (outer
->region_type
== ORT_WORKSHARE
9986 && outer
->combined_loop
)
9988 n
= splay_tree_lookup (outer
->variables
,
9989 (splay_tree_key
)decl
);
9990 if (n
!= NULL
&& (n
->value
& GOVD_LOCAL
) != 0)
9992 lastprivate
= false;
9995 else if (outer
->outer_context
9996 && (outer
->outer_context
->region_type
9997 == ORT_COMBINED_PARALLEL
))
9998 outer
= outer
->outer_context
;
9999 else if (omp_check_private (outer
, decl
, false))
10002 else if (((outer
->region_type
& ORT_TASK
) != 0)
10003 && outer
->combined_loop
10004 && !omp_check_private (gimplify_omp_ctxp
,
10007 else if (outer
->region_type
!= ORT_COMBINED_PARALLEL
)
10009 omp_notice_variable (outer
, decl
, true);
10014 n
= splay_tree_lookup (outer
->variables
,
10015 (splay_tree_key
)decl
);
10016 if (n
== NULL
|| (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
10018 omp_add_variable (outer
, decl
,
10019 GOVD_LASTPRIVATE
| GOVD_SEEN
);
10020 if (outer
->region_type
== ORT_COMBINED_PARALLEL
10021 && outer
->outer_context
10022 && (outer
->outer_context
->region_type
10024 && outer
->outer_context
->combined_loop
)
10026 outer
= outer
->outer_context
;
10027 n
= splay_tree_lookup (outer
->variables
,
10028 (splay_tree_key
)decl
);
10029 if (omp_check_private (outer
, decl
, false))
10032 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
10034 omp_add_variable (outer
, decl
,
10040 if (outer
&& outer
->outer_context
10041 && (outer
->outer_context
->region_type
10042 == ORT_COMBINED_TEAMS
))
10044 outer
= outer
->outer_context
;
10045 n
= splay_tree_lookup (outer
->variables
,
10046 (splay_tree_key
)decl
);
10048 || (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
10049 omp_add_variable (outer
, decl
,
10050 GOVD_SHARED
| GOVD_SEEN
);
10054 if (outer
&& outer
->outer_context
)
10055 omp_notice_variable (outer
->outer_context
, decl
,
10061 c
= build_omp_clause (input_location
,
10062 lastprivate
? OMP_CLAUSE_LASTPRIVATE
10063 : OMP_CLAUSE_PRIVATE
);
10064 OMP_CLAUSE_DECL (c
) = decl
;
10065 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
10066 OMP_FOR_CLAUSES (for_stmt
) = c
;
10067 omp_add_variable (gimplify_omp_ctxp
, decl
,
10068 (lastprivate
? GOVD_LASTPRIVATE
: GOVD_PRIVATE
)
10069 | GOVD_EXPLICIT
| GOVD_SEEN
);
10073 else if (omp_is_private (gimplify_omp_ctxp
, decl
, 0))
10074 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
10076 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_PRIVATE
| GOVD_SEEN
);
10078 /* If DECL is not a gimple register, create a temporary variable to act
10079 as an iteration counter. This is valid, since DECL cannot be
10080 modified in the body of the loop. Similarly for any iteration vars
10081 in simd with collapse > 1 where the iterator vars must be
10083 if (orig_for_stmt
!= for_stmt
)
10085 else if (!is_gimple_reg (decl
)
10086 || (ort
== ORT_SIMD
10087 && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1))
10089 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
10090 /* Make sure omp_add_variable is not called on it prematurely.
10091 We call it ourselves a few lines later. */
10092 gimplify_omp_ctxp
= NULL
;
10093 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
10094 gimplify_omp_ctxp
= ctx
;
10095 TREE_OPERAND (t
, 0) = var
;
10097 gimplify_seq_add_stmt (&for_body
, gimple_build_assign (decl
, var
));
10099 if (ort
== ORT_SIMD
10100 && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
10102 c2
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
10103 OMP_CLAUSE_LINEAR_NO_COPYIN (c2
) = 1;
10104 OMP_CLAUSE_LINEAR_NO_COPYOUT (c2
) = 1;
10105 OMP_CLAUSE_DECL (c2
) = var
;
10106 OMP_CLAUSE_CHAIN (c2
) = OMP_FOR_CLAUSES (for_stmt
);
10107 OMP_FOR_CLAUSES (for_stmt
) = c2
;
10108 omp_add_variable (gimplify_omp_ctxp
, var
,
10109 GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
);
10110 if (c
== NULL_TREE
)
10117 omp_add_variable (gimplify_omp_ctxp
, var
,
10118 GOVD_PRIVATE
| GOVD_SEEN
);
10123 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
10124 is_gimple_val
, fb_rvalue
, false);
10125 ret
= MIN (ret
, tret
);
10126 if (ret
== GS_ERROR
)
10129 /* Handle OMP_FOR_COND. */
10130 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
10131 gcc_assert (COMPARISON_CLASS_P (t
));
10132 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
10134 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
10135 is_gimple_val
, fb_rvalue
, false);
10136 ret
= MIN (ret
, tret
);
10138 /* Handle OMP_FOR_INCR. */
10139 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
10140 switch (TREE_CODE (t
))
10142 case PREINCREMENT_EXPR
:
10143 case POSTINCREMENT_EXPR
:
10145 tree decl
= TREE_OPERAND (t
, 0);
10146 /* c_omp_for_incr_canonicalize_ptr() should have been
10147 called to massage things appropriately. */
10148 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl
)));
10150 if (orig_for_stmt
!= for_stmt
)
10152 t
= build_int_cst (TREE_TYPE (decl
), 1);
10154 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
10155 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
10156 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
10157 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
10161 case PREDECREMENT_EXPR
:
10162 case POSTDECREMENT_EXPR
:
10163 /* c_omp_for_incr_canonicalize_ptr() should have been
10164 called to massage things appropriately. */
10165 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl
)));
10166 if (orig_for_stmt
!= for_stmt
)
10168 t
= build_int_cst (TREE_TYPE (decl
), -1);
10170 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
10171 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
10172 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
10173 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
10177 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
10178 TREE_OPERAND (t
, 0) = var
;
10180 t
= TREE_OPERAND (t
, 1);
10181 switch (TREE_CODE (t
))
10184 if (TREE_OPERAND (t
, 1) == decl
)
10186 TREE_OPERAND (t
, 1) = TREE_OPERAND (t
, 0);
10187 TREE_OPERAND (t
, 0) = var
;
10193 case POINTER_PLUS_EXPR
:
10194 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
10195 TREE_OPERAND (t
, 0) = var
;
10198 gcc_unreachable ();
10201 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
10202 is_gimple_val
, fb_rvalue
, false);
10203 ret
= MIN (ret
, tret
);
10206 tree step
= TREE_OPERAND (t
, 1);
10207 tree stept
= TREE_TYPE (decl
);
10208 if (POINTER_TYPE_P (stept
))
10210 step
= fold_convert (stept
, step
);
10211 if (TREE_CODE (t
) == MINUS_EXPR
)
10212 step
= fold_build1 (NEGATE_EXPR
, stept
, step
);
10213 OMP_CLAUSE_LINEAR_STEP (c
) = step
;
10214 if (step
!= TREE_OPERAND (t
, 1))
10216 tret
= gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
),
10217 &for_pre_body
, NULL
,
10218 is_gimple_val
, fb_rvalue
, false);
10219 ret
= MIN (ret
, tret
);
10225 gcc_unreachable ();
10231 OMP_CLAUSE_LINEAR_STEP (c2
) = OMP_CLAUSE_LINEAR_STEP (c
);
10234 if ((var
!= decl
|| collapse
> 1 || tile
) && orig_for_stmt
== for_stmt
)
10236 for (c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
10237 if (((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
10238 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) == NULL
)
10239 || (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
10240 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)
10241 && OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
) == NULL
))
10242 && OMP_CLAUSE_DECL (c
) == decl
)
10244 if (is_doacross
&& (collapse
== 1 || i
>= collapse
))
10248 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
10249 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
10250 gcc_assert (TREE_OPERAND (t
, 0) == var
);
10251 t
= TREE_OPERAND (t
, 1);
10252 gcc_assert (TREE_CODE (t
) == PLUS_EXPR
10253 || TREE_CODE (t
) == MINUS_EXPR
10254 || TREE_CODE (t
) == POINTER_PLUS_EXPR
);
10255 gcc_assert (TREE_OPERAND (t
, 0) == var
);
10256 t
= build2 (TREE_CODE (t
), TREE_TYPE (decl
),
10257 is_doacross
? var
: decl
,
10258 TREE_OPERAND (t
, 1));
10261 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
10262 seq
= &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
);
10264 seq
= &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
);
10265 gimplify_assign (decl
, t
, seq
);
10270 BITMAP_FREE (has_decl_expr
);
10272 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
10274 push_gimplify_context ();
10275 if (TREE_CODE (OMP_FOR_BODY (orig_for_stmt
)) != BIND_EXPR
)
10277 OMP_FOR_BODY (orig_for_stmt
)
10278 = build3 (BIND_EXPR
, void_type_node
, NULL
,
10279 OMP_FOR_BODY (orig_for_stmt
), NULL
);
10280 TREE_SIDE_EFFECTS (OMP_FOR_BODY (orig_for_stmt
)) = 1;
10284 gimple
*g
= gimplify_and_return_first (OMP_FOR_BODY (orig_for_stmt
),
10287 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
10289 if (gimple_code (g
) == GIMPLE_BIND
)
10290 pop_gimplify_context (g
);
10292 pop_gimplify_context (NULL
);
10295 if (orig_for_stmt
!= for_stmt
)
10296 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
10298 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
10299 decl
= TREE_OPERAND (t
, 0);
10300 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
10301 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
10302 gimplify_omp_ctxp
= ctx
->outer_context
;
10303 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
10304 gimplify_omp_ctxp
= ctx
;
10305 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
10306 TREE_OPERAND (t
, 0) = var
;
10307 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
10308 TREE_OPERAND (t
, 1) = copy_node (TREE_OPERAND (t
, 1));
10309 TREE_OPERAND (TREE_OPERAND (t
, 1), 0) = var
;
10312 gimplify_adjust_omp_clauses (pre_p
, for_body
,
10313 &OMP_FOR_CLAUSES (orig_for_stmt
),
10314 TREE_CODE (orig_for_stmt
));
10317 switch (TREE_CODE (orig_for_stmt
))
10319 case OMP_FOR
: kind
= GF_OMP_FOR_KIND_FOR
; break;
10320 case OMP_SIMD
: kind
= GF_OMP_FOR_KIND_SIMD
; break;
10321 case OMP_DISTRIBUTE
: kind
= GF_OMP_FOR_KIND_DISTRIBUTE
; break;
10322 case OMP_TASKLOOP
: kind
= GF_OMP_FOR_KIND_TASKLOOP
; break;
10323 case OACC_LOOP
: kind
= GF_OMP_FOR_KIND_OACC_LOOP
; break;
10325 gcc_unreachable ();
10327 gfor
= gimple_build_omp_for (for_body
, kind
, OMP_FOR_CLAUSES (orig_for_stmt
),
10328 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)),
10330 if (orig_for_stmt
!= for_stmt
)
10331 gimple_omp_for_set_combined_p (gfor
, true);
10332 if (gimplify_omp_ctxp
10333 && (gimplify_omp_ctxp
->combined_loop
10334 || (gimplify_omp_ctxp
->region_type
== ORT_COMBINED_PARALLEL
10335 && gimplify_omp_ctxp
->outer_context
10336 && gimplify_omp_ctxp
->outer_context
->combined_loop
)))
10338 gimple_omp_for_set_combined_into_p (gfor
, true);
10339 if (gimplify_omp_ctxp
->combined_loop
)
10340 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_SIMD
);
10342 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_FOR
);
10345 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
10347 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
10348 gimple_omp_for_set_index (gfor
, i
, TREE_OPERAND (t
, 0));
10349 gimple_omp_for_set_initial (gfor
, i
, TREE_OPERAND (t
, 1));
10350 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
10351 gimple_omp_for_set_cond (gfor
, i
, TREE_CODE (t
));
10352 gimple_omp_for_set_final (gfor
, i
, TREE_OPERAND (t
, 1));
10353 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
10354 gimple_omp_for_set_incr (gfor
, i
, TREE_OPERAND (t
, 1));
10357 /* OMP_TASKLOOP is gimplified as two GIMPLE_OMP_FOR taskloop
10358 constructs with GIMPLE_OMP_TASK sandwiched in between them.
10359 The outer taskloop stands for computing the number of iterations,
10360 counts for collapsed loops and holding taskloop specific clauses.
10361 The task construct stands for the effect of data sharing on the
10362 explicit task it creates and the inner taskloop stands for expansion
10363 of the static loop inside of the explicit task construct. */
10364 if (TREE_CODE (orig_for_stmt
) == OMP_TASKLOOP
)
10366 tree
*gfor_clauses_ptr
= gimple_omp_for_clauses_ptr (gfor
);
10367 tree task_clauses
= NULL_TREE
;
10368 tree c
= *gfor_clauses_ptr
;
10369 tree
*gtask_clauses_ptr
= &task_clauses
;
10370 tree outer_for_clauses
= NULL_TREE
;
10371 tree
*gforo_clauses_ptr
= &outer_for_clauses
;
10372 for (; c
; c
= OMP_CLAUSE_CHAIN (c
))
10373 switch (OMP_CLAUSE_CODE (c
))
10375 /* These clauses are allowed on task, move them there. */
10376 case OMP_CLAUSE_SHARED
:
10377 case OMP_CLAUSE_FIRSTPRIVATE
:
10378 case OMP_CLAUSE_DEFAULT
:
10379 case OMP_CLAUSE_IF
:
10380 case OMP_CLAUSE_UNTIED
:
10381 case OMP_CLAUSE_FINAL
:
10382 case OMP_CLAUSE_MERGEABLE
:
10383 case OMP_CLAUSE_PRIORITY
:
10384 *gtask_clauses_ptr
= c
;
10385 gtask_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
10387 case OMP_CLAUSE_PRIVATE
:
10388 if (OMP_CLAUSE_PRIVATE_TASKLOOP_IV (c
))
10390 /* We want private on outer for and firstprivate
10393 = build_omp_clause (OMP_CLAUSE_LOCATION (c
),
10394 OMP_CLAUSE_FIRSTPRIVATE
);
10395 OMP_CLAUSE_DECL (*gtask_clauses_ptr
) = OMP_CLAUSE_DECL (c
);
10396 lang_hooks
.decls
.omp_finish_clause (*gtask_clauses_ptr
, NULL
);
10397 gtask_clauses_ptr
= &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr
);
10398 *gforo_clauses_ptr
= c
;
10399 gforo_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
10403 *gtask_clauses_ptr
= c
;
10404 gtask_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
10407 /* These clauses go into outer taskloop clauses. */
10408 case OMP_CLAUSE_GRAINSIZE
:
10409 case OMP_CLAUSE_NUM_TASKS
:
10410 case OMP_CLAUSE_NOGROUP
:
10411 *gforo_clauses_ptr
= c
;
10412 gforo_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
10414 /* Taskloop clause we duplicate on both taskloops. */
10415 case OMP_CLAUSE_COLLAPSE
:
10416 *gfor_clauses_ptr
= c
;
10417 gfor_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
10418 *gforo_clauses_ptr
= copy_node (c
);
10419 gforo_clauses_ptr
= &OMP_CLAUSE_CHAIN (*gforo_clauses_ptr
);
10421 /* For lastprivate, keep the clause on inner taskloop, and add
10422 a shared clause on task. If the same decl is also firstprivate,
10423 add also firstprivate clause on the inner taskloop. */
10424 case OMP_CLAUSE_LASTPRIVATE
:
10425 if (OMP_CLAUSE_LASTPRIVATE_TASKLOOP_IV (c
))
10427 /* For taskloop C++ lastprivate IVs, we want:
10428 1) private on outer taskloop
10429 2) firstprivate and shared on task
10430 3) lastprivate on inner taskloop */
10432 = build_omp_clause (OMP_CLAUSE_LOCATION (c
),
10433 OMP_CLAUSE_FIRSTPRIVATE
);
10434 OMP_CLAUSE_DECL (*gtask_clauses_ptr
) = OMP_CLAUSE_DECL (c
);
10435 lang_hooks
.decls
.omp_finish_clause (*gtask_clauses_ptr
, NULL
);
10436 gtask_clauses_ptr
= &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr
);
10437 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
) = 1;
10438 *gforo_clauses_ptr
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
10439 OMP_CLAUSE_PRIVATE
);
10440 OMP_CLAUSE_DECL (*gforo_clauses_ptr
) = OMP_CLAUSE_DECL (c
);
10441 OMP_CLAUSE_PRIVATE_TASKLOOP_IV (*gforo_clauses_ptr
) = 1;
10442 TREE_TYPE (*gforo_clauses_ptr
) = TREE_TYPE (c
);
10443 gforo_clauses_ptr
= &OMP_CLAUSE_CHAIN (*gforo_clauses_ptr
);
10445 *gfor_clauses_ptr
= c
;
10446 gfor_clauses_ptr
= &OMP_CLAUSE_CHAIN (c
);
10448 = build_omp_clause (OMP_CLAUSE_LOCATION (c
), OMP_CLAUSE_SHARED
);
10449 OMP_CLAUSE_DECL (*gtask_clauses_ptr
) = OMP_CLAUSE_DECL (c
);
10450 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
10451 OMP_CLAUSE_SHARED_FIRSTPRIVATE (*gtask_clauses_ptr
) = 1;
10453 = &OMP_CLAUSE_CHAIN (*gtask_clauses_ptr
);
10456 gcc_unreachable ();
10458 *gfor_clauses_ptr
= NULL_TREE
;
10459 *gtask_clauses_ptr
= NULL_TREE
;
10460 *gforo_clauses_ptr
= NULL_TREE
;
10461 g
= gimple_build_bind (NULL_TREE
, gfor
, NULL_TREE
);
10462 g
= gimple_build_omp_task (g
, task_clauses
, NULL_TREE
, NULL_TREE
,
10463 NULL_TREE
, NULL_TREE
, NULL_TREE
);
10464 gimple_omp_task_set_taskloop_p (g
, true);
10465 g
= gimple_build_bind (NULL_TREE
, g
, NULL_TREE
);
10467 = gimple_build_omp_for (g
, GF_OMP_FOR_KIND_TASKLOOP
, outer_for_clauses
,
10468 gimple_omp_for_collapse (gfor
),
10469 gimple_omp_for_pre_body (gfor
));
10470 gimple_omp_for_set_pre_body (gfor
, NULL
);
10471 gimple_omp_for_set_combined_p (gforo
, true);
10472 gimple_omp_for_set_combined_into_p (gfor
, true);
10473 for (i
= 0; i
< (int) gimple_omp_for_collapse (gfor
); i
++)
10475 tree type
= TREE_TYPE (gimple_omp_for_index (gfor
, i
));
10476 tree v
= create_tmp_var (type
);
10477 gimple_omp_for_set_index (gforo
, i
, v
);
10478 t
= unshare_expr (gimple_omp_for_initial (gfor
, i
));
10479 gimple_omp_for_set_initial (gforo
, i
, t
);
10480 gimple_omp_for_set_cond (gforo
, i
,
10481 gimple_omp_for_cond (gfor
, i
));
10482 t
= unshare_expr (gimple_omp_for_final (gfor
, i
));
10483 gimple_omp_for_set_final (gforo
, i
, t
);
10484 t
= unshare_expr (gimple_omp_for_incr (gfor
, i
));
10485 gcc_assert (TREE_OPERAND (t
, 0) == gimple_omp_for_index (gfor
, i
));
10486 TREE_OPERAND (t
, 0) = v
;
10487 gimple_omp_for_set_incr (gforo
, i
, t
);
10488 t
= build_omp_clause (input_location
, OMP_CLAUSE_PRIVATE
);
10489 OMP_CLAUSE_DECL (t
) = v
;
10490 OMP_CLAUSE_CHAIN (t
) = gimple_omp_for_clauses (gforo
);
10491 gimple_omp_for_set_clauses (gforo
, t
);
10493 gimplify_seq_add_stmt (pre_p
, gforo
);
10496 gimplify_seq_add_stmt (pre_p
, gfor
);
10497 if (ret
!= GS_ALL_DONE
)
10499 *expr_p
= NULL_TREE
;
10500 return GS_ALL_DONE
;
10503 /* Helper function of optimize_target_teams, find OMP_TEAMS inside
10504 of OMP_TARGET's body. */
10507 find_omp_teams (tree
*tp
, int *walk_subtrees
, void *)
10509 *walk_subtrees
= 0;
10510 switch (TREE_CODE (*tp
))
10515 case STATEMENT_LIST
:
10516 *walk_subtrees
= 1;
10524 /* Helper function of optimize_target_teams, determine if the expression
10525 can be computed safely before the target construct on the host. */
10528 computable_teams_clause (tree
*tp
, int *walk_subtrees
, void *)
10534 *walk_subtrees
= 0;
10537 switch (TREE_CODE (*tp
))
10542 *walk_subtrees
= 0;
10543 if (error_operand_p (*tp
)
10544 || !INTEGRAL_TYPE_P (TREE_TYPE (*tp
))
10545 || DECL_HAS_VALUE_EXPR_P (*tp
)
10546 || DECL_THREAD_LOCAL_P (*tp
)
10547 || TREE_SIDE_EFFECTS (*tp
)
10548 || TREE_THIS_VOLATILE (*tp
))
10550 if (is_global_var (*tp
)
10551 && (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (*tp
))
10552 || lookup_attribute ("omp declare target link",
10553 DECL_ATTRIBUTES (*tp
))))
10556 && !DECL_SEEN_IN_BIND_EXPR_P (*tp
)
10557 && !is_global_var (*tp
)
10558 && decl_function_context (*tp
) == current_function_decl
)
10560 n
= splay_tree_lookup (gimplify_omp_ctxp
->variables
,
10561 (splay_tree_key
) *tp
);
10564 if (gimplify_omp_ctxp
->target_map_scalars_firstprivate
)
10568 else if (n
->value
& GOVD_LOCAL
)
10570 else if (n
->value
& GOVD_FIRSTPRIVATE
)
10572 else if ((n
->value
& (GOVD_MAP
| GOVD_MAP_ALWAYS_TO
))
10573 == (GOVD_MAP
| GOVD_MAP_ALWAYS_TO
))
10577 if (!INTEGRAL_TYPE_P (TREE_TYPE (*tp
)))
10581 if (TARGET_EXPR_INITIAL (*tp
)
10582 || TREE_CODE (TARGET_EXPR_SLOT (*tp
)) != VAR_DECL
)
10584 return computable_teams_clause (&TARGET_EXPR_SLOT (*tp
),
10585 walk_subtrees
, NULL
);
10586 /* Allow some reasonable subset of integral arithmetics. */
10590 case TRUNC_DIV_EXPR
:
10591 case CEIL_DIV_EXPR
:
10592 case FLOOR_DIV_EXPR
:
10593 case ROUND_DIV_EXPR
:
10594 case TRUNC_MOD_EXPR
:
10595 case CEIL_MOD_EXPR
:
10596 case FLOOR_MOD_EXPR
:
10597 case ROUND_MOD_EXPR
:
10599 case EXACT_DIV_EXPR
:
10610 case NON_LVALUE_EXPR
:
10612 if (!INTEGRAL_TYPE_P (TREE_TYPE (*tp
)))
10615 /* And disallow anything else, except for comparisons. */
10617 if (COMPARISON_CLASS_P (*tp
))
10623 /* Try to determine if the num_teams and/or thread_limit expressions
10624 can have their values determined already before entering the
10626 INTEGER_CSTs trivially are,
10627 integral decls that are firstprivate (explicitly or implicitly)
10628 or explicitly map(always, to:) or map(always, tofrom:) on the target
10629 region too, and expressions involving simple arithmetics on those
10630 too, function calls are not ok, dereferencing something neither etc.
10631 Add NUM_TEAMS and THREAD_LIMIT clauses to the OMP_CLAUSES of
10632 EXPR based on what we find:
10633 0 stands for clause not specified at all, use implementation default
10634 -1 stands for value that can't be determined easily before entering
10635 the target construct.
10636 If teams construct is not present at all, use 1 for num_teams
10637 and 0 for thread_limit (only one team is involved, and the thread
10638 limit is implementation defined. */
10641 optimize_target_teams (tree target
, gimple_seq
*pre_p
)
10643 tree body
= OMP_BODY (target
);
10644 tree teams
= walk_tree (&body
, find_omp_teams
, NULL
, NULL
);
10645 tree num_teams
= integer_zero_node
;
10646 tree thread_limit
= integer_zero_node
;
10647 location_t num_teams_loc
= EXPR_LOCATION (target
);
10648 location_t thread_limit_loc
= EXPR_LOCATION (target
);
10650 struct gimplify_omp_ctx
*target_ctx
= gimplify_omp_ctxp
;
10652 if (teams
== NULL_TREE
)
10653 num_teams
= integer_one_node
;
10655 for (c
= OMP_TEAMS_CLAUSES (teams
); c
; c
= OMP_CLAUSE_CHAIN (c
))
10657 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_NUM_TEAMS
)
10660 num_teams_loc
= OMP_CLAUSE_LOCATION (c
);
10662 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_THREAD_LIMIT
)
10665 thread_limit_loc
= OMP_CLAUSE_LOCATION (c
);
10669 expr
= OMP_CLAUSE_OPERAND (c
, 0);
10670 if (TREE_CODE (expr
) == INTEGER_CST
)
10675 if (walk_tree (&expr
, computable_teams_clause
, NULL
, NULL
))
10677 *p
= integer_minus_one_node
;
10681 gimplify_omp_ctxp
= gimplify_omp_ctxp
->outer_context
;
10682 if (gimplify_expr (p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
, false)
10685 gimplify_omp_ctxp
= target_ctx
;
10686 *p
= integer_minus_one_node
;
10689 gimplify_omp_ctxp
= target_ctx
;
10690 if (!DECL_P (expr
) && TREE_CODE (expr
) != TARGET_EXPR
)
10691 OMP_CLAUSE_OPERAND (c
, 0) = *p
;
10693 c
= build_omp_clause (thread_limit_loc
, OMP_CLAUSE_THREAD_LIMIT
);
10694 OMP_CLAUSE_THREAD_LIMIT_EXPR (c
) = thread_limit
;
10695 OMP_CLAUSE_CHAIN (c
) = OMP_TARGET_CLAUSES (target
);
10696 OMP_TARGET_CLAUSES (target
) = c
;
10697 c
= build_omp_clause (num_teams_loc
, OMP_CLAUSE_NUM_TEAMS
);
10698 OMP_CLAUSE_NUM_TEAMS_EXPR (c
) = num_teams
;
10699 OMP_CLAUSE_CHAIN (c
) = OMP_TARGET_CLAUSES (target
);
10700 OMP_TARGET_CLAUSES (target
) = c
;
10703 /* Gimplify the gross structure of several OMP constructs. */
10706 gimplify_omp_workshare (tree
*expr_p
, gimple_seq
*pre_p
)
10708 tree expr
= *expr_p
;
10710 gimple_seq body
= NULL
;
10711 enum omp_region_type ort
;
10713 switch (TREE_CODE (expr
))
10717 ort
= ORT_WORKSHARE
;
10720 ort
= OMP_TARGET_COMBINED (expr
) ? ORT_COMBINED_TARGET
: ORT_TARGET
;
10723 ort
= ORT_ACC_KERNELS
;
10725 case OACC_PARALLEL
:
10726 ort
= ORT_ACC_PARALLEL
;
10729 ort
= ORT_ACC_DATA
;
10731 case OMP_TARGET_DATA
:
10732 ort
= ORT_TARGET_DATA
;
10735 ort
= OMP_TEAMS_COMBINED (expr
) ? ORT_COMBINED_TEAMS
: ORT_TEAMS
;
10737 case OACC_HOST_DATA
:
10738 ort
= ORT_ACC_HOST_DATA
;
10741 gcc_unreachable ();
10743 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr
), pre_p
, ort
,
10745 if (TREE_CODE (expr
) == OMP_TARGET
)
10746 optimize_target_teams (expr
, pre_p
);
10747 if ((ort
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0)
10749 push_gimplify_context ();
10750 gimple
*g
= gimplify_and_return_first (OMP_BODY (expr
), &body
);
10751 if (gimple_code (g
) == GIMPLE_BIND
)
10752 pop_gimplify_context (g
);
10754 pop_gimplify_context (NULL
);
10755 if ((ort
& ORT_TARGET_DATA
) != 0)
10757 enum built_in_function end_ix
;
10758 switch (TREE_CODE (expr
))
10761 case OACC_HOST_DATA
:
10762 end_ix
= BUILT_IN_GOACC_DATA_END
;
10764 case OMP_TARGET_DATA
:
10765 end_ix
= BUILT_IN_GOMP_TARGET_END_DATA
;
10768 gcc_unreachable ();
10770 tree fn
= builtin_decl_explicit (end_ix
);
10771 g
= gimple_build_call (fn
, 0);
10772 gimple_seq cleanup
= NULL
;
10773 gimple_seq_add_stmt (&cleanup
, g
);
10774 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
10776 gimple_seq_add_stmt (&body
, g
);
10780 gimplify_and_add (OMP_BODY (expr
), &body
);
10781 gimplify_adjust_omp_clauses (pre_p
, body
, &OMP_CLAUSES (expr
),
10784 switch (TREE_CODE (expr
))
10787 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_DATA
,
10788 OMP_CLAUSES (expr
));
10791 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_KERNELS
,
10792 OMP_CLAUSES (expr
));
10794 case OACC_HOST_DATA
:
10795 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_HOST_DATA
,
10796 OMP_CLAUSES (expr
));
10798 case OACC_PARALLEL
:
10799 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_PARALLEL
,
10800 OMP_CLAUSES (expr
));
10803 stmt
= gimple_build_omp_sections (body
, OMP_CLAUSES (expr
));
10806 stmt
= gimple_build_omp_single (body
, OMP_CLAUSES (expr
));
10809 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_REGION
,
10810 OMP_CLAUSES (expr
));
10812 case OMP_TARGET_DATA
:
10813 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_DATA
,
10814 OMP_CLAUSES (expr
));
10817 stmt
= gimple_build_omp_teams (body
, OMP_CLAUSES (expr
));
10820 gcc_unreachable ();
10823 gimplify_seq_add_stmt (pre_p
, stmt
);
10824 *expr_p
= NULL_TREE
;
10827 /* Gimplify the gross structure of OpenACC enter/exit data, update, and OpenMP
10828 target update constructs. */
10831 gimplify_omp_target_update (tree
*expr_p
, gimple_seq
*pre_p
)
10833 tree expr
= *expr_p
;
10836 enum omp_region_type ort
= ORT_WORKSHARE
;
10838 switch (TREE_CODE (expr
))
10840 case OACC_ENTER_DATA
:
10841 case OACC_EXIT_DATA
:
10842 kind
= GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
;
10846 kind
= GF_OMP_TARGET_KIND_OACC_UPDATE
;
10849 case OMP_TARGET_UPDATE
:
10850 kind
= GF_OMP_TARGET_KIND_UPDATE
;
10852 case OMP_TARGET_ENTER_DATA
:
10853 kind
= GF_OMP_TARGET_KIND_ENTER_DATA
;
10855 case OMP_TARGET_EXIT_DATA
:
10856 kind
= GF_OMP_TARGET_KIND_EXIT_DATA
;
10859 gcc_unreachable ();
10861 gimplify_scan_omp_clauses (&OMP_STANDALONE_CLAUSES (expr
), pre_p
,
10862 ort
, TREE_CODE (expr
));
10863 gimplify_adjust_omp_clauses (pre_p
, NULL
, &OMP_STANDALONE_CLAUSES (expr
),
10865 stmt
= gimple_build_omp_target (NULL
, kind
, OMP_STANDALONE_CLAUSES (expr
));
10867 gimplify_seq_add_stmt (pre_p
, stmt
);
10868 *expr_p
= NULL_TREE
;
10871 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
10872 stabilized the lhs of the atomic operation as *ADDR. Return true if
10873 EXPR is this stabilized form. */
10876 goa_lhs_expr_p (tree expr
, tree addr
)
10878 /* Also include casts to other type variants. The C front end is fond
10879 of adding these for e.g. volatile variables. This is like
10880 STRIP_TYPE_NOPS but includes the main variant lookup. */
10881 STRIP_USELESS_TYPE_CONVERSION (expr
);
10883 if (TREE_CODE (expr
) == INDIRECT_REF
)
10885 expr
= TREE_OPERAND (expr
, 0);
10886 while (expr
!= addr
10887 && (CONVERT_EXPR_P (expr
)
10888 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
10889 && TREE_CODE (expr
) == TREE_CODE (addr
)
10890 && types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (addr
)))
10892 expr
= TREE_OPERAND (expr
, 0);
10893 addr
= TREE_OPERAND (addr
, 0);
10897 return (TREE_CODE (addr
) == ADDR_EXPR
10898 && TREE_CODE (expr
) == ADDR_EXPR
10899 && TREE_OPERAND (addr
, 0) == TREE_OPERAND (expr
, 0));
10901 if (TREE_CODE (addr
) == ADDR_EXPR
&& expr
== TREE_OPERAND (addr
, 0))
10906 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
10907 expression does not involve the lhs, evaluate it into a temporary.
10908 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
10909 or -1 if an error was encountered. */
10912 goa_stabilize_expr (tree
*expr_p
, gimple_seq
*pre_p
, tree lhs_addr
,
10915 tree expr
= *expr_p
;
10918 if (goa_lhs_expr_p (expr
, lhs_addr
))
10923 if (is_gimple_val (expr
))
10927 switch (TREE_CODE_CLASS (TREE_CODE (expr
)))
10930 case tcc_comparison
:
10931 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
, lhs_addr
,
10935 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
, lhs_addr
,
10938 case tcc_expression
:
10939 switch (TREE_CODE (expr
))
10941 case TRUTH_ANDIF_EXPR
:
10942 case TRUTH_ORIF_EXPR
:
10943 case TRUTH_AND_EXPR
:
10944 case TRUTH_OR_EXPR
:
10945 case TRUTH_XOR_EXPR
:
10946 case BIT_INSERT_EXPR
:
10947 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
,
10948 lhs_addr
, lhs_var
);
10950 case TRUTH_NOT_EXPR
:
10951 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
10952 lhs_addr
, lhs_var
);
10954 case COMPOUND_EXPR
:
10955 /* Break out any preevaluations from cp_build_modify_expr. */
10956 for (; TREE_CODE (expr
) == COMPOUND_EXPR
;
10957 expr
= TREE_OPERAND (expr
, 1))
10958 gimplify_stmt (&TREE_OPERAND (expr
, 0), pre_p
);
10960 return goa_stabilize_expr (expr_p
, pre_p
, lhs_addr
, lhs_var
);
10965 case tcc_reference
:
10966 if (TREE_CODE (expr
) == BIT_FIELD_REF
)
10967 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
10968 lhs_addr
, lhs_var
);
10976 enum gimplify_status gs
;
10977 gs
= gimplify_expr (expr_p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
10978 if (gs
!= GS_ALL_DONE
)
10985 /* Gimplify an OMP_ATOMIC statement. */
10987 static enum gimplify_status
10988 gimplify_omp_atomic (tree
*expr_p
, gimple_seq
*pre_p
)
10990 tree addr
= TREE_OPERAND (*expr_p
, 0);
10991 tree rhs
= TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
10992 ? NULL
: TREE_OPERAND (*expr_p
, 1);
10993 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
10995 gomp_atomic_load
*loadstmt
;
10996 gomp_atomic_store
*storestmt
;
10998 tmp_load
= create_tmp_reg (type
);
10999 if (rhs
&& goa_stabilize_expr (&rhs
, pre_p
, addr
, tmp_load
) < 0)
11002 if (gimplify_expr (&addr
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
11006 loadstmt
= gimple_build_omp_atomic_load (tmp_load
, addr
);
11007 gimplify_seq_add_stmt (pre_p
, loadstmt
);
11008 if (rhs
&& gimplify_expr (&rhs
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
11012 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
)
11014 storestmt
= gimple_build_omp_atomic_store (rhs
);
11015 gimplify_seq_add_stmt (pre_p
, storestmt
);
11016 if (OMP_ATOMIC_SEQ_CST (*expr_p
))
11018 gimple_omp_atomic_set_seq_cst (loadstmt
);
11019 gimple_omp_atomic_set_seq_cst (storestmt
);
11021 switch (TREE_CODE (*expr_p
))
11023 case OMP_ATOMIC_READ
:
11024 case OMP_ATOMIC_CAPTURE_OLD
:
11025 *expr_p
= tmp_load
;
11026 gimple_omp_atomic_set_need_value (loadstmt
);
11028 case OMP_ATOMIC_CAPTURE_NEW
:
11030 gimple_omp_atomic_set_need_value (storestmt
);
11037 return GS_ALL_DONE
;
11040 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
11041 body, and adding some EH bits. */
11043 static enum gimplify_status
11044 gimplify_transaction (tree
*expr_p
, gimple_seq
*pre_p
)
11046 tree expr
= *expr_p
, temp
, tbody
= TRANSACTION_EXPR_BODY (expr
);
11048 gtransaction
*trans_stmt
;
11049 gimple_seq body
= NULL
;
11052 /* Wrap the transaction body in a BIND_EXPR so we have a context
11053 where to put decls for OMP. */
11054 if (TREE_CODE (tbody
) != BIND_EXPR
)
11056 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, tbody
, NULL
);
11057 TREE_SIDE_EFFECTS (bind
) = 1;
11058 SET_EXPR_LOCATION (bind
, EXPR_LOCATION (tbody
));
11059 TRANSACTION_EXPR_BODY (expr
) = bind
;
11062 push_gimplify_context ();
11063 temp
= voidify_wrapper_expr (*expr_p
, NULL
);
11065 body_stmt
= gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr
), &body
);
11066 pop_gimplify_context (body_stmt
);
11068 trans_stmt
= gimple_build_transaction (body
);
11069 if (TRANSACTION_EXPR_OUTER (expr
))
11070 subcode
= GTMA_IS_OUTER
;
11071 else if (TRANSACTION_EXPR_RELAXED (expr
))
11072 subcode
= GTMA_IS_RELAXED
;
11073 gimple_transaction_set_subcode (trans_stmt
, subcode
);
11075 gimplify_seq_add_stmt (pre_p
, trans_stmt
);
11083 *expr_p
= NULL_TREE
;
11084 return GS_ALL_DONE
;
11087 /* Gimplify an OMP_ORDERED construct. EXPR is the tree version. BODY
11088 is the OMP_BODY of the original EXPR (which has already been
11089 gimplified so it's not present in the EXPR).
11091 Return the gimplified GIMPLE_OMP_ORDERED tuple. */
11094 gimplify_omp_ordered (tree expr
, gimple_seq body
)
11099 tree source_c
= NULL_TREE
;
11100 tree sink_c
= NULL_TREE
;
11102 if (gimplify_omp_ctxp
)
11104 for (c
= OMP_ORDERED_CLAUSES (expr
); c
; c
= OMP_CLAUSE_CHAIN (c
))
11105 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
11106 && gimplify_omp_ctxp
->loop_iter_var
.is_empty ()
11107 && (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
11108 || OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SOURCE
))
11110 error_at (OMP_CLAUSE_LOCATION (c
),
11111 "%<ordered%> construct with %<depend%> clause must be "
11112 "closely nested inside a loop with %<ordered%> clause "
11113 "with a parameter");
11116 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
11117 && OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
)
11120 for (decls
= OMP_CLAUSE_DECL (c
), i
= 0;
11121 decls
&& TREE_CODE (decls
) == TREE_LIST
;
11122 decls
= TREE_CHAIN (decls
), ++i
)
11123 if (i
>= gimplify_omp_ctxp
->loop_iter_var
.length () / 2)
11125 else if (TREE_VALUE (decls
)
11126 != gimplify_omp_ctxp
->loop_iter_var
[2 * i
])
11128 error_at (OMP_CLAUSE_LOCATION (c
),
11129 "variable %qE is not an iteration "
11130 "of outermost loop %d, expected %qE",
11131 TREE_VALUE (decls
), i
+ 1,
11132 gimplify_omp_ctxp
->loop_iter_var
[2 * i
]);
11138 = gimplify_omp_ctxp
->loop_iter_var
[2 * i
+ 1];
11139 if (!fail
&& i
!= gimplify_omp_ctxp
->loop_iter_var
.length () / 2)
11141 error_at (OMP_CLAUSE_LOCATION (c
),
11142 "number of variables in %<depend(sink)%> "
11143 "clause does not match number of "
11144 "iteration variables");
11149 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
11150 && OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SOURCE
)
11154 error_at (OMP_CLAUSE_LOCATION (c
),
11155 "more than one %<depend(source)%> clause on an "
11156 "%<ordered%> construct");
11163 if (source_c
&& sink_c
)
11165 error_at (OMP_CLAUSE_LOCATION (source_c
),
11166 "%<depend(source)%> clause specified together with "
11167 "%<depend(sink:)%> clauses on the same construct");
11172 return gimple_build_nop ();
11173 return gimple_build_omp_ordered (body
, OMP_ORDERED_CLAUSES (expr
));
11176 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
11177 expression produces a value to be used as an operand inside a GIMPLE
11178 statement, the value will be stored back in *EXPR_P. This value will
11179 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
11180 an SSA_NAME. The corresponding sequence of GIMPLE statements is
11181 emitted in PRE_P and POST_P.
11183 Additionally, this process may overwrite parts of the input
11184 expression during gimplification. Ideally, it should be
11185 possible to do non-destructive gimplification.
11187 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
11188 the expression needs to evaluate to a value to be used as
11189 an operand in a GIMPLE statement, this value will be stored in
11190 *EXPR_P on exit. This happens when the caller specifies one
11191 of fb_lvalue or fb_rvalue fallback flags.
11193 PRE_P will contain the sequence of GIMPLE statements corresponding
11194 to the evaluation of EXPR and all the side-effects that must
11195 be executed before the main expression. On exit, the last
11196 statement of PRE_P is the core statement being gimplified. For
11197 instance, when gimplifying 'if (++a)' the last statement in
11198 PRE_P will be 'if (t.1)' where t.1 is the result of
11199 pre-incrementing 'a'.
11201 POST_P will contain the sequence of GIMPLE statements corresponding
11202 to the evaluation of all the side-effects that must be executed
11203 after the main expression. If this is NULL, the post
11204 side-effects are stored at the end of PRE_P.
11206 The reason why the output is split in two is to handle post
11207 side-effects explicitly. In some cases, an expression may have
11208 inner and outer post side-effects which need to be emitted in
11209 an order different from the one given by the recursive
11210 traversal. For instance, for the expression (*p--)++ the post
11211 side-effects of '--' must actually occur *after* the post
11212 side-effects of '++'. However, gimplification will first visit
11213 the inner expression, so if a separate POST sequence was not
11214 used, the resulting sequence would be:
11221 However, the post-decrement operation in line #2 must not be
11222 evaluated until after the store to *p at line #4, so the
11223 correct sequence should be:
11230 So, by specifying a separate post queue, it is possible
11231 to emit the post side-effects in the correct order.
11232 If POST_P is NULL, an internal queue will be used. Before
11233 returning to the caller, the sequence POST_P is appended to
11234 the main output sequence PRE_P.
11236 GIMPLE_TEST_F points to a function that takes a tree T and
11237 returns nonzero if T is in the GIMPLE form requested by the
11238 caller. The GIMPLE predicates are in gimple.c.
11240 FALLBACK tells the function what sort of a temporary we want if
11241 gimplification cannot produce an expression that complies with
11244 fb_none means that no temporary should be generated
11245 fb_rvalue means that an rvalue is OK to generate
11246 fb_lvalue means that an lvalue is OK to generate
11247 fb_either means that either is OK, but an lvalue is preferable.
11248 fb_mayfail means that gimplification may fail (in which case
11249 GS_ERROR will be returned)
11251 The return value is either GS_ERROR or GS_ALL_DONE, since this
11252 function iterates until EXPR is completely gimplified or an error
11255 enum gimplify_status
11256 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
11257 bool (*gimple_test_f
) (tree
), fallback_t fallback
)
11260 gimple_seq internal_pre
= NULL
;
11261 gimple_seq internal_post
= NULL
;
11264 location_t saved_location
;
11265 enum gimplify_status ret
;
11266 gimple_stmt_iterator pre_last_gsi
, post_last_gsi
;
11269 save_expr
= *expr_p
;
11270 if (save_expr
== NULL_TREE
)
11271 return GS_ALL_DONE
;
11273 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
11274 is_statement
= gimple_test_f
== is_gimple_stmt
;
11276 gcc_assert (pre_p
);
11278 /* Consistency checks. */
11279 if (gimple_test_f
== is_gimple_reg
)
11280 gcc_assert (fallback
& (fb_rvalue
| fb_lvalue
));
11281 else if (gimple_test_f
== is_gimple_val
11282 || gimple_test_f
== is_gimple_call_addr
11283 || gimple_test_f
== is_gimple_condexpr
11284 || gimple_test_f
== is_gimple_mem_rhs
11285 || gimple_test_f
== is_gimple_mem_rhs_or_call
11286 || gimple_test_f
== is_gimple_reg_rhs
11287 || gimple_test_f
== is_gimple_reg_rhs_or_call
11288 || gimple_test_f
== is_gimple_asm_val
11289 || gimple_test_f
== is_gimple_mem_ref_addr
)
11290 gcc_assert (fallback
& fb_rvalue
);
11291 else if (gimple_test_f
== is_gimple_min_lval
11292 || gimple_test_f
== is_gimple_lvalue
)
11293 gcc_assert (fallback
& fb_lvalue
);
11294 else if (gimple_test_f
== is_gimple_addressable
)
11295 gcc_assert (fallback
& fb_either
);
11296 else if (gimple_test_f
== is_gimple_stmt
)
11297 gcc_assert (fallback
== fb_none
);
11300 /* We should have recognized the GIMPLE_TEST_F predicate to
11301 know what kind of fallback to use in case a temporary is
11302 needed to hold the value or address of *EXPR_P. */
11303 gcc_unreachable ();
11306 /* We used to check the predicate here and return immediately if it
11307 succeeds. This is wrong; the design is for gimplification to be
11308 idempotent, and for the predicates to only test for valid forms, not
11309 whether they are fully simplified. */
11311 pre_p
= &internal_pre
;
11313 if (post_p
== NULL
)
11314 post_p
= &internal_post
;
11316 /* Remember the last statements added to PRE_P and POST_P. Every
11317 new statement added by the gimplification helpers needs to be
11318 annotated with location information. To centralize the
11319 responsibility, we remember the last statement that had been
11320 added to both queues before gimplifying *EXPR_P. If
11321 gimplification produces new statements in PRE_P and POST_P, those
11322 statements will be annotated with the same location information
11324 pre_last_gsi
= gsi_last (*pre_p
);
11325 post_last_gsi
= gsi_last (*post_p
);
11327 saved_location
= input_location
;
11328 if (save_expr
!= error_mark_node
11329 && EXPR_HAS_LOCATION (*expr_p
))
11330 input_location
= EXPR_LOCATION (*expr_p
);
11332 /* Loop over the specific gimplifiers until the toplevel node
11333 remains the same. */
11336 /* Strip away as many useless type conversions as possible
11337 at the toplevel. */
11338 STRIP_USELESS_TYPE_CONVERSION (*expr_p
);
11340 /* Remember the expr. */
11341 save_expr
= *expr_p
;
11343 /* Die, die, die, my darling. */
11344 if (error_operand_p (save_expr
))
11350 /* Do any language-specific gimplification. */
11351 ret
= ((enum gimplify_status
)
11352 lang_hooks
.gimplify_expr (expr_p
, pre_p
, post_p
));
11355 if (*expr_p
== NULL_TREE
)
11357 if (*expr_p
!= save_expr
)
11360 else if (ret
!= GS_UNHANDLED
)
11363 /* Make sure that all the cases set 'ret' appropriately. */
11364 ret
= GS_UNHANDLED
;
11365 switch (TREE_CODE (*expr_p
))
11367 /* First deal with the special cases. */
11369 case POSTINCREMENT_EXPR
:
11370 case POSTDECREMENT_EXPR
:
11371 case PREINCREMENT_EXPR
:
11372 case PREDECREMENT_EXPR
:
11373 ret
= gimplify_self_mod_expr (expr_p
, pre_p
, post_p
,
11374 fallback
!= fb_none
,
11375 TREE_TYPE (*expr_p
));
11378 case VIEW_CONVERT_EXPR
:
11379 if (is_gimple_reg_type (TREE_TYPE (*expr_p
))
11380 && is_gimple_reg_type (TREE_TYPE (TREE_OPERAND (*expr_p
, 0))))
11382 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
11383 post_p
, is_gimple_val
, fb_rvalue
);
11384 recalculate_side_effects (*expr_p
);
11390 case ARRAY_RANGE_REF
:
11391 case REALPART_EXPR
:
11392 case IMAGPART_EXPR
:
11393 case COMPONENT_REF
:
11394 ret
= gimplify_compound_lval (expr_p
, pre_p
, post_p
,
11395 fallback
? fallback
: fb_rvalue
);
11399 ret
= gimplify_cond_expr (expr_p
, pre_p
, fallback
);
11401 /* C99 code may assign to an array in a structure value of a
11402 conditional expression, and this has undefined behavior
11403 only on execution, so create a temporary if an lvalue is
11405 if (fallback
== fb_lvalue
)
11407 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
, false);
11408 mark_addressable (*expr_p
);
11414 ret
= gimplify_call_expr (expr_p
, pre_p
, fallback
!= fb_none
);
11416 /* C99 code may assign to an array in a structure returned
11417 from a function, and this has undefined behavior only on
11418 execution, so create a temporary if an lvalue is
11420 if (fallback
== fb_lvalue
)
11422 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
, false);
11423 mark_addressable (*expr_p
);
11429 gcc_unreachable ();
11431 case COMPOUND_EXPR
:
11432 ret
= gimplify_compound_expr (expr_p
, pre_p
, fallback
!= fb_none
);
11435 case COMPOUND_LITERAL_EXPR
:
11436 ret
= gimplify_compound_literal_expr (expr_p
, pre_p
,
11437 gimple_test_f
, fallback
);
11442 ret
= gimplify_modify_expr (expr_p
, pre_p
, post_p
,
11443 fallback
!= fb_none
);
11446 case TRUTH_ANDIF_EXPR
:
11447 case TRUTH_ORIF_EXPR
:
11449 /* Preserve the original type of the expression and the
11450 source location of the outer expression. */
11451 tree org_type
= TREE_TYPE (*expr_p
);
11452 *expr_p
= gimple_boolify (*expr_p
);
11453 *expr_p
= build3_loc (input_location
, COND_EXPR
,
11457 org_type
, boolean_true_node
),
11460 org_type
, boolean_false_node
));
11465 case TRUTH_NOT_EXPR
:
11467 tree type
= TREE_TYPE (*expr_p
);
11468 /* The parsers are careful to generate TRUTH_NOT_EXPR
11469 only with operands that are always zero or one.
11470 We do not fold here but handle the only interesting case
11471 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
11472 *expr_p
= gimple_boolify (*expr_p
);
11473 if (TYPE_PRECISION (TREE_TYPE (*expr_p
)) == 1)
11474 *expr_p
= build1_loc (input_location
, BIT_NOT_EXPR
,
11475 TREE_TYPE (*expr_p
),
11476 TREE_OPERAND (*expr_p
, 0));
11478 *expr_p
= build2_loc (input_location
, BIT_XOR_EXPR
,
11479 TREE_TYPE (*expr_p
),
11480 TREE_OPERAND (*expr_p
, 0),
11481 build_int_cst (TREE_TYPE (*expr_p
), 1));
11482 if (!useless_type_conversion_p (type
, TREE_TYPE (*expr_p
)))
11483 *expr_p
= fold_convert_loc (input_location
, type
, *expr_p
);
11489 ret
= gimplify_addr_expr (expr_p
, pre_p
, post_p
);
11492 case ANNOTATE_EXPR
:
11494 tree cond
= TREE_OPERAND (*expr_p
, 0);
11495 tree kind
= TREE_OPERAND (*expr_p
, 1);
11496 tree data
= TREE_OPERAND (*expr_p
, 2);
11497 tree type
= TREE_TYPE (cond
);
11498 if (!INTEGRAL_TYPE_P (type
))
11504 tree tmp
= create_tmp_var (type
);
11505 gimplify_arg (&cond
, pre_p
, EXPR_LOCATION (*expr_p
));
11507 = gimple_build_call_internal (IFN_ANNOTATE
, 3, cond
, kind
, data
);
11508 gimple_call_set_lhs (call
, tmp
);
11509 gimplify_seq_add_stmt (pre_p
, call
);
11516 ret
= gimplify_va_arg_expr (expr_p
, pre_p
, post_p
);
11520 if (IS_EMPTY_STMT (*expr_p
))
11526 if (VOID_TYPE_P (TREE_TYPE (*expr_p
))
11527 || fallback
== fb_none
)
11529 /* Just strip a conversion to void (or in void context) and
11531 *expr_p
= TREE_OPERAND (*expr_p
, 0);
11536 ret
= gimplify_conversion (expr_p
);
11537 if (ret
== GS_ERROR
)
11539 if (*expr_p
!= save_expr
)
11543 case FIX_TRUNC_EXPR
:
11544 /* unary_expr: ... | '(' cast ')' val | ... */
11545 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
11546 is_gimple_val
, fb_rvalue
);
11547 recalculate_side_effects (*expr_p
);
11552 bool volatilep
= TREE_THIS_VOLATILE (*expr_p
);
11553 bool notrap
= TREE_THIS_NOTRAP (*expr_p
);
11554 tree saved_ptr_type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 0));
11556 *expr_p
= fold_indirect_ref_loc (input_location
, *expr_p
);
11557 if (*expr_p
!= save_expr
)
11563 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
11564 is_gimple_reg
, fb_rvalue
);
11565 if (ret
== GS_ERROR
)
11568 recalculate_side_effects (*expr_p
);
11569 *expr_p
= fold_build2_loc (input_location
, MEM_REF
,
11570 TREE_TYPE (*expr_p
),
11571 TREE_OPERAND (*expr_p
, 0),
11572 build_int_cst (saved_ptr_type
, 0));
11573 TREE_THIS_VOLATILE (*expr_p
) = volatilep
;
11574 TREE_THIS_NOTRAP (*expr_p
) = notrap
;
11579 /* We arrive here through the various re-gimplifcation paths. */
11581 /* First try re-folding the whole thing. */
11582 tmp
= fold_binary (MEM_REF
, TREE_TYPE (*expr_p
),
11583 TREE_OPERAND (*expr_p
, 0),
11584 TREE_OPERAND (*expr_p
, 1));
11587 REF_REVERSE_STORAGE_ORDER (tmp
)
11588 = REF_REVERSE_STORAGE_ORDER (*expr_p
);
11590 recalculate_side_effects (*expr_p
);
11594 /* Avoid re-gimplifying the address operand if it is already
11595 in suitable form. Re-gimplifying would mark the address
11596 operand addressable. Always gimplify when not in SSA form
11597 as we still may have to gimplify decls with value-exprs. */
11598 if (!gimplify_ctxp
|| !gimple_in_ssa_p (cfun
)
11599 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p
, 0)))
11601 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
11602 is_gimple_mem_ref_addr
, fb_rvalue
);
11603 if (ret
== GS_ERROR
)
11606 recalculate_side_effects (*expr_p
);
11610 /* Constants need not be gimplified. */
11617 /* Drop the overflow flag on constants, we do not want
11618 that in the GIMPLE IL. */
11619 if (TREE_OVERFLOW_P (*expr_p
))
11620 *expr_p
= drop_tree_overflow (*expr_p
);
11625 /* If we require an lvalue, such as for ADDR_EXPR, retain the
11626 CONST_DECL node. Otherwise the decl is replaceable by its
11628 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
11629 if (fallback
& fb_lvalue
)
11633 *expr_p
= DECL_INITIAL (*expr_p
);
11639 ret
= gimplify_decl_expr (expr_p
, pre_p
);
11643 ret
= gimplify_bind_expr (expr_p
, pre_p
);
11647 ret
= gimplify_loop_expr (expr_p
, pre_p
);
11651 ret
= gimplify_switch_expr (expr_p
, pre_p
);
11655 ret
= gimplify_exit_expr (expr_p
);
11659 /* If the target is not LABEL, then it is a computed jump
11660 and the target needs to be gimplified. */
11661 if (TREE_CODE (GOTO_DESTINATION (*expr_p
)) != LABEL_DECL
)
11663 ret
= gimplify_expr (&GOTO_DESTINATION (*expr_p
), pre_p
,
11664 NULL
, is_gimple_val
, fb_rvalue
);
11665 if (ret
== GS_ERROR
)
11668 gimplify_seq_add_stmt (pre_p
,
11669 gimple_build_goto (GOTO_DESTINATION (*expr_p
)));
11674 gimplify_seq_add_stmt (pre_p
,
11675 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p
),
11676 PREDICT_EXPR_OUTCOME (*expr_p
)));
11681 ret
= gimplify_label_expr (expr_p
, pre_p
);
11682 label
= LABEL_EXPR_LABEL (*expr_p
);
11683 gcc_assert (decl_function_context (label
) == current_function_decl
);
11685 /* If the label is used in a goto statement, or address of the label
11686 is taken, we need to unpoison all variables that were seen so far.
11687 Doing so would prevent us from reporting a false positives. */
11688 if (asan_poisoned_variables
11689 && asan_used_labels
!= NULL
11690 && asan_used_labels
->contains (label
))
11691 asan_poison_variables (asan_poisoned_variables
, false, pre_p
);
11694 case CASE_LABEL_EXPR
:
11695 ret
= gimplify_case_label_expr (expr_p
, pre_p
);
11697 if (gimplify_ctxp
->live_switch_vars
)
11698 asan_poison_variables (gimplify_ctxp
->live_switch_vars
, false,
11703 ret
= gimplify_return_expr (*expr_p
, pre_p
);
11707 /* Don't reduce this in place; let gimplify_init_constructor work its
11708 magic. Buf if we're just elaborating this for side effects, just
11709 gimplify any element that has side-effects. */
11710 if (fallback
== fb_none
)
11712 unsigned HOST_WIDE_INT ix
;
11714 tree temp
= NULL_TREE
;
11715 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p
), ix
, val
)
11716 if (TREE_SIDE_EFFECTS (val
))
11717 append_to_statement_list (val
, &temp
);
11720 ret
= temp
? GS_OK
: GS_ALL_DONE
;
11722 /* C99 code may assign to an array in a constructed
11723 structure or union, and this has undefined behavior only
11724 on execution, so create a temporary if an lvalue is
11726 else if (fallback
== fb_lvalue
)
11728 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
, false);
11729 mark_addressable (*expr_p
);
11736 /* The following are special cases that are not handled by the
11737 original GIMPLE grammar. */
11739 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
11742 ret
= gimplify_save_expr (expr_p
, pre_p
, post_p
);
11745 case BIT_FIELD_REF
:
11746 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
11747 post_p
, is_gimple_lvalue
, fb_either
);
11748 recalculate_side_effects (*expr_p
);
11751 case TARGET_MEM_REF
:
11753 enum gimplify_status r0
= GS_ALL_DONE
, r1
= GS_ALL_DONE
;
11755 if (TMR_BASE (*expr_p
))
11756 r0
= gimplify_expr (&TMR_BASE (*expr_p
), pre_p
,
11757 post_p
, is_gimple_mem_ref_addr
, fb_either
);
11758 if (TMR_INDEX (*expr_p
))
11759 r1
= gimplify_expr (&TMR_INDEX (*expr_p
), pre_p
,
11760 post_p
, is_gimple_val
, fb_rvalue
);
11761 if (TMR_INDEX2 (*expr_p
))
11762 r1
= gimplify_expr (&TMR_INDEX2 (*expr_p
), pre_p
,
11763 post_p
, is_gimple_val
, fb_rvalue
);
11764 /* TMR_STEP and TMR_OFFSET are always integer constants. */
11765 ret
= MIN (r0
, r1
);
11769 case NON_LVALUE_EXPR
:
11770 /* This should have been stripped above. */
11771 gcc_unreachable ();
11774 ret
= gimplify_asm_expr (expr_p
, pre_p
, post_p
);
11777 case TRY_FINALLY_EXPR
:
11778 case TRY_CATCH_EXPR
:
11780 gimple_seq eval
, cleanup
;
11783 /* Calls to destructors are generated automatically in FINALLY/CATCH
11784 block. They should have location as UNKNOWN_LOCATION. However,
11785 gimplify_call_expr will reset these call stmts to input_location
11786 if it finds stmt's location is unknown. To prevent resetting for
11787 destructors, we set the input_location to unknown.
11788 Note that this only affects the destructor calls in FINALLY/CATCH
11789 block, and will automatically reset to its original value by the
11790 end of gimplify_expr. */
11791 input_location
= UNKNOWN_LOCATION
;
11792 eval
= cleanup
= NULL
;
11793 gimplify_and_add (TREE_OPERAND (*expr_p
, 0), &eval
);
11794 gimplify_and_add (TREE_OPERAND (*expr_p
, 1), &cleanup
);
11795 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
11796 if (gimple_seq_empty_p (cleanup
))
11798 gimple_seq_add_seq (pre_p
, eval
);
11802 try_
= gimple_build_try (eval
, cleanup
,
11803 TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
11804 ? GIMPLE_TRY_FINALLY
11805 : GIMPLE_TRY_CATCH
);
11806 if (EXPR_HAS_LOCATION (save_expr
))
11807 gimple_set_location (try_
, EXPR_LOCATION (save_expr
));
11808 else if (LOCATION_LOCUS (saved_location
) != UNKNOWN_LOCATION
)
11809 gimple_set_location (try_
, saved_location
);
11810 if (TREE_CODE (*expr_p
) == TRY_CATCH_EXPR
)
11811 gimple_try_set_catch_is_cleanup (try_
,
11812 TRY_CATCH_IS_CLEANUP (*expr_p
));
11813 gimplify_seq_add_stmt (pre_p
, try_
);
11818 case CLEANUP_POINT_EXPR
:
11819 ret
= gimplify_cleanup_point_expr (expr_p
, pre_p
);
11823 ret
= gimplify_target_expr (expr_p
, pre_p
, post_p
);
11829 gimple_seq handler
= NULL
;
11830 gimplify_and_add (CATCH_BODY (*expr_p
), &handler
);
11831 c
= gimple_build_catch (CATCH_TYPES (*expr_p
), handler
);
11832 gimplify_seq_add_stmt (pre_p
, c
);
11837 case EH_FILTER_EXPR
:
11840 gimple_seq failure
= NULL
;
11842 gimplify_and_add (EH_FILTER_FAILURE (*expr_p
), &failure
);
11843 ehf
= gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p
), failure
);
11844 gimple_set_no_warning (ehf
, TREE_NO_WARNING (*expr_p
));
11845 gimplify_seq_add_stmt (pre_p
, ehf
);
11852 enum gimplify_status r0
, r1
;
11853 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
,
11854 post_p
, is_gimple_val
, fb_rvalue
);
11855 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
,
11856 post_p
, is_gimple_val
, fb_rvalue
);
11857 TREE_SIDE_EFFECTS (*expr_p
) = 0;
11858 ret
= MIN (r0
, r1
);
11863 /* We get here when taking the address of a label. We mark
11864 the label as "forced"; meaning it can never be removed and
11865 it is a potential target for any computed goto. */
11866 FORCED_LABEL (*expr_p
) = 1;
11870 case STATEMENT_LIST
:
11871 ret
= gimplify_statement_list (expr_p
, pre_p
);
11874 case WITH_SIZE_EXPR
:
11876 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
11877 post_p
== &internal_post
? NULL
: post_p
,
11878 gimple_test_f
, fallback
);
11879 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
11880 is_gimple_val
, fb_rvalue
);
11887 ret
= gimplify_var_or_parm_decl (expr_p
);
11891 /* When within an OMP context, notice uses of variables. */
11892 if (gimplify_omp_ctxp
)
11893 omp_notice_variable (gimplify_omp_ctxp
, *expr_p
, true);
11897 case DEBUG_EXPR_DECL
:
11898 gcc_unreachable ();
11900 case DEBUG_BEGIN_STMT
:
11901 gimplify_seq_add_stmt (pre_p
,
11902 gimple_build_debug_begin_stmt
11903 (TREE_BLOCK (*expr_p
),
11904 EXPR_LOCATION (*expr_p
)));
11910 /* Allow callbacks into the gimplifier during optimization. */
11915 gimplify_omp_parallel (expr_p
, pre_p
);
11920 gimplify_omp_task (expr_p
, pre_p
);
11926 case OMP_DISTRIBUTE
:
11929 ret
= gimplify_omp_for (expr_p
, pre_p
);
11933 gimplify_oacc_cache (expr_p
, pre_p
);
11938 gimplify_oacc_declare (expr_p
, pre_p
);
11942 case OACC_HOST_DATA
:
11945 case OACC_PARALLEL
:
11949 case OMP_TARGET_DATA
:
11951 gimplify_omp_workshare (expr_p
, pre_p
);
11955 case OACC_ENTER_DATA
:
11956 case OACC_EXIT_DATA
:
11958 case OMP_TARGET_UPDATE
:
11959 case OMP_TARGET_ENTER_DATA
:
11960 case OMP_TARGET_EXIT_DATA
:
11961 gimplify_omp_target_update (expr_p
, pre_p
);
11967 case OMP_TASKGROUP
:
11971 gimple_seq body
= NULL
;
11974 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
11975 switch (TREE_CODE (*expr_p
))
11978 g
= gimple_build_omp_section (body
);
11981 g
= gimple_build_omp_master (body
);
11983 case OMP_TASKGROUP
:
11985 gimple_seq cleanup
= NULL
;
11987 = builtin_decl_explicit (BUILT_IN_GOMP_TASKGROUP_END
);
11988 g
= gimple_build_call (fn
, 0);
11989 gimple_seq_add_stmt (&cleanup
, g
);
11990 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
11992 gimple_seq_add_stmt (&body
, g
);
11993 g
= gimple_build_omp_taskgroup (body
);
11997 g
= gimplify_omp_ordered (*expr_p
, body
);
12000 gimplify_scan_omp_clauses (&OMP_CRITICAL_CLAUSES (*expr_p
),
12001 pre_p
, ORT_WORKSHARE
, OMP_CRITICAL
);
12002 gimplify_adjust_omp_clauses (pre_p
, body
,
12003 &OMP_CRITICAL_CLAUSES (*expr_p
),
12005 g
= gimple_build_omp_critical (body
,
12006 OMP_CRITICAL_NAME (*expr_p
),
12007 OMP_CRITICAL_CLAUSES (*expr_p
));
12010 gcc_unreachable ();
12012 gimplify_seq_add_stmt (pre_p
, g
);
12018 case OMP_ATOMIC_READ
:
12019 case OMP_ATOMIC_CAPTURE_OLD
:
12020 case OMP_ATOMIC_CAPTURE_NEW
:
12021 ret
= gimplify_omp_atomic (expr_p
, pre_p
);
12024 case TRANSACTION_EXPR
:
12025 ret
= gimplify_transaction (expr_p
, pre_p
);
12028 case TRUTH_AND_EXPR
:
12029 case TRUTH_OR_EXPR
:
12030 case TRUTH_XOR_EXPR
:
12032 tree orig_type
= TREE_TYPE (*expr_p
);
12033 tree new_type
, xop0
, xop1
;
12034 *expr_p
= gimple_boolify (*expr_p
);
12035 new_type
= TREE_TYPE (*expr_p
);
12036 if (!useless_type_conversion_p (orig_type
, new_type
))
12038 *expr_p
= fold_convert_loc (input_location
, orig_type
, *expr_p
);
12043 /* Boolified binary truth expressions are semantically equivalent
12044 to bitwise binary expressions. Canonicalize them to the
12045 bitwise variant. */
12046 switch (TREE_CODE (*expr_p
))
12048 case TRUTH_AND_EXPR
:
12049 TREE_SET_CODE (*expr_p
, BIT_AND_EXPR
);
12051 case TRUTH_OR_EXPR
:
12052 TREE_SET_CODE (*expr_p
, BIT_IOR_EXPR
);
12054 case TRUTH_XOR_EXPR
:
12055 TREE_SET_CODE (*expr_p
, BIT_XOR_EXPR
);
12060 /* Now make sure that operands have compatible type to
12061 expression's new_type. */
12062 xop0
= TREE_OPERAND (*expr_p
, 0);
12063 xop1
= TREE_OPERAND (*expr_p
, 1);
12064 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop0
)))
12065 TREE_OPERAND (*expr_p
, 0) = fold_convert_loc (input_location
,
12068 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop1
)))
12069 TREE_OPERAND (*expr_p
, 1) = fold_convert_loc (input_location
,
12072 /* Continue classified as tcc_binary. */
12076 case VEC_COND_EXPR
:
12078 enum gimplify_status r0
, r1
, r2
;
12080 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
12081 post_p
, is_gimple_condexpr
, fb_rvalue
);
12082 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
12083 post_p
, is_gimple_val
, fb_rvalue
);
12084 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
12085 post_p
, is_gimple_val
, fb_rvalue
);
12087 ret
= MIN (MIN (r0
, r1
), r2
);
12088 recalculate_side_effects (*expr_p
);
12092 case VEC_PERM_EXPR
:
12093 /* Classified as tcc_expression. */
12096 case BIT_INSERT_EXPR
:
12097 /* Argument 3 is a constant. */
12100 case POINTER_PLUS_EXPR
:
12102 enum gimplify_status r0
, r1
;
12103 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
12104 post_p
, is_gimple_val
, fb_rvalue
);
12105 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
12106 post_p
, is_gimple_val
, fb_rvalue
);
12107 recalculate_side_effects (*expr_p
);
12108 ret
= MIN (r0
, r1
);
12113 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p
)))
12115 case tcc_comparison
:
12116 /* Handle comparison of objects of non scalar mode aggregates
12117 with a call to memcmp. It would be nice to only have to do
12118 this for variable-sized objects, but then we'd have to allow
12119 the same nest of reference nodes we allow for MODIFY_EXPR and
12120 that's too complex.
12122 Compare scalar mode aggregates as scalar mode values. Using
12123 memcmp for them would be very inefficient at best, and is
12124 plain wrong if bitfields are involved. */
12126 tree type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 1));
12128 /* Vector comparisons need no boolification. */
12129 if (TREE_CODE (type
) == VECTOR_TYPE
)
12131 else if (!AGGREGATE_TYPE_P (type
))
12133 tree org_type
= TREE_TYPE (*expr_p
);
12134 *expr_p
= gimple_boolify (*expr_p
);
12135 if (!useless_type_conversion_p (org_type
,
12136 TREE_TYPE (*expr_p
)))
12138 *expr_p
= fold_convert_loc (input_location
,
12139 org_type
, *expr_p
);
12145 else if (TYPE_MODE (type
) != BLKmode
)
12146 ret
= gimplify_scalar_mode_aggregate_compare (expr_p
);
12148 ret
= gimplify_variable_sized_compare (expr_p
);
12153 /* If *EXPR_P does not need to be special-cased, handle it
12154 according to its class. */
12156 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
12157 post_p
, is_gimple_val
, fb_rvalue
);
12163 enum gimplify_status r0
, r1
;
12165 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
12166 post_p
, is_gimple_val
, fb_rvalue
);
12167 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
12168 post_p
, is_gimple_val
, fb_rvalue
);
12170 ret
= MIN (r0
, r1
);
12176 enum gimplify_status r0
, r1
, r2
;
12178 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
12179 post_p
, is_gimple_val
, fb_rvalue
);
12180 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
12181 post_p
, is_gimple_val
, fb_rvalue
);
12182 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
12183 post_p
, is_gimple_val
, fb_rvalue
);
12185 ret
= MIN (MIN (r0
, r1
), r2
);
12189 case tcc_declaration
:
12192 goto dont_recalculate
;
12195 gcc_unreachable ();
12198 recalculate_side_effects (*expr_p
);
12204 gcc_assert (*expr_p
|| ret
!= GS_OK
);
12206 while (ret
== GS_OK
);
12208 /* If we encountered an error_mark somewhere nested inside, either
12209 stub out the statement or propagate the error back out. */
12210 if (ret
== GS_ERROR
)
12217 /* This was only valid as a return value from the langhook, which
12218 we handled. Make sure it doesn't escape from any other context. */
12219 gcc_assert (ret
!= GS_UNHANDLED
);
12221 if (fallback
== fb_none
&& *expr_p
&& !is_gimple_stmt (*expr_p
))
12223 /* We aren't looking for a value, and we don't have a valid
12224 statement. If it doesn't have side-effects, throw it away.
12225 We can also get here with code such as "*&&L;", where L is
12226 a LABEL_DECL that is marked as FORCED_LABEL. */
12227 if (TREE_CODE (*expr_p
) == LABEL_DECL
12228 || !TREE_SIDE_EFFECTS (*expr_p
))
12230 else if (!TREE_THIS_VOLATILE (*expr_p
))
12232 /* This is probably a _REF that contains something nested that
12233 has side effects. Recurse through the operands to find it. */
12234 enum tree_code code
= TREE_CODE (*expr_p
);
12238 case COMPONENT_REF
:
12239 case REALPART_EXPR
:
12240 case IMAGPART_EXPR
:
12241 case VIEW_CONVERT_EXPR
:
12242 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
12243 gimple_test_f
, fallback
);
12247 case ARRAY_RANGE_REF
:
12248 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
12249 gimple_test_f
, fallback
);
12250 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
12251 gimple_test_f
, fallback
);
12255 /* Anything else with side-effects must be converted to
12256 a valid statement before we get here. */
12257 gcc_unreachable ();
12262 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p
))
12263 && TYPE_MODE (TREE_TYPE (*expr_p
)) != BLKmode
)
12265 /* Historically, the compiler has treated a bare reference
12266 to a non-BLKmode volatile lvalue as forcing a load. */
12267 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p
));
12269 /* Normally, we do not want to create a temporary for a
12270 TREE_ADDRESSABLE type because such a type should not be
12271 copied by bitwise-assignment. However, we make an
12272 exception here, as all we are doing here is ensuring that
12273 we read the bytes that make up the type. We use
12274 create_tmp_var_raw because create_tmp_var will abort when
12275 given a TREE_ADDRESSABLE type. */
12276 tree tmp
= create_tmp_var_raw (type
, "vol");
12277 gimple_add_tmp_var (tmp
);
12278 gimplify_assign (tmp
, *expr_p
, pre_p
);
12282 /* We can't do anything useful with a volatile reference to
12283 an incomplete type, so just throw it away. Likewise for
12284 a BLKmode type, since any implicit inner load should
12285 already have been turned into an explicit one by the
12286 gimplification process. */
12290 /* If we are gimplifying at the statement level, we're done. Tack
12291 everything together and return. */
12292 if (fallback
== fb_none
|| is_statement
)
12294 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
12295 it out for GC to reclaim it. */
12296 *expr_p
= NULL_TREE
;
12298 if (!gimple_seq_empty_p (internal_pre
)
12299 || !gimple_seq_empty_p (internal_post
))
12301 gimplify_seq_add_seq (&internal_pre
, internal_post
);
12302 gimplify_seq_add_seq (pre_p
, internal_pre
);
12305 /* The result of gimplifying *EXPR_P is going to be the last few
12306 statements in *PRE_P and *POST_P. Add location information
12307 to all the statements that were added by the gimplification
12309 if (!gimple_seq_empty_p (*pre_p
))
12310 annotate_all_with_location_after (*pre_p
, pre_last_gsi
, input_location
);
12312 if (!gimple_seq_empty_p (*post_p
))
12313 annotate_all_with_location_after (*post_p
, post_last_gsi
,
12319 #ifdef ENABLE_GIMPLE_CHECKING
12322 enum tree_code code
= TREE_CODE (*expr_p
);
12323 /* These expressions should already be in gimple IR form. */
12324 gcc_assert (code
!= MODIFY_EXPR
12325 && code
!= ASM_EXPR
12326 && code
!= BIND_EXPR
12327 && code
!= CATCH_EXPR
12328 && (code
!= COND_EXPR
|| gimplify_ctxp
->allow_rhs_cond_expr
)
12329 && code
!= EH_FILTER_EXPR
12330 && code
!= GOTO_EXPR
12331 && code
!= LABEL_EXPR
12332 && code
!= LOOP_EXPR
12333 && code
!= SWITCH_EXPR
12334 && code
!= TRY_FINALLY_EXPR
12335 && code
!= OACC_PARALLEL
12336 && code
!= OACC_KERNELS
12337 && code
!= OACC_DATA
12338 && code
!= OACC_HOST_DATA
12339 && code
!= OACC_DECLARE
12340 && code
!= OACC_UPDATE
12341 && code
!= OACC_ENTER_DATA
12342 && code
!= OACC_EXIT_DATA
12343 && code
!= OACC_CACHE
12344 && code
!= OMP_CRITICAL
12346 && code
!= OACC_LOOP
12347 && code
!= OMP_MASTER
12348 && code
!= OMP_TASKGROUP
12349 && code
!= OMP_ORDERED
12350 && code
!= OMP_PARALLEL
12351 && code
!= OMP_SECTIONS
12352 && code
!= OMP_SECTION
12353 && code
!= OMP_SINGLE
);
12357 /* Otherwise we're gimplifying a subexpression, so the resulting
12358 value is interesting. If it's a valid operand that matches
12359 GIMPLE_TEST_F, we're done. Unless we are handling some
12360 post-effects internally; if that's the case, we need to copy into
12361 a temporary before adding the post-effects to POST_P. */
12362 if (gimple_seq_empty_p (internal_post
) && (*gimple_test_f
) (*expr_p
))
12365 /* Otherwise, we need to create a new temporary for the gimplified
12368 /* We can't return an lvalue if we have an internal postqueue. The
12369 object the lvalue refers to would (probably) be modified by the
12370 postqueue; we need to copy the value out first, which means an
12372 if ((fallback
& fb_lvalue
)
12373 && gimple_seq_empty_p (internal_post
)
12374 && is_gimple_addressable (*expr_p
))
12376 /* An lvalue will do. Take the address of the expression, store it
12377 in a temporary, and replace the expression with an INDIRECT_REF of
12379 tmp
= build_fold_addr_expr_loc (input_location
, *expr_p
);
12380 gimplify_expr (&tmp
, pre_p
, post_p
, is_gimple_reg
, fb_rvalue
);
12381 *expr_p
= build_simple_mem_ref (tmp
);
12383 else if ((fallback
& fb_rvalue
) && is_gimple_reg_rhs_or_call (*expr_p
))
12385 /* An rvalue will do. Assign the gimplified expression into a
12386 new temporary TMP and replace the original expression with
12387 TMP. First, make sure that the expression has a type so that
12388 it can be assigned into a temporary. */
12389 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p
)));
12390 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
12394 #ifdef ENABLE_GIMPLE_CHECKING
12395 if (!(fallback
& fb_mayfail
))
12397 fprintf (stderr
, "gimplification failed:\n");
12398 print_generic_expr (stderr
, *expr_p
);
12399 debug_tree (*expr_p
);
12400 internal_error ("gimplification failed");
12403 gcc_assert (fallback
& fb_mayfail
);
12405 /* If this is an asm statement, and the user asked for the
12406 impossible, don't die. Fail and let gimplify_asm_expr
12412 /* Make sure the temporary matches our predicate. */
12413 gcc_assert ((*gimple_test_f
) (*expr_p
));
12415 if (!gimple_seq_empty_p (internal_post
))
12417 annotate_all_with_location (internal_post
, input_location
);
12418 gimplify_seq_add_seq (pre_p
, internal_post
);
12422 input_location
= saved_location
;
12426 /* Like gimplify_expr but make sure the gimplified result is not itself
12427 a SSA name (but a decl if it were). Temporaries required by
12428 evaluating *EXPR_P may be still SSA names. */
12430 static enum gimplify_status
12431 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
12432 bool (*gimple_test_f
) (tree
), fallback_t fallback
,
12435 bool was_ssa_name_p
= TREE_CODE (*expr_p
) == SSA_NAME
;
12436 enum gimplify_status ret
= gimplify_expr (expr_p
, pre_p
, post_p
,
12437 gimple_test_f
, fallback
);
12439 && TREE_CODE (*expr_p
) == SSA_NAME
)
12441 tree name
= *expr_p
;
12442 if (was_ssa_name_p
)
12443 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, NULL
, false);
12446 /* Avoid the extra copy if possible. */
12447 *expr_p
= create_tmp_reg (TREE_TYPE (name
));
12448 gimple_set_lhs (SSA_NAME_DEF_STMT (name
), *expr_p
);
12449 release_ssa_name (name
);
12455 /* Look through TYPE for variable-sized objects and gimplify each such
12456 size that we find. Add to LIST_P any statements generated. */
12459 gimplify_type_sizes (tree type
, gimple_seq
*list_p
)
12463 if (type
== NULL
|| type
== error_mark_node
)
12466 /* We first do the main variant, then copy into any other variants. */
12467 type
= TYPE_MAIN_VARIANT (type
);
12469 /* Avoid infinite recursion. */
12470 if (TYPE_SIZES_GIMPLIFIED (type
))
12473 TYPE_SIZES_GIMPLIFIED (type
) = 1;
12475 switch (TREE_CODE (type
))
12478 case ENUMERAL_TYPE
:
12481 case FIXED_POINT_TYPE
:
12482 gimplify_one_sizepos (&TYPE_MIN_VALUE (type
), list_p
);
12483 gimplify_one_sizepos (&TYPE_MAX_VALUE (type
), list_p
);
12485 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
12487 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (type
);
12488 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (type
);
12493 /* These types may not have declarations, so handle them here. */
12494 gimplify_type_sizes (TREE_TYPE (type
), list_p
);
12495 gimplify_type_sizes (TYPE_DOMAIN (type
), list_p
);
12496 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
12497 with assigned stack slots, for -O1+ -g they should be tracked
12499 if (!(TYPE_NAME (type
)
12500 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
12501 && DECL_IGNORED_P (TYPE_NAME (type
)))
12502 && TYPE_DOMAIN (type
)
12503 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type
)))
12505 t
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
12506 if (t
&& VAR_P (t
) && DECL_ARTIFICIAL (t
))
12507 DECL_IGNORED_P (t
) = 0;
12508 t
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
12509 if (t
&& VAR_P (t
) && DECL_ARTIFICIAL (t
))
12510 DECL_IGNORED_P (t
) = 0;
12516 case QUAL_UNION_TYPE
:
12517 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
12518 if (TREE_CODE (field
) == FIELD_DECL
)
12520 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field
), list_p
);
12521 gimplify_one_sizepos (&DECL_SIZE (field
), list_p
);
12522 gimplify_one_sizepos (&DECL_SIZE_UNIT (field
), list_p
);
12523 gimplify_type_sizes (TREE_TYPE (field
), list_p
);
12528 case REFERENCE_TYPE
:
12529 /* We used to recurse on the pointed-to type here, which turned out to
12530 be incorrect because its definition might refer to variables not
12531 yet initialized at this point if a forward declaration is involved.
12533 It was actually useful for anonymous pointed-to types to ensure
12534 that the sizes evaluation dominates every possible later use of the
12535 values. Restricting to such types here would be safe since there
12536 is no possible forward declaration around, but would introduce an
12537 undesirable middle-end semantic to anonymity. We then defer to
12538 front-ends the responsibility of ensuring that the sizes are
12539 evaluated both early and late enough, e.g. by attaching artificial
12540 type declarations to the tree. */
12547 gimplify_one_sizepos (&TYPE_SIZE (type
), list_p
);
12548 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type
), list_p
);
12550 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
12552 TYPE_SIZE (t
) = TYPE_SIZE (type
);
12553 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (type
);
12554 TYPE_SIZES_GIMPLIFIED (t
) = 1;
12558 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
12559 a size or position, has had all of its SAVE_EXPRs evaluated.
12560 We add any required statements to *STMT_P. */
12563 gimplify_one_sizepos (tree
*expr_p
, gimple_seq
*stmt_p
)
12565 tree expr
= *expr_p
;
12567 /* We don't do anything if the value isn't there, is constant, or contains
12568 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
12569 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
12570 will want to replace it with a new variable, but that will cause problems
12571 if this type is from outside the function. It's OK to have that here. */
12572 if (expr
== NULL_TREE
12573 || is_gimple_constant (expr
)
12574 || TREE_CODE (expr
) == VAR_DECL
12575 || CONTAINS_PLACEHOLDER_P (expr
))
12578 *expr_p
= unshare_expr (expr
);
12580 /* SSA names in decl/type fields are a bad idea - they'll get reclaimed
12581 if the def vanishes. */
12582 gimplify_expr (expr_p
, stmt_p
, NULL
, is_gimple_val
, fb_rvalue
, false);
12584 /* If expr wasn't already is_gimple_sizepos or is_gimple_constant from the
12585 FE, ensure that it is a VAR_DECL, otherwise we might handle some decls
12586 as gimplify_vla_decl even when they would have all sizes INTEGER_CSTs. */
12587 if (is_gimple_constant (*expr_p
))
12588 *expr_p
= get_initialized_tmp_var (*expr_p
, stmt_p
, NULL
, false);
12591 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
12592 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
12593 is true, also gimplify the parameters. */
12596 gimplify_body (tree fndecl
, bool do_parms
)
12598 location_t saved_location
= input_location
;
12599 gimple_seq parm_stmts
, parm_cleanup
= NULL
, seq
;
12600 gimple
*outer_stmt
;
12602 struct cgraph_node
*cgn
;
12604 timevar_push (TV_TREE_GIMPLIFY
);
12606 init_tree_ssa (cfun
);
12608 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
12610 default_rtl_profile ();
12612 gcc_assert (gimplify_ctxp
== NULL
);
12613 push_gimplify_context (true);
12615 if (flag_openacc
|| flag_openmp
)
12617 gcc_assert (gimplify_omp_ctxp
== NULL
);
12618 if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (fndecl
)))
12619 gimplify_omp_ctxp
= new_omp_context (ORT_TARGET
);
12622 /* Unshare most shared trees in the body and in that of any nested functions.
12623 It would seem we don't have to do this for nested functions because
12624 they are supposed to be output and then the outer function gimplified
12625 first, but the g++ front end doesn't always do it that way. */
12626 unshare_body (fndecl
);
12627 unvisit_body (fndecl
);
12629 cgn
= cgraph_node::get (fndecl
);
12630 if (cgn
&& cgn
->origin
)
12631 nonlocal_vlas
= new hash_set
<tree
>;
12633 /* Make sure input_location isn't set to something weird. */
12634 input_location
= DECL_SOURCE_LOCATION (fndecl
);
12636 /* Resolve callee-copies. This has to be done before processing
12637 the body so that DECL_VALUE_EXPR gets processed correctly. */
12638 parm_stmts
= do_parms
? gimplify_parameters (&parm_cleanup
) : NULL
;
12640 /* Gimplify the function's body. */
12642 gimplify_stmt (&DECL_SAVED_TREE (fndecl
), &seq
);
12643 outer_stmt
= gimple_seq_first_stmt (seq
);
12646 outer_stmt
= gimple_build_nop ();
12647 gimplify_seq_add_stmt (&seq
, outer_stmt
);
12650 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
12651 not the case, wrap everything in a GIMPLE_BIND to make it so. */
12652 if (gimple_code (outer_stmt
) == GIMPLE_BIND
12653 && gimple_seq_first (seq
) == gimple_seq_last (seq
))
12654 outer_bind
= as_a
<gbind
*> (outer_stmt
);
12656 outer_bind
= gimple_build_bind (NULL_TREE
, seq
, NULL
);
12658 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
12660 /* If we had callee-copies statements, insert them at the beginning
12661 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
12662 if (!gimple_seq_empty_p (parm_stmts
))
12666 gimplify_seq_add_seq (&parm_stmts
, gimple_bind_body (outer_bind
));
12669 gtry
*g
= gimple_build_try (parm_stmts
, parm_cleanup
,
12670 GIMPLE_TRY_FINALLY
);
12672 gimple_seq_add_stmt (&parm_stmts
, g
);
12674 gimple_bind_set_body (outer_bind
, parm_stmts
);
12676 for (parm
= DECL_ARGUMENTS (current_function_decl
);
12677 parm
; parm
= DECL_CHAIN (parm
))
12678 if (DECL_HAS_VALUE_EXPR_P (parm
))
12680 DECL_HAS_VALUE_EXPR_P (parm
) = 0;
12681 DECL_IGNORED_P (parm
) = 0;
12687 if (nonlocal_vla_vars
)
12689 /* tree-nested.c may later on call declare_vars (..., true);
12690 which relies on BLOCK_VARS chain to be the tail of the
12691 gimple_bind_vars chain. Ensure we don't violate that
12693 if (gimple_bind_block (outer_bind
)
12694 == DECL_INITIAL (current_function_decl
))
12695 declare_vars (nonlocal_vla_vars
, outer_bind
, true);
12697 BLOCK_VARS (DECL_INITIAL (current_function_decl
))
12698 = chainon (BLOCK_VARS (DECL_INITIAL (current_function_decl
)),
12699 nonlocal_vla_vars
);
12700 nonlocal_vla_vars
= NULL_TREE
;
12702 delete nonlocal_vlas
;
12703 nonlocal_vlas
= NULL
;
12706 if ((flag_openacc
|| flag_openmp
|| flag_openmp_simd
)
12707 && gimplify_omp_ctxp
)
12709 delete_omp_context (gimplify_omp_ctxp
);
12710 gimplify_omp_ctxp
= NULL
;
12713 pop_gimplify_context (outer_bind
);
12714 gcc_assert (gimplify_ctxp
== NULL
);
12716 if (flag_checking
&& !seen_error ())
12717 verify_gimple_in_seq (gimple_bind_body (outer_bind
));
12719 timevar_pop (TV_TREE_GIMPLIFY
);
12720 input_location
= saved_location
;
12725 typedef char *char_p
; /* For DEF_VEC_P. */
12727 /* Return whether we should exclude FNDECL from instrumentation. */
12730 flag_instrument_functions_exclude_p (tree fndecl
)
12734 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_functions
;
12735 if (v
&& v
->length () > 0)
12741 name
= lang_hooks
.decl_printable_name (fndecl
, 0);
12742 FOR_EACH_VEC_ELT (*v
, i
, s
)
12743 if (strstr (name
, s
) != NULL
)
12747 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_files
;
12748 if (v
&& v
->length () > 0)
12754 name
= DECL_SOURCE_FILE (fndecl
);
12755 FOR_EACH_VEC_ELT (*v
, i
, s
)
12756 if (strstr (name
, s
) != NULL
)
12763 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
12764 node for the function we want to gimplify.
12766 Return the sequence of GIMPLE statements corresponding to the body
12770 gimplify_function_tree (tree fndecl
)
12776 gcc_assert (!gimple_body (fndecl
));
12778 if (DECL_STRUCT_FUNCTION (fndecl
))
12779 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
12781 push_struct_function (fndecl
);
12783 /* Tentatively set PROP_gimple_lva here, and reset it in gimplify_va_arg_expr
12785 cfun
->curr_properties
|= PROP_gimple_lva
;
12787 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
12789 /* Preliminarily mark non-addressed complex variables as eligible
12790 for promotion to gimple registers. We'll transform their uses
12791 as we find them. */
12792 if ((TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
12793 || TREE_CODE (TREE_TYPE (parm
)) == VECTOR_TYPE
)
12794 && !TREE_THIS_VOLATILE (parm
)
12795 && !needs_to_live_in_memory (parm
))
12796 DECL_GIMPLE_REG_P (parm
) = 1;
12799 ret
= DECL_RESULT (fndecl
);
12800 if ((TREE_CODE (TREE_TYPE (ret
)) == COMPLEX_TYPE
12801 || TREE_CODE (TREE_TYPE (ret
)) == VECTOR_TYPE
)
12802 && !needs_to_live_in_memory (ret
))
12803 DECL_GIMPLE_REG_P (ret
) = 1;
12805 if (asan_sanitize_use_after_scope () && sanitize_flags_p (SANITIZE_ADDRESS
))
12806 asan_poisoned_variables
= new hash_set
<tree
> ();
12807 bind
= gimplify_body (fndecl
, true);
12808 if (asan_poisoned_variables
)
12810 delete asan_poisoned_variables
;
12811 asan_poisoned_variables
= NULL
;
12814 /* The tree body of the function is no longer needed, replace it
12815 with the new GIMPLE body. */
12817 gimple_seq_add_stmt (&seq
, bind
);
12818 gimple_set_body (fndecl
, seq
);
12820 /* If we're instrumenting function entry/exit, then prepend the call to
12821 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
12822 catch the exit hook. */
12823 /* ??? Add some way to ignore exceptions for this TFE. */
12824 if (flag_instrument_function_entry_exit
12825 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
)
12826 /* Do not instrument extern inline functions. */
12827 && !(DECL_DECLARED_INLINE_P (fndecl
)
12828 && DECL_EXTERNAL (fndecl
)
12829 && DECL_DISREGARD_INLINE_LIMITS (fndecl
))
12830 && !flag_instrument_functions_exclude_p (fndecl
))
12835 gimple_seq cleanup
= NULL
, body
= NULL
;
12839 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
12840 call
= gimple_build_call (x
, 1, integer_zero_node
);
12841 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
12842 gimple_call_set_lhs (call
, tmp_var
);
12843 gimplify_seq_add_stmt (&cleanup
, call
);
12844 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT
);
12845 call
= gimple_build_call (x
, 2,
12846 build_fold_addr_expr (current_function_decl
),
12848 gimplify_seq_add_stmt (&cleanup
, call
);
12849 tf
= gimple_build_try (seq
, cleanup
, GIMPLE_TRY_FINALLY
);
12851 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
12852 call
= gimple_build_call (x
, 1, integer_zero_node
);
12853 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
12854 gimple_call_set_lhs (call
, tmp_var
);
12855 gimplify_seq_add_stmt (&body
, call
);
12856 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER
);
12857 call
= gimple_build_call (x
, 2,
12858 build_fold_addr_expr (current_function_decl
),
12860 gimplify_seq_add_stmt (&body
, call
);
12861 gimplify_seq_add_stmt (&body
, tf
);
12862 new_bind
= gimple_build_bind (NULL
, body
, NULL
);
12864 /* Replace the current function body with the body
12865 wrapped in the try/finally TF. */
12867 gimple_seq_add_stmt (&seq
, new_bind
);
12868 gimple_set_body (fndecl
, seq
);
12872 if (sanitize_flags_p (SANITIZE_THREAD
))
12874 gcall
*call
= gimple_build_call_internal (IFN_TSAN_FUNC_EXIT
, 0);
12875 gimple
*tf
= gimple_build_try (seq
, call
, GIMPLE_TRY_FINALLY
);
12876 gbind
*new_bind
= gimple_build_bind (NULL
, tf
, NULL
);
12877 /* Replace the current function body with the body
12878 wrapped in the try/finally TF. */
12880 gimple_seq_add_stmt (&seq
, new_bind
);
12881 gimple_set_body (fndecl
, seq
);
12884 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
12885 cfun
->curr_properties
|= PROP_gimple_any
;
12889 dump_function (TDI_gimple
, fndecl
);
12892 /* Return a dummy expression of type TYPE in order to keep going after an
12896 dummy_object (tree type
)
12898 tree t
= build_int_cst (build_pointer_type (type
), 0);
12899 return build2 (MEM_REF
, type
, t
, t
);
12902 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
12903 builtin function, but a very special sort of operator. */
12905 enum gimplify_status
12906 gimplify_va_arg_expr (tree
*expr_p
, gimple_seq
*pre_p
,
12907 gimple_seq
*post_p ATTRIBUTE_UNUSED
)
12909 tree promoted_type
, have_va_type
;
12910 tree valist
= TREE_OPERAND (*expr_p
, 0);
12911 tree type
= TREE_TYPE (*expr_p
);
12912 tree t
, tag
, aptag
;
12913 location_t loc
= EXPR_LOCATION (*expr_p
);
12915 /* Verify that valist is of the proper type. */
12916 have_va_type
= TREE_TYPE (valist
);
12917 if (have_va_type
== error_mark_node
)
12919 have_va_type
= targetm
.canonical_va_list_type (have_va_type
);
12920 if (have_va_type
== NULL_TREE
12921 && POINTER_TYPE_P (TREE_TYPE (valist
)))
12922 /* Handle 'Case 1: Not an array type' from c-common.c/build_va_arg. */
12924 = targetm
.canonical_va_list_type (TREE_TYPE (TREE_TYPE (valist
)));
12925 gcc_assert (have_va_type
!= NULL_TREE
);
12927 /* Generate a diagnostic for requesting data of a type that cannot
12928 be passed through `...' due to type promotion at the call site. */
12929 if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
12932 static bool gave_help
;
12934 /* Use the expansion point to handle cases such as passing bool (defined
12935 in a system header) through `...'. */
12936 source_location xloc
12937 = expansion_point_location_if_in_system_header (loc
);
12939 /* Unfortunately, this is merely undefined, rather than a constraint
12940 violation, so we cannot make this an error. If this call is never
12941 executed, the program is still strictly conforming. */
12942 warned
= warning_at (xloc
, 0,
12943 "%qT is promoted to %qT when passed through %<...%>",
12944 type
, promoted_type
);
12945 if (!gave_help
&& warned
)
12948 inform (xloc
, "(so you should pass %qT not %qT to %<va_arg%>)",
12949 promoted_type
, type
);
12952 /* We can, however, treat "undefined" any way we please.
12953 Call abort to encourage the user to fix the program. */
12955 inform (xloc
, "if this code is reached, the program will abort");
12956 /* Before the abort, allow the evaluation of the va_list
12957 expression to exit or longjmp. */
12958 gimplify_and_add (valist
, pre_p
);
12959 t
= build_call_expr_loc (loc
,
12960 builtin_decl_implicit (BUILT_IN_TRAP
), 0);
12961 gimplify_and_add (t
, pre_p
);
12963 /* This is dead code, but go ahead and finish so that the
12964 mode of the result comes out right. */
12965 *expr_p
= dummy_object (type
);
12966 return GS_ALL_DONE
;
12969 tag
= build_int_cst (build_pointer_type (type
), 0);
12970 aptag
= build_int_cst (TREE_TYPE (valist
), 0);
12972 *expr_p
= build_call_expr_internal_loc (loc
, IFN_VA_ARG
, type
, 3,
12973 valist
, tag
, aptag
);
12975 /* Clear the tentatively set PROP_gimple_lva, to indicate that IFN_VA_ARG
12976 needs to be expanded. */
12977 cfun
->curr_properties
&= ~PROP_gimple_lva
;
12982 /* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
12984 DST/SRC are the destination and source respectively. You can pass
12985 ungimplified trees in DST or SRC, in which case they will be
12986 converted to a gimple operand if necessary.
12988 This function returns the newly created GIMPLE_ASSIGN tuple. */
12991 gimplify_assign (tree dst
, tree src
, gimple_seq
*seq_p
)
12993 tree t
= build2 (MODIFY_EXPR
, TREE_TYPE (dst
), dst
, src
);
12994 gimplify_and_add (t
, seq_p
);
12996 return gimple_seq_last_stmt (*seq_p
);
13000 gimplify_hasher::hash (const elt_t
*p
)
13003 return iterative_hash_expr (t
, 0);
13007 gimplify_hasher::equal (const elt_t
*p1
, const elt_t
*p2
)
13011 enum tree_code code
= TREE_CODE (t1
);
13013 if (TREE_CODE (t2
) != code
13014 || TREE_TYPE (t1
) != TREE_TYPE (t2
))
13017 if (!operand_equal_p (t1
, t2
, 0))
13020 /* Only allow them to compare equal if they also hash equal; otherwise
13021 results are nondeterminate, and we fail bootstrap comparison. */
13022 gcc_checking_assert (hash (p1
) == hash (p2
));