1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002-2015 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"
29 #include "double-int.h"
37 #include "fold-const.h"
40 #include "hard-reg-set.h"
44 #include "statistics.h"
46 #include "fixed-value.h"
47 #include "insn-config.h"
57 #include "basic-block.h"
58 #include "tree-ssa-alias.h"
59 #include "internal-fn.h"
60 #include "gimple-fold.h"
62 #include "gimple-expr.h"
66 #include "gimple-iterator.h"
67 #include "stringpool.h"
68 #include "stor-layout.h"
69 #include "print-tree.h"
70 #include "tree-iterator.h"
71 #include "tree-inline.h"
72 #include "tree-pretty-print.h"
73 #include "langhooks.h"
75 #include "gimple-ssa.h"
77 #include "plugin-api.h"
81 #include "tree-ssanames.h"
83 #include "diagnostic-core.h"
85 #include "splay-tree.h"
87 #include "gimple-low.h"
89 #include "gomp-constants.h"
91 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
92 #include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
95 enum gimplify_omp_var_data
101 GOVD_FIRSTPRIVATE
= 16,
102 GOVD_LASTPRIVATE
= 32,
106 GOVD_DEBUG_PRIVATE
= 512,
107 GOVD_PRIVATE_OUTER_REF
= 1024,
111 /* Flag for GOVD_MAP: don't copy back. */
112 GOVD_MAP_TO_ONLY
= 8192,
114 GOVD_DATA_SHARE_CLASS
= (GOVD_SHARED
| GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
115 | GOVD_LASTPRIVATE
| GOVD_REDUCTION
| GOVD_LINEAR
125 ORT_COMBINED_PARALLEL
= 3,
130 ORT_TARGET_DATA
= 16,
131 /* Data region with offloading. */
135 /* Gimplify hashtable helper. */
137 struct gimplify_hasher
: typed_free_remove
<elt_t
>
139 typedef elt_t value_type
;
140 typedef elt_t compare_type
;
141 static inline hashval_t
hash (const value_type
*);
142 static inline bool equal (const value_type
*, const compare_type
*);
147 struct gimplify_ctx
*prev_context
;
149 vec
<gbind
*> bind_expr_stack
;
151 gimple_seq conditional_cleanups
;
155 vec
<tree
> case_labels
;
156 /* The formal temporary table. Should this be persistent? */
157 hash_table
<gimplify_hasher
> *temp_htab
;
162 bool allow_rhs_cond_expr
;
163 bool in_cleanup_point_expr
;
166 struct gimplify_omp_ctx
168 struct gimplify_omp_ctx
*outer_context
;
169 splay_tree variables
;
170 hash_set
<tree
> *privatized_types
;
172 enum omp_clause_default_kind default_kind
;
173 enum omp_region_type region_type
;
178 static struct gimplify_ctx
*gimplify_ctxp
;
179 static struct gimplify_omp_ctx
*gimplify_omp_ctxp
;
181 /* Forward declaration. */
182 static enum gimplify_status
gimplify_compound_expr (tree
*, gimple_seq
*, bool);
184 /* Shorter alias name for the above function for use in gimplify.c
188 gimplify_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
190 gimple_seq_add_stmt_without_update (seq_p
, gs
);
193 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
194 NULL, a new sequence is allocated. This function is
195 similar to gimple_seq_add_seq, but does not scan the operands.
196 During gimplification, we need to manipulate statement sequences
197 before the def/use vectors have been constructed. */
200 gimplify_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
202 gimple_stmt_iterator si
;
207 si
= gsi_last (*dst_p
);
208 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
212 /* Pointer to a list of allocated gimplify_ctx structs to be used for pushing
213 and popping gimplify contexts. */
215 static struct gimplify_ctx
*ctx_pool
= NULL
;
217 /* Return a gimplify context struct from the pool. */
219 static inline struct gimplify_ctx
*
222 struct gimplify_ctx
* c
= ctx_pool
;
225 ctx_pool
= c
->prev_context
;
227 c
= XNEW (struct gimplify_ctx
);
229 memset (c
, '\0', sizeof (*c
));
233 /* Put gimplify context C back into the pool. */
236 ctx_free (struct gimplify_ctx
*c
)
238 c
->prev_context
= ctx_pool
;
242 /* Free allocated ctx stack memory. */
245 free_gimplify_stack (void)
247 struct gimplify_ctx
*c
;
249 while ((c
= ctx_pool
))
251 ctx_pool
= c
->prev_context
;
257 /* Set up a context for the gimplifier. */
260 push_gimplify_context (bool in_ssa
, bool rhs_cond_ok
)
262 struct gimplify_ctx
*c
= ctx_alloc ();
264 c
->prev_context
= gimplify_ctxp
;
266 gimplify_ctxp
->into_ssa
= in_ssa
;
267 gimplify_ctxp
->allow_rhs_cond_expr
= rhs_cond_ok
;
270 /* Tear down a context for the gimplifier. If BODY is non-null, then
271 put the temporaries into the outer BIND_EXPR. Otherwise, put them
274 BODY is not a sequence, but the first tuple in a sequence. */
277 pop_gimplify_context (gimple body
)
279 struct gimplify_ctx
*c
= gimplify_ctxp
;
282 && (!c
->bind_expr_stack
.exists ()
283 || c
->bind_expr_stack
.is_empty ()));
284 c
->bind_expr_stack
.release ();
285 gimplify_ctxp
= c
->prev_context
;
288 declare_vars (c
->temps
, body
, false);
290 record_vars (c
->temps
);
297 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
300 gimple_push_bind_expr (gbind
*bind_stmt
)
302 gimplify_ctxp
->bind_expr_stack
.reserve (8);
303 gimplify_ctxp
->bind_expr_stack
.safe_push (bind_stmt
);
306 /* Pop the first element off the stack of bindings. */
309 gimple_pop_bind_expr (void)
311 gimplify_ctxp
->bind_expr_stack
.pop ();
314 /* Return the first element of the stack of bindings. */
317 gimple_current_bind_expr (void)
319 return gimplify_ctxp
->bind_expr_stack
.last ();
322 /* Return the stack of bindings created during gimplification. */
325 gimple_bind_expr_stack (void)
327 return gimplify_ctxp
->bind_expr_stack
;
330 /* Return true iff there is a COND_EXPR between us and the innermost
331 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
334 gimple_conditional_context (void)
336 return gimplify_ctxp
->conditions
> 0;
339 /* Note that we've entered a COND_EXPR. */
342 gimple_push_condition (void)
344 #ifdef ENABLE_GIMPLE_CHECKING
345 if (gimplify_ctxp
->conditions
== 0)
346 gcc_assert (gimple_seq_empty_p (gimplify_ctxp
->conditional_cleanups
));
348 ++(gimplify_ctxp
->conditions
);
351 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
352 now, add any conditional cleanups we've seen to the prequeue. */
355 gimple_pop_condition (gimple_seq
*pre_p
)
357 int conds
= --(gimplify_ctxp
->conditions
);
359 gcc_assert (conds
>= 0);
362 gimplify_seq_add_seq (pre_p
, gimplify_ctxp
->conditional_cleanups
);
363 gimplify_ctxp
->conditional_cleanups
= NULL
;
367 /* A stable comparison routine for use with splay trees and DECLs. */
370 splay_tree_compare_decl_uid (splay_tree_key xa
, splay_tree_key xb
)
375 return DECL_UID (a
) - DECL_UID (b
);
378 /* Create a new omp construct that deals with variable remapping. */
380 static struct gimplify_omp_ctx
*
381 new_omp_context (enum omp_region_type region_type
)
383 struct gimplify_omp_ctx
*c
;
385 c
= XCNEW (struct gimplify_omp_ctx
);
386 c
->outer_context
= gimplify_omp_ctxp
;
387 c
->variables
= splay_tree_new (splay_tree_compare_decl_uid
, 0, 0);
388 c
->privatized_types
= new hash_set
<tree
>;
389 c
->location
= input_location
;
390 c
->region_type
= region_type
;
391 if ((region_type
& ORT_TASK
) == 0)
392 c
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
394 c
->default_kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
399 /* Destroy an omp construct that deals with variable remapping. */
402 delete_omp_context (struct gimplify_omp_ctx
*c
)
404 splay_tree_delete (c
->variables
);
405 delete c
->privatized_types
;
409 static void omp_add_variable (struct gimplify_omp_ctx
*, tree
, unsigned int);
410 static bool omp_notice_variable (struct gimplify_omp_ctx
*, tree
, bool);
412 /* Both gimplify the statement T and append it to *SEQ_P. This function
413 behaves exactly as gimplify_stmt, but you don't have to pass T as a
417 gimplify_and_add (tree t
, gimple_seq
*seq_p
)
419 gimplify_stmt (&t
, seq_p
);
422 /* Gimplify statement T into sequence *SEQ_P, and return the first
423 tuple in the sequence of generated tuples for this statement.
424 Return NULL if gimplifying T produced no tuples. */
427 gimplify_and_return_first (tree t
, gimple_seq
*seq_p
)
429 gimple_stmt_iterator last
= gsi_last (*seq_p
);
431 gimplify_and_add (t
, seq_p
);
433 if (!gsi_end_p (last
))
436 return gsi_stmt (last
);
439 return gimple_seq_first_stmt (*seq_p
);
442 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
443 LHS, or for a call argument. */
446 is_gimple_mem_rhs (tree t
)
448 /* If we're dealing with a renamable type, either source or dest must be
449 a renamed variable. */
450 if (is_gimple_reg_type (TREE_TYPE (t
)))
451 return is_gimple_val (t
);
453 return is_gimple_val (t
) || is_gimple_lvalue (t
);
456 /* Return true if T is a CALL_EXPR or an expression that can be
457 assigned to a temporary. Note that this predicate should only be
458 used during gimplification. See the rationale for this in
459 gimplify_modify_expr. */
462 is_gimple_reg_rhs_or_call (tree t
)
464 return (get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
465 || TREE_CODE (t
) == CALL_EXPR
);
468 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
469 this predicate should only be used during gimplification. See the
470 rationale for this in gimplify_modify_expr. */
473 is_gimple_mem_rhs_or_call (tree t
)
475 /* If we're dealing with a renamable type, either source or dest must be
476 a renamed variable. */
477 if (is_gimple_reg_type (TREE_TYPE (t
)))
478 return is_gimple_val (t
);
480 return (is_gimple_val (t
) || is_gimple_lvalue (t
)
481 || TREE_CODE (t
) == CALL_EXPR
);
484 /* Create a temporary with a name derived from VAL. Subroutine of
485 lookup_tmp_var; nobody else should call this function. */
488 create_tmp_from_val (tree val
)
490 /* Drop all qualifiers and address-space information from the value type. */
491 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (val
));
492 tree var
= create_tmp_var (type
, get_name (val
));
493 if (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
494 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
495 DECL_GIMPLE_REG_P (var
) = 1;
499 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
500 an existing expression temporary. */
503 lookup_tmp_var (tree val
, bool is_formal
)
507 /* If not optimizing, never really reuse a temporary. local-alloc
508 won't allocate any variable that is used in more than one basic
509 block, which means it will go into memory, causing much extra
510 work in reload and final and poorer code generation, outweighing
511 the extra memory allocation here. */
512 if (!optimize
|| !is_formal
|| TREE_SIDE_EFFECTS (val
))
513 ret
= create_tmp_from_val (val
);
520 if (!gimplify_ctxp
->temp_htab
)
521 gimplify_ctxp
->temp_htab
= new hash_table
<gimplify_hasher
> (1000);
522 slot
= gimplify_ctxp
->temp_htab
->find_slot (&elt
, INSERT
);
525 elt_p
= XNEW (elt_t
);
527 elt_p
->temp
= ret
= create_tmp_from_val (val
);
540 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
543 internal_get_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
548 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
549 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
550 gimplify_expr (&val
, pre_p
, post_p
, is_gimple_reg_rhs_or_call
,
553 if (gimplify_ctxp
->into_ssa
554 && is_gimple_reg_type (TREE_TYPE (val
)))
555 t
= make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val
)));
557 t
= lookup_tmp_var (val
, is_formal
);
559 mod
= build2 (INIT_EXPR
, TREE_TYPE (t
), t
, unshare_expr (val
));
561 SET_EXPR_LOCATION (mod
, EXPR_LOC_OR_LOC (val
, input_location
));
563 /* gimplify_modify_expr might want to reduce this further. */
564 gimplify_and_add (mod
, pre_p
);
570 /* Return a formal temporary variable initialized with VAL. PRE_P is as
571 in gimplify_expr. Only use this function if:
573 1) The value of the unfactored expression represented by VAL will not
574 change between the initialization and use of the temporary, and
575 2) The temporary will not be otherwise modified.
577 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
578 and #2 means it is inappropriate for && temps.
580 For other cases, use get_initialized_tmp_var instead. */
583 get_formal_tmp_var (tree val
, gimple_seq
*pre_p
)
585 return internal_get_tmp_var (val
, pre_p
, NULL
, true);
588 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
589 are as in gimplify_expr. */
592 get_initialized_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
594 return internal_get_tmp_var (val
, pre_p
, post_p
, false);
597 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
598 generate debug info for them; otherwise don't. */
601 declare_vars (tree vars
, gimple gs
, bool debug_info
)
608 gbind
*scope
= as_a
<gbind
*> (gs
);
610 temps
= nreverse (last
);
612 block
= gimple_bind_block (scope
);
613 gcc_assert (!block
|| TREE_CODE (block
) == BLOCK
);
614 if (!block
|| !debug_info
)
616 DECL_CHAIN (last
) = gimple_bind_vars (scope
);
617 gimple_bind_set_vars (scope
, temps
);
621 /* We need to attach the nodes both to the BIND_EXPR and to its
622 associated BLOCK for debugging purposes. The key point here
623 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
624 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
625 if (BLOCK_VARS (block
))
626 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), temps
);
629 gimple_bind_set_vars (scope
,
630 chainon (gimple_bind_vars (scope
), temps
));
631 BLOCK_VARS (block
) = temps
;
637 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
638 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
639 no such upper bound can be obtained. */
642 force_constant_size (tree var
)
644 /* The only attempt we make is by querying the maximum size of objects
645 of the variable's type. */
647 HOST_WIDE_INT max_size
;
649 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
651 max_size
= max_int_size_in_bytes (TREE_TYPE (var
));
653 gcc_assert (max_size
>= 0);
656 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var
)), max_size
);
658 = build_int_cst (TREE_TYPE (DECL_SIZE (var
)), max_size
* BITS_PER_UNIT
);
661 /* Push the temporary variable TMP into the current binding. */
664 gimple_add_tmp_var_fn (struct function
*fn
, tree tmp
)
666 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
668 /* Later processing assumes that the object size is constant, which might
669 not be true at this point. Force the use of a constant upper bound in
671 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (tmp
)))
672 force_constant_size (tmp
);
674 DECL_CONTEXT (tmp
) = fn
->decl
;
675 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
677 record_vars_into (tmp
, fn
->decl
);
680 /* Push the temporary variable TMP into the current binding. */
683 gimple_add_tmp_var (tree tmp
)
685 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
687 /* Later processing assumes that the object size is constant, which might
688 not be true at this point. Force the use of a constant upper bound in
690 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (tmp
)))
691 force_constant_size (tmp
);
693 DECL_CONTEXT (tmp
) = current_function_decl
;
694 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
698 DECL_CHAIN (tmp
) = gimplify_ctxp
->temps
;
699 gimplify_ctxp
->temps
= tmp
;
701 /* Mark temporaries local within the nearest enclosing parallel. */
702 if (gimplify_omp_ctxp
)
704 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
706 && (ctx
->region_type
== ORT_WORKSHARE
707 || ctx
->region_type
== ORT_SIMD
))
708 ctx
= ctx
->outer_context
;
710 omp_add_variable (ctx
, tmp
, GOVD_LOCAL
| GOVD_SEEN
);
719 /* This case is for nested functions. We need to expose the locals
721 body_seq
= gimple_body (current_function_decl
);
722 declare_vars (tmp
, gimple_seq_first_stmt (body_seq
), false);
728 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
729 nodes that are referenced more than once in GENERIC functions. This is
730 necessary because gimplification (translation into GIMPLE) is performed
731 by modifying tree nodes in-place, so gimplication of a shared node in a
732 first context could generate an invalid GIMPLE form in a second context.
734 This is achieved with a simple mark/copy/unmark algorithm that walks the
735 GENERIC representation top-down, marks nodes with TREE_VISITED the first
736 time it encounters them, duplicates them if they already have TREE_VISITED
737 set, and finally removes the TREE_VISITED marks it has set.
739 The algorithm works only at the function level, i.e. it generates a GENERIC
740 representation of a function with no nodes shared within the function when
741 passed a GENERIC function (except for nodes that are allowed to be shared).
743 At the global level, it is also necessary to unshare tree nodes that are
744 referenced in more than one function, for the same aforementioned reason.
745 This requires some cooperation from the front-end. There are 2 strategies:
747 1. Manual unsharing. The front-end needs to call unshare_expr on every
748 expression that might end up being shared across functions.
750 2. Deep unsharing. This is an extension of regular unsharing. Instead
751 of calling unshare_expr on expressions that might be shared across
752 functions, the front-end pre-marks them with TREE_VISITED. This will
753 ensure that they are unshared on the first reference within functions
754 when the regular unsharing algorithm runs. The counterpart is that
755 this algorithm must look deeper than for manual unsharing, which is
756 specified by LANG_HOOKS_DEEP_UNSHARING.
758 If there are only few specific cases of node sharing across functions, it is
759 probably easier for a front-end to unshare the expressions manually. On the
760 contrary, if the expressions generated at the global level are as widespread
761 as expressions generated within functions, deep unsharing is very likely the
764 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
765 These nodes model computations that must be done once. If we were to
766 unshare something like SAVE_EXPR(i++), the gimplification process would
767 create wrong code. However, if DATA is non-null, it must hold a pointer
768 set that is used to unshare the subtrees of these nodes. */
771 mostly_copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
774 enum tree_code code
= TREE_CODE (t
);
776 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
777 copy their subtrees if we can make sure to do it only once. */
778 if (code
== SAVE_EXPR
|| code
== TARGET_EXPR
|| code
== BIND_EXPR
)
780 if (data
&& !((hash_set
<tree
> *)data
)->add (t
))
786 /* Stop at types, decls, constants like copy_tree_r. */
787 else if (TREE_CODE_CLASS (code
) == tcc_type
788 || TREE_CODE_CLASS (code
) == tcc_declaration
789 || TREE_CODE_CLASS (code
) == tcc_constant
790 /* We can't do anything sensible with a BLOCK used as an
791 expression, but we also can't just die when we see it
792 because of non-expression uses. So we avert our eyes
793 and cross our fingers. Silly Java. */
797 /* Cope with the statement expression extension. */
798 else if (code
== STATEMENT_LIST
)
801 /* Leave the bulk of the work to copy_tree_r itself. */
803 copy_tree_r (tp
, walk_subtrees
, NULL
);
808 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
809 If *TP has been visited already, then *TP is deeply copied by calling
810 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
813 copy_if_shared_r (tree
*tp
, int *walk_subtrees
, void *data
)
816 enum tree_code code
= TREE_CODE (t
);
818 /* Skip types, decls, and constants. But we do want to look at their
819 types and the bounds of types. Mark them as visited so we properly
820 unmark their subtrees on the unmark pass. If we've already seen them,
821 don't look down further. */
822 if (TREE_CODE_CLASS (code
) == tcc_type
823 || TREE_CODE_CLASS (code
) == tcc_declaration
824 || TREE_CODE_CLASS (code
) == tcc_constant
)
826 if (TREE_VISITED (t
))
829 TREE_VISITED (t
) = 1;
832 /* If this node has been visited already, unshare it and don't look
834 else if (TREE_VISITED (t
))
836 walk_tree (tp
, mostly_copy_tree_r
, data
, NULL
);
840 /* Otherwise, mark the node as visited and keep looking. */
842 TREE_VISITED (t
) = 1;
847 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
848 copy_if_shared_r callback unmodified. */
851 copy_if_shared (tree
*tp
, void *data
)
853 walk_tree (tp
, copy_if_shared_r
, data
, NULL
);
856 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
857 any nested functions. */
860 unshare_body (tree fndecl
)
862 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
863 /* If the language requires deep unsharing, we need a pointer set to make
864 sure we don't repeatedly unshare subtrees of unshareable nodes. */
865 hash_set
<tree
> *visited
866 = lang_hooks
.deep_unsharing
? new hash_set
<tree
> : NULL
;
868 copy_if_shared (&DECL_SAVED_TREE (fndecl
), visited
);
869 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl
)), visited
);
870 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)), visited
);
875 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
876 unshare_body (cgn
->decl
);
879 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
880 Subtrees are walked until the first unvisited node is encountered. */
883 unmark_visited_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
887 /* If this node has been visited, unmark it and keep looking. */
888 if (TREE_VISITED (t
))
889 TREE_VISITED (t
) = 0;
891 /* Otherwise, don't look any deeper. */
898 /* Unmark the visited trees rooted at *TP. */
901 unmark_visited (tree
*tp
)
903 walk_tree (tp
, unmark_visited_r
, NULL
, NULL
);
906 /* Likewise, but mark all trees as not visited. */
909 unvisit_body (tree fndecl
)
911 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
913 unmark_visited (&DECL_SAVED_TREE (fndecl
));
914 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl
)));
915 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)));
918 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
919 unvisit_body (cgn
->decl
);
922 /* Unconditionally make an unshared copy of EXPR. This is used when using
923 stored expressions which span multiple functions, such as BINFO_VTABLE,
924 as the normal unsharing process can't tell that they're shared. */
927 unshare_expr (tree expr
)
929 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
933 /* Worker for unshare_expr_without_location. */
936 prune_expr_location (tree
*tp
, int *walk_subtrees
, void *)
939 SET_EXPR_LOCATION (*tp
, UNKNOWN_LOCATION
);
945 /* Similar to unshare_expr but also prune all expression locations
949 unshare_expr_without_location (tree expr
)
951 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
953 walk_tree (&expr
, prune_expr_location
, NULL
, NULL
);
957 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
958 contain statements and have a value. Assign its value to a temporary
959 and give it void_type_node. Return the temporary, or NULL_TREE if
960 WRAPPER was already void. */
963 voidify_wrapper_expr (tree wrapper
, tree temp
)
965 tree type
= TREE_TYPE (wrapper
);
966 if (type
&& !VOID_TYPE_P (type
))
970 /* Set p to point to the body of the wrapper. Loop until we find
971 something that isn't a wrapper. */
972 for (p
= &wrapper
; p
&& *p
; )
974 switch (TREE_CODE (*p
))
977 TREE_SIDE_EFFECTS (*p
) = 1;
978 TREE_TYPE (*p
) = void_type_node
;
979 /* For a BIND_EXPR, the body is operand 1. */
980 p
= &BIND_EXPR_BODY (*p
);
983 case CLEANUP_POINT_EXPR
:
984 case TRY_FINALLY_EXPR
:
986 TREE_SIDE_EFFECTS (*p
) = 1;
987 TREE_TYPE (*p
) = void_type_node
;
988 p
= &TREE_OPERAND (*p
, 0);
993 tree_stmt_iterator i
= tsi_last (*p
);
994 TREE_SIDE_EFFECTS (*p
) = 1;
995 TREE_TYPE (*p
) = void_type_node
;
996 p
= tsi_end_p (i
) ? NULL
: tsi_stmt_ptr (i
);
1001 /* Advance to the last statement. Set all container types to
1003 for (; TREE_CODE (*p
) == COMPOUND_EXPR
; p
= &TREE_OPERAND (*p
, 1))
1005 TREE_SIDE_EFFECTS (*p
) = 1;
1006 TREE_TYPE (*p
) = void_type_node
;
1010 case TRANSACTION_EXPR
:
1011 TREE_SIDE_EFFECTS (*p
) = 1;
1012 TREE_TYPE (*p
) = void_type_node
;
1013 p
= &TRANSACTION_EXPR_BODY (*p
);
1017 /* Assume that any tree upon which voidify_wrapper_expr is
1018 directly called is a wrapper, and that its body is op0. */
1021 TREE_SIDE_EFFECTS (*p
) = 1;
1022 TREE_TYPE (*p
) = void_type_node
;
1023 p
= &TREE_OPERAND (*p
, 0);
1031 if (p
== NULL
|| IS_EMPTY_STMT (*p
))
1035 /* The wrapper is on the RHS of an assignment that we're pushing
1037 gcc_assert (TREE_CODE (temp
) == INIT_EXPR
1038 || TREE_CODE (temp
) == MODIFY_EXPR
);
1039 TREE_OPERAND (temp
, 1) = *p
;
1044 temp
= create_tmp_var (type
, "retval");
1045 *p
= build2 (INIT_EXPR
, type
, temp
, *p
);
1054 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1055 a temporary through which they communicate. */
1058 build_stack_save_restore (gcall
**save
, gcall
**restore
)
1062 *save
= gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE
), 0);
1063 tmp_var
= create_tmp_var (ptr_type_node
, "saved_stack");
1064 gimple_call_set_lhs (*save
, tmp_var
);
1067 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE
),
1071 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1073 static enum gimplify_status
1074 gimplify_bind_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1076 tree bind_expr
= *expr_p
;
1077 bool old_save_stack
= gimplify_ctxp
->save_stack
;
1080 gimple_seq body
, cleanup
;
1082 location_t start_locus
= 0, end_locus
= 0;
1084 tree temp
= voidify_wrapper_expr (bind_expr
, NULL
);
1086 /* Mark variables seen in this bind expr. */
1087 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1089 if (TREE_CODE (t
) == VAR_DECL
)
1091 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1093 /* Mark variable as local. */
1094 if (ctx
&& !DECL_EXTERNAL (t
)
1095 && (! DECL_SEEN_IN_BIND_EXPR_P (t
)
1096 || splay_tree_lookup (ctx
->variables
,
1097 (splay_tree_key
) t
) == NULL
))
1099 if (ctx
->region_type
== ORT_SIMD
1100 && TREE_ADDRESSABLE (t
)
1101 && !TREE_STATIC (t
))
1102 omp_add_variable (ctx
, t
, GOVD_PRIVATE
| GOVD_SEEN
);
1104 omp_add_variable (ctx
, t
, GOVD_LOCAL
| GOVD_SEEN
);
1107 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
1109 if (DECL_HARD_REGISTER (t
) && !is_global_var (t
) && cfun
)
1110 cfun
->has_local_explicit_reg_vars
= true;
1113 /* Preliminarily mark non-addressed complex variables as eligible
1114 for promotion to gimple registers. We'll transform their uses
1116 if ((TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
1117 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1118 && !TREE_THIS_VOLATILE (t
)
1119 && (TREE_CODE (t
) == VAR_DECL
&& !DECL_HARD_REGISTER (t
))
1120 && !needs_to_live_in_memory (t
))
1121 DECL_GIMPLE_REG_P (t
) = 1;
1124 bind_stmt
= gimple_build_bind (BIND_EXPR_VARS (bind_expr
), NULL
,
1125 BIND_EXPR_BLOCK (bind_expr
));
1126 gimple_push_bind_expr (bind_stmt
);
1128 gimplify_ctxp
->save_stack
= false;
1130 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1132 gimplify_stmt (&BIND_EXPR_BODY (bind_expr
), &body
);
1133 gimple_bind_set_body (bind_stmt
, body
);
1135 /* Source location wise, the cleanup code (stack_restore and clobbers)
1136 belongs to the end of the block, so propagate what we have. The
1137 stack_save operation belongs to the beginning of block, which we can
1138 infer from the bind_expr directly if the block has no explicit
1140 if (BIND_EXPR_BLOCK (bind_expr
))
1142 end_locus
= BLOCK_SOURCE_END_LOCATION (BIND_EXPR_BLOCK (bind_expr
));
1143 start_locus
= BLOCK_SOURCE_LOCATION (BIND_EXPR_BLOCK (bind_expr
));
1145 if (start_locus
== 0)
1146 start_locus
= EXPR_LOCATION (bind_expr
);
1150 if (gimplify_ctxp
->save_stack
)
1152 gcall
*stack_restore
;
1154 /* Save stack on entry and restore it on exit. Add a try_finally
1155 block to achieve this. */
1156 build_stack_save_restore (&stack_save
, &stack_restore
);
1158 gimple_set_location (stack_save
, start_locus
);
1159 gimple_set_location (stack_restore
, end_locus
);
1161 gimplify_seq_add_stmt (&cleanup
, stack_restore
);
1164 /* Add clobbers for all variables that go out of scope. */
1165 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1167 if (TREE_CODE (t
) == VAR_DECL
1168 && !is_global_var (t
)
1169 && DECL_CONTEXT (t
) == current_function_decl
1170 && !DECL_HARD_REGISTER (t
)
1171 && !TREE_THIS_VOLATILE (t
)
1172 && !DECL_HAS_VALUE_EXPR_P (t
)
1173 /* Only care for variables that have to be in memory. Others
1174 will be rewritten into SSA names, hence moved to the top-level. */
1175 && !is_gimple_reg (t
)
1176 && flag_stack_reuse
!= SR_NONE
)
1178 tree clobber
= build_constructor (TREE_TYPE (t
), NULL
);
1179 gimple clobber_stmt
;
1180 TREE_THIS_VOLATILE (clobber
) = 1;
1181 clobber_stmt
= gimple_build_assign (t
, clobber
);
1182 gimple_set_location (clobber_stmt
, end_locus
);
1183 gimplify_seq_add_stmt (&cleanup
, clobber_stmt
);
1190 gimple_seq new_body
;
1193 gs
= gimple_build_try (gimple_bind_body (bind_stmt
), cleanup
,
1194 GIMPLE_TRY_FINALLY
);
1197 gimplify_seq_add_stmt (&new_body
, stack_save
);
1198 gimplify_seq_add_stmt (&new_body
, gs
);
1199 gimple_bind_set_body (bind_stmt
, new_body
);
1202 gimplify_ctxp
->save_stack
= old_save_stack
;
1203 gimple_pop_bind_expr ();
1205 gimplify_seq_add_stmt (pre_p
, bind_stmt
);
1213 *expr_p
= NULL_TREE
;
1217 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1218 GIMPLE value, it is assigned to a new temporary and the statement is
1219 re-written to return the temporary.
1221 PRE_P points to the sequence where side effects that must happen before
1222 STMT should be stored. */
1224 static enum gimplify_status
1225 gimplify_return_expr (tree stmt
, gimple_seq
*pre_p
)
1228 tree ret_expr
= TREE_OPERAND (stmt
, 0);
1229 tree result_decl
, result
;
1231 if (ret_expr
== error_mark_node
)
1234 /* Implicit _Cilk_sync must be inserted right before any return statement
1235 if there is a _Cilk_spawn in the function. If the user has provided a
1236 _Cilk_sync, the optimizer should remove this duplicate one. */
1237 if (fn_contains_cilk_spawn_p (cfun
))
1239 tree impl_sync
= build0 (CILK_SYNC_STMT
, void_type_node
);
1240 gimplify_and_add (impl_sync
, pre_p
);
1244 || TREE_CODE (ret_expr
) == RESULT_DECL
1245 || ret_expr
== error_mark_node
)
1247 greturn
*ret
= gimple_build_return (ret_expr
);
1248 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1249 gimplify_seq_add_stmt (pre_p
, ret
);
1253 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1254 result_decl
= NULL_TREE
;
1257 result_decl
= TREE_OPERAND (ret_expr
, 0);
1259 /* See through a return by reference. */
1260 if (TREE_CODE (result_decl
) == INDIRECT_REF
)
1261 result_decl
= TREE_OPERAND (result_decl
, 0);
1263 gcc_assert ((TREE_CODE (ret_expr
) == MODIFY_EXPR
1264 || TREE_CODE (ret_expr
) == INIT_EXPR
)
1265 && TREE_CODE (result_decl
) == RESULT_DECL
);
1268 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1269 Recall that aggregate_value_p is FALSE for any aggregate type that is
1270 returned in registers. If we're returning values in registers, then
1271 we don't want to extend the lifetime of the RESULT_DECL, particularly
1272 across another call. In addition, for those aggregates for which
1273 hard_function_value generates a PARALLEL, we'll die during normal
1274 expansion of structure assignments; there's special code in expand_return
1275 to handle this case that does not exist in expand_expr. */
1278 else if (aggregate_value_p (result_decl
, TREE_TYPE (current_function_decl
)))
1280 if (TREE_CODE (DECL_SIZE (result_decl
)) != INTEGER_CST
)
1282 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl
)))
1283 gimplify_type_sizes (TREE_TYPE (result_decl
), pre_p
);
1284 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1285 should be effectively allocated by the caller, i.e. all calls to
1286 this function must be subject to the Return Slot Optimization. */
1287 gimplify_one_sizepos (&DECL_SIZE (result_decl
), pre_p
);
1288 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl
), pre_p
);
1290 result
= result_decl
;
1292 else if (gimplify_ctxp
->return_temp
)
1293 result
= gimplify_ctxp
->return_temp
;
1296 result
= create_tmp_reg (TREE_TYPE (result_decl
));
1298 /* ??? With complex control flow (usually involving abnormal edges),
1299 we can wind up warning about an uninitialized value for this. Due
1300 to how this variable is constructed and initialized, this is never
1301 true. Give up and never warn. */
1302 TREE_NO_WARNING (result
) = 1;
1304 gimplify_ctxp
->return_temp
= result
;
1307 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1308 Then gimplify the whole thing. */
1309 if (result
!= result_decl
)
1310 TREE_OPERAND (ret_expr
, 0) = result
;
1312 gimplify_and_add (TREE_OPERAND (stmt
, 0), pre_p
);
1314 ret
= gimple_build_return (result
);
1315 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1316 gimplify_seq_add_stmt (pre_p
, ret
);
1321 /* Gimplify a variable-length array DECL. */
1324 gimplify_vla_decl (tree decl
, gimple_seq
*seq_p
)
1326 /* This is a variable-sized decl. Simplify its size and mark it
1327 for deferred expansion. */
1328 tree t
, addr
, ptr_type
;
1330 gimplify_one_sizepos (&DECL_SIZE (decl
), seq_p
);
1331 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl
), seq_p
);
1333 /* Don't mess with a DECL_VALUE_EXPR set by the front-end. */
1334 if (DECL_HAS_VALUE_EXPR_P (decl
))
1337 /* All occurrences of this decl in final gimplified code will be
1338 replaced by indirection. Setting DECL_VALUE_EXPR does two
1339 things: First, it lets the rest of the gimplifier know what
1340 replacement to use. Second, it lets the debug info know
1341 where to find the value. */
1342 ptr_type
= build_pointer_type (TREE_TYPE (decl
));
1343 addr
= create_tmp_var (ptr_type
, get_name (decl
));
1344 DECL_IGNORED_P (addr
) = 0;
1345 t
= build_fold_indirect_ref (addr
);
1346 TREE_THIS_NOTRAP (t
) = 1;
1347 SET_DECL_VALUE_EXPR (decl
, t
);
1348 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1350 t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
1351 t
= build_call_expr (t
, 2, DECL_SIZE_UNIT (decl
),
1352 size_int (DECL_ALIGN (decl
)));
1353 /* The call has been built for a variable-sized object. */
1354 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
1355 t
= fold_convert (ptr_type
, t
);
1356 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
1358 gimplify_and_add (t
, seq_p
);
1360 /* Indicate that we need to restore the stack level when the
1361 enclosing BIND_EXPR is exited. */
1362 gimplify_ctxp
->save_stack
= true;
1365 /* A helper function to be called via walk_tree. Mark all labels under *TP
1366 as being forced. To be called for DECL_INITIAL of static variables. */
1369 force_labels_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1373 if (TREE_CODE (*tp
) == LABEL_DECL
)
1374 FORCED_LABEL (*tp
) = 1;
1379 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1380 and initialization explicit. */
1382 static enum gimplify_status
1383 gimplify_decl_expr (tree
*stmt_p
, gimple_seq
*seq_p
)
1385 tree stmt
= *stmt_p
;
1386 tree decl
= DECL_EXPR_DECL (stmt
);
1388 *stmt_p
= NULL_TREE
;
1390 if (TREE_TYPE (decl
) == error_mark_node
)
1393 if ((TREE_CODE (decl
) == TYPE_DECL
1394 || TREE_CODE (decl
) == VAR_DECL
)
1395 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl
)))
1396 gimplify_type_sizes (TREE_TYPE (decl
), seq_p
);
1398 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1399 in case its size expressions contain problematic nodes like CALL_EXPR. */
1400 if (TREE_CODE (decl
) == TYPE_DECL
1401 && DECL_ORIGINAL_TYPE (decl
)
1402 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl
)))
1403 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl
), seq_p
);
1405 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1407 tree init
= DECL_INITIAL (decl
);
1409 if (TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1410 || (!TREE_STATIC (decl
)
1411 && flag_stack_check
== GENERIC_STACK_CHECK
1412 && compare_tree_int (DECL_SIZE_UNIT (decl
),
1413 STACK_CHECK_MAX_VAR_SIZE
) > 0))
1414 gimplify_vla_decl (decl
, seq_p
);
1416 /* Some front ends do not explicitly declare all anonymous
1417 artificial variables. We compensate here by declaring the
1418 variables, though it would be better if the front ends would
1419 explicitly declare them. */
1420 if (!DECL_SEEN_IN_BIND_EXPR_P (decl
)
1421 && DECL_ARTIFICIAL (decl
) && DECL_NAME (decl
) == NULL_TREE
)
1422 gimple_add_tmp_var (decl
);
1424 if (init
&& init
!= error_mark_node
)
1426 if (!TREE_STATIC (decl
))
1428 DECL_INITIAL (decl
) = NULL_TREE
;
1429 init
= build2 (INIT_EXPR
, void_type_node
, decl
, init
);
1430 gimplify_and_add (init
, seq_p
);
1434 /* We must still examine initializers for static variables
1435 as they may contain a label address. */
1436 walk_tree (&init
, force_labels_r
, NULL
, NULL
);
1443 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1444 and replacing the LOOP_EXPR with goto, but if the loop contains an
1445 EXIT_EXPR, we need to append a label for it to jump to. */
1447 static enum gimplify_status
1448 gimplify_loop_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1450 tree saved_label
= gimplify_ctxp
->exit_label
;
1451 tree start_label
= create_artificial_label (UNKNOWN_LOCATION
);
1453 gimplify_seq_add_stmt (pre_p
, gimple_build_label (start_label
));
1455 gimplify_ctxp
->exit_label
= NULL_TREE
;
1457 gimplify_and_add (LOOP_EXPR_BODY (*expr_p
), pre_p
);
1459 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (start_label
));
1461 if (gimplify_ctxp
->exit_label
)
1462 gimplify_seq_add_stmt (pre_p
,
1463 gimple_build_label (gimplify_ctxp
->exit_label
));
1465 gimplify_ctxp
->exit_label
= saved_label
;
1471 /* Gimplify a statement list onto a sequence. These may be created either
1472 by an enlightened front-end, or by shortcut_cond_expr. */
1474 static enum gimplify_status
1475 gimplify_statement_list (tree
*expr_p
, gimple_seq
*pre_p
)
1477 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
1479 tree_stmt_iterator i
= tsi_start (*expr_p
);
1481 while (!tsi_end_p (i
))
1483 gimplify_stmt (tsi_stmt_ptr (i
), pre_p
);
1497 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
1500 static enum gimplify_status
1501 gimplify_switch_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1503 tree switch_expr
= *expr_p
;
1504 gimple_seq switch_body_seq
= NULL
;
1505 enum gimplify_status ret
;
1506 tree index_type
= TREE_TYPE (switch_expr
);
1507 if (index_type
== NULL_TREE
)
1508 index_type
= TREE_TYPE (SWITCH_COND (switch_expr
));
1510 ret
= gimplify_expr (&SWITCH_COND (switch_expr
), pre_p
, NULL
, is_gimple_val
,
1512 if (ret
== GS_ERROR
|| ret
== GS_UNHANDLED
)
1515 if (SWITCH_BODY (switch_expr
))
1518 vec
<tree
> saved_labels
;
1519 tree default_case
= NULL_TREE
;
1520 gswitch
*switch_stmt
;
1522 /* If someone can be bothered to fill in the labels, they can
1523 be bothered to null out the body too. */
1524 gcc_assert (!SWITCH_LABELS (switch_expr
));
1526 /* Save old labels, get new ones from body, then restore the old
1527 labels. Save all the things from the switch body to append after. */
1528 saved_labels
= gimplify_ctxp
->case_labels
;
1529 gimplify_ctxp
->case_labels
.create (8);
1531 gimplify_stmt (&SWITCH_BODY (switch_expr
), &switch_body_seq
);
1532 labels
= gimplify_ctxp
->case_labels
;
1533 gimplify_ctxp
->case_labels
= saved_labels
;
1535 preprocess_case_label_vec_for_gimple (labels
, index_type
,
1540 glabel
*new_default
;
1543 = build_case_label (NULL_TREE
, NULL_TREE
,
1544 create_artificial_label (UNKNOWN_LOCATION
));
1545 new_default
= gimple_build_label (CASE_LABEL (default_case
));
1546 gimplify_seq_add_stmt (&switch_body_seq
, new_default
);
1549 switch_stmt
= gimple_build_switch (SWITCH_COND (switch_expr
),
1550 default_case
, labels
);
1551 gimplify_seq_add_stmt (pre_p
, switch_stmt
);
1552 gimplify_seq_add_seq (pre_p
, switch_body_seq
);
1556 gcc_assert (SWITCH_LABELS (switch_expr
));
1561 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
1563 static enum gimplify_status
1564 gimplify_case_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1566 struct gimplify_ctx
*ctxp
;
1569 /* Invalid programs can play Duff's Device type games with, for example,
1570 #pragma omp parallel. At least in the C front end, we don't
1571 detect such invalid branches until after gimplification, in the
1572 diagnose_omp_blocks pass. */
1573 for (ctxp
= gimplify_ctxp
; ; ctxp
= ctxp
->prev_context
)
1574 if (ctxp
->case_labels
.exists ())
1577 label_stmt
= gimple_build_label (CASE_LABEL (*expr_p
));
1578 ctxp
->case_labels
.safe_push (*expr_p
);
1579 gimplify_seq_add_stmt (pre_p
, label_stmt
);
1584 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1588 build_and_jump (tree
*label_p
)
1590 if (label_p
== NULL
)
1591 /* If there's nowhere to jump, just fall through. */
1594 if (*label_p
== NULL_TREE
)
1596 tree label
= create_artificial_label (UNKNOWN_LOCATION
);
1600 return build1 (GOTO_EXPR
, void_type_node
, *label_p
);
1603 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1604 This also involves building a label to jump to and communicating it to
1605 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1607 static enum gimplify_status
1608 gimplify_exit_expr (tree
*expr_p
)
1610 tree cond
= TREE_OPERAND (*expr_p
, 0);
1613 expr
= build_and_jump (&gimplify_ctxp
->exit_label
);
1614 expr
= build3 (COND_EXPR
, void_type_node
, cond
, expr
, NULL_TREE
);
1620 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1621 different from its canonical type, wrap the whole thing inside a
1622 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1625 The canonical type of a COMPONENT_REF is the type of the field being
1626 referenced--unless the field is a bit-field which can be read directly
1627 in a smaller mode, in which case the canonical type is the
1628 sign-appropriate type corresponding to that mode. */
1631 canonicalize_component_ref (tree
*expr_p
)
1633 tree expr
= *expr_p
;
1636 gcc_assert (TREE_CODE (expr
) == COMPONENT_REF
);
1638 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
1639 type
= TREE_TYPE (get_unwidened (expr
, NULL_TREE
));
1641 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
1643 /* One could argue that all the stuff below is not necessary for
1644 the non-bitfield case and declare it a FE error if type
1645 adjustment would be needed. */
1646 if (TREE_TYPE (expr
) != type
)
1648 #ifdef ENABLE_TYPES_CHECKING
1649 tree old_type
= TREE_TYPE (expr
);
1653 /* We need to preserve qualifiers and propagate them from
1655 type_quals
= TYPE_QUALS (type
)
1656 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1657 if (TYPE_QUALS (type
) != type_quals
)
1658 type
= build_qualified_type (TYPE_MAIN_VARIANT (type
), type_quals
);
1660 /* Set the type of the COMPONENT_REF to the underlying type. */
1661 TREE_TYPE (expr
) = type
;
1663 #ifdef ENABLE_TYPES_CHECKING
1664 /* It is now a FE error, if the conversion from the canonical
1665 type to the original expression type is not useless. */
1666 gcc_assert (useless_type_conversion_p (old_type
, type
));
1671 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1672 to foo, embed that change in the ADDR_EXPR by converting
1677 where L is the lower bound. For simplicity, only do this for constant
1679 The constraint is that the type of &array[L] is trivially convertible
1683 canonicalize_addr_expr (tree
*expr_p
)
1685 tree expr
= *expr_p
;
1686 tree addr_expr
= TREE_OPERAND (expr
, 0);
1687 tree datype
, ddatype
, pddatype
;
1689 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1690 if (!POINTER_TYPE_P (TREE_TYPE (expr
))
1691 || TREE_CODE (addr_expr
) != ADDR_EXPR
)
1694 /* The addr_expr type should be a pointer to an array. */
1695 datype
= TREE_TYPE (TREE_TYPE (addr_expr
));
1696 if (TREE_CODE (datype
) != ARRAY_TYPE
)
1699 /* The pointer to element type shall be trivially convertible to
1700 the expression pointer type. */
1701 ddatype
= TREE_TYPE (datype
);
1702 pddatype
= build_pointer_type (ddatype
);
1703 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)),
1707 /* The lower bound and element sizes must be constant. */
1708 if (!TYPE_SIZE_UNIT (ddatype
)
1709 || TREE_CODE (TYPE_SIZE_UNIT (ddatype
)) != INTEGER_CST
1710 || !TYPE_DOMAIN (datype
) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))
1711 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))) != INTEGER_CST
)
1714 /* All checks succeeded. Build a new node to merge the cast. */
1715 *expr_p
= build4 (ARRAY_REF
, ddatype
, TREE_OPERAND (addr_expr
, 0),
1716 TYPE_MIN_VALUE (TYPE_DOMAIN (datype
)),
1717 NULL_TREE
, NULL_TREE
);
1718 *expr_p
= build1 (ADDR_EXPR
, pddatype
, *expr_p
);
1720 /* We can have stripped a required restrict qualifier above. */
1721 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
1722 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
1725 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1726 underneath as appropriate. */
1728 static enum gimplify_status
1729 gimplify_conversion (tree
*expr_p
)
1731 location_t loc
= EXPR_LOCATION (*expr_p
);
1732 gcc_assert (CONVERT_EXPR_P (*expr_p
));
1734 /* Then strip away all but the outermost conversion. */
1735 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p
, 0));
1737 /* And remove the outermost conversion if it's useless. */
1738 if (tree_ssa_useless_type_conversion (*expr_p
))
1739 *expr_p
= TREE_OPERAND (*expr_p
, 0);
1741 /* If we still have a conversion at the toplevel,
1742 then canonicalize some constructs. */
1743 if (CONVERT_EXPR_P (*expr_p
))
1745 tree sub
= TREE_OPERAND (*expr_p
, 0);
1747 /* If a NOP conversion is changing the type of a COMPONENT_REF
1748 expression, then canonicalize its type now in order to expose more
1749 redundant conversions. */
1750 if (TREE_CODE (sub
) == COMPONENT_REF
)
1751 canonicalize_component_ref (&TREE_OPERAND (*expr_p
, 0));
1753 /* If a NOP conversion is changing a pointer to array of foo
1754 to a pointer to foo, embed that change in the ADDR_EXPR. */
1755 else if (TREE_CODE (sub
) == ADDR_EXPR
)
1756 canonicalize_addr_expr (expr_p
);
1759 /* If we have a conversion to a non-register type force the
1760 use of a VIEW_CONVERT_EXPR instead. */
1761 if (CONVERT_EXPR_P (*expr_p
) && !is_gimple_reg_type (TREE_TYPE (*expr_p
)))
1762 *expr_p
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (*expr_p
),
1763 TREE_OPERAND (*expr_p
, 0));
1765 /* Canonicalize CONVERT_EXPR to NOP_EXPR. */
1766 if (TREE_CODE (*expr_p
) == CONVERT_EXPR
)
1767 TREE_SET_CODE (*expr_p
, NOP_EXPR
);
1772 /* Nonlocal VLAs seen in the current function. */
1773 static hash_set
<tree
> *nonlocal_vlas
;
1775 /* The VAR_DECLs created for nonlocal VLAs for debug info purposes. */
1776 static tree nonlocal_vla_vars
;
1778 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
1779 DECL_VALUE_EXPR, and it's worth re-examining things. */
1781 static enum gimplify_status
1782 gimplify_var_or_parm_decl (tree
*expr_p
)
1784 tree decl
= *expr_p
;
1786 /* ??? If this is a local variable, and it has not been seen in any
1787 outer BIND_EXPR, then it's probably the result of a duplicate
1788 declaration, for which we've already issued an error. It would
1789 be really nice if the front end wouldn't leak these at all.
1790 Currently the only known culprit is C++ destructors, as seen
1791 in g++.old-deja/g++.jason/binding.C. */
1792 if (TREE_CODE (decl
) == VAR_DECL
1793 && !DECL_SEEN_IN_BIND_EXPR_P (decl
)
1794 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)
1795 && decl_function_context (decl
) == current_function_decl
)
1797 gcc_assert (seen_error ());
1801 /* When within an OMP context, notice uses of variables. */
1802 if (gimplify_omp_ctxp
&& omp_notice_variable (gimplify_omp_ctxp
, decl
, true))
1805 /* If the decl is an alias for another expression, substitute it now. */
1806 if (DECL_HAS_VALUE_EXPR_P (decl
))
1808 tree value_expr
= DECL_VALUE_EXPR (decl
);
1810 /* For referenced nonlocal VLAs add a decl for debugging purposes
1811 to the current function. */
1812 if (TREE_CODE (decl
) == VAR_DECL
1813 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1814 && nonlocal_vlas
!= NULL
1815 && TREE_CODE (value_expr
) == INDIRECT_REF
1816 && TREE_CODE (TREE_OPERAND (value_expr
, 0)) == VAR_DECL
1817 && decl_function_context (decl
) != current_function_decl
)
1819 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1821 && (ctx
->region_type
== ORT_WORKSHARE
1822 || ctx
->region_type
== ORT_SIMD
))
1823 ctx
= ctx
->outer_context
;
1824 if (!ctx
&& !nonlocal_vlas
->add (decl
))
1826 tree copy
= copy_node (decl
);
1828 lang_hooks
.dup_lang_specific_decl (copy
);
1829 SET_DECL_RTL (copy
, 0);
1830 TREE_USED (copy
) = 1;
1831 DECL_CHAIN (copy
) = nonlocal_vla_vars
;
1832 nonlocal_vla_vars
= copy
;
1833 SET_DECL_VALUE_EXPR (copy
, unshare_expr (value_expr
));
1834 DECL_HAS_VALUE_EXPR_P (copy
) = 1;
1838 *expr_p
= unshare_expr (value_expr
);
1845 /* Recalculate the value of the TREE_SIDE_EFFECTS flag for T. */
1848 recalculate_side_effects (tree t
)
1850 enum tree_code code
= TREE_CODE (t
);
1851 int len
= TREE_OPERAND_LENGTH (t
);
1854 switch (TREE_CODE_CLASS (code
))
1856 case tcc_expression
:
1862 case PREDECREMENT_EXPR
:
1863 case PREINCREMENT_EXPR
:
1864 case POSTDECREMENT_EXPR
:
1865 case POSTINCREMENT_EXPR
:
1866 /* All of these have side-effects, no matter what their
1875 case tcc_comparison
: /* a comparison expression */
1876 case tcc_unary
: /* a unary arithmetic expression */
1877 case tcc_binary
: /* a binary arithmetic expression */
1878 case tcc_reference
: /* a reference */
1879 case tcc_vl_exp
: /* a function call */
1880 TREE_SIDE_EFFECTS (t
) = TREE_THIS_VOLATILE (t
);
1881 for (i
= 0; i
< len
; ++i
)
1883 tree op
= TREE_OPERAND (t
, i
);
1884 if (op
&& TREE_SIDE_EFFECTS (op
))
1885 TREE_SIDE_EFFECTS (t
) = 1;
1890 /* No side-effects. */
1898 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1902 : min_lval '[' val ']'
1904 | compound_lval '[' val ']'
1905 | compound_lval '.' ID
1907 This is not part of the original SIMPLE definition, which separates
1908 array and member references, but it seems reasonable to handle them
1909 together. Also, this way we don't run into problems with union
1910 aliasing; gcc requires that for accesses through a union to alias, the
1911 union reference must be explicit, which was not always the case when we
1912 were splitting up array and member refs.
1914 PRE_P points to the sequence where side effects that must happen before
1915 *EXPR_P should be stored.
1917 POST_P points to the sequence where side effects that must happen after
1918 *EXPR_P should be stored. */
1920 static enum gimplify_status
1921 gimplify_compound_lval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
1922 fallback_t fallback
)
1925 enum gimplify_status ret
= GS_ALL_DONE
, tret
;
1927 location_t loc
= EXPR_LOCATION (*expr_p
);
1928 tree expr
= *expr_p
;
1930 /* Create a stack of the subexpressions so later we can walk them in
1931 order from inner to outer. */
1932 auto_vec
<tree
, 10> expr_stack
;
1934 /* We can handle anything that get_inner_reference can deal with. */
1935 for (p
= expr_p
; ; p
= &TREE_OPERAND (*p
, 0))
1938 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
1939 if (TREE_CODE (*p
) == INDIRECT_REF
)
1940 *p
= fold_indirect_ref_loc (loc
, *p
);
1942 if (handled_component_p (*p
))
1944 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
1945 additional COMPONENT_REFs. */
1946 else if ((TREE_CODE (*p
) == VAR_DECL
|| TREE_CODE (*p
) == PARM_DECL
)
1947 && gimplify_var_or_parm_decl (p
) == GS_OK
)
1952 expr_stack
.safe_push (*p
);
1955 gcc_assert (expr_stack
.length ());
1957 /* Now EXPR_STACK is a stack of pointers to all the refs we've
1958 walked through and P points to the innermost expression.
1960 Java requires that we elaborated nodes in source order. That
1961 means we must gimplify the inner expression followed by each of
1962 the indices, in order. But we can't gimplify the inner
1963 expression until we deal with any variable bounds, sizes, or
1964 positions in order to deal with PLACEHOLDER_EXPRs.
1966 So we do this in three steps. First we deal with the annotations
1967 for any variables in the components, then we gimplify the base,
1968 then we gimplify any indices, from left to right. */
1969 for (i
= expr_stack
.length () - 1; i
>= 0; i
--)
1971 tree t
= expr_stack
[i
];
1973 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
1975 /* Gimplify the low bound and element type size and put them into
1976 the ARRAY_REF. If these values are set, they have already been
1978 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
1980 tree low
= unshare_expr (array_ref_low_bound (t
));
1981 if (!is_gimple_min_invariant (low
))
1983 TREE_OPERAND (t
, 2) = low
;
1984 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
1985 post_p
, is_gimple_reg
,
1987 ret
= MIN (ret
, tret
);
1992 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
1993 is_gimple_reg
, fb_rvalue
);
1994 ret
= MIN (ret
, tret
);
1997 if (TREE_OPERAND (t
, 3) == NULL_TREE
)
1999 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0)));
2000 tree elmt_size
= unshare_expr (array_ref_element_size (t
));
2001 tree factor
= size_int (TYPE_ALIGN_UNIT (elmt_type
));
2003 /* Divide the element size by the alignment of the element
2006 = size_binop_loc (loc
, EXACT_DIV_EXPR
, elmt_size
, factor
);
2008 if (!is_gimple_min_invariant (elmt_size
))
2010 TREE_OPERAND (t
, 3) = elmt_size
;
2011 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
,
2012 post_p
, is_gimple_reg
,
2014 ret
= MIN (ret
, tret
);
2019 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
, post_p
,
2020 is_gimple_reg
, fb_rvalue
);
2021 ret
= MIN (ret
, tret
);
2024 else if (TREE_CODE (t
) == COMPONENT_REF
)
2026 /* Set the field offset into T and gimplify it. */
2027 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2029 tree offset
= unshare_expr (component_ref_field_offset (t
));
2030 tree field
= TREE_OPERAND (t
, 1);
2032 = size_int (DECL_OFFSET_ALIGN (field
) / BITS_PER_UNIT
);
2034 /* Divide the offset by its alignment. */
2035 offset
= size_binop_loc (loc
, EXACT_DIV_EXPR
, offset
, factor
);
2037 if (!is_gimple_min_invariant (offset
))
2039 TREE_OPERAND (t
, 2) = offset
;
2040 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2041 post_p
, is_gimple_reg
,
2043 ret
= MIN (ret
, tret
);
2048 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2049 is_gimple_reg
, fb_rvalue
);
2050 ret
= MIN (ret
, tret
);
2055 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2056 so as to match the min_lval predicate. Failure to do so may result
2057 in the creation of large aggregate temporaries. */
2058 tret
= gimplify_expr (p
, pre_p
, post_p
, is_gimple_min_lval
,
2059 fallback
| fb_lvalue
);
2060 ret
= MIN (ret
, tret
);
2062 /* And finally, the indices and operands of ARRAY_REF. During this
2063 loop we also remove any useless conversions. */
2064 for (; expr_stack
.length () > 0; )
2066 tree t
= expr_stack
.pop ();
2068 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2070 /* Gimplify the dimension. */
2071 if (!is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
2073 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2074 is_gimple_val
, fb_rvalue
);
2075 ret
= MIN (ret
, tret
);
2079 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t
, 0));
2081 /* The innermost expression P may have originally had
2082 TREE_SIDE_EFFECTS set which would have caused all the outer
2083 expressions in *EXPR_P leading to P to also have had
2084 TREE_SIDE_EFFECTS set. */
2085 recalculate_side_effects (t
);
2088 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2089 if ((fallback
& fb_rvalue
) && TREE_CODE (*expr_p
) == COMPONENT_REF
)
2091 canonicalize_component_ref (expr_p
);
2094 expr_stack
.release ();
2096 gcc_assert (*expr_p
== expr
|| ret
!= GS_ALL_DONE
);
2101 /* Gimplify the self modifying expression pointed to by EXPR_P
2104 PRE_P points to the list where side effects that must happen before
2105 *EXPR_P should be stored.
2107 POST_P points to the list where side effects that must happen after
2108 *EXPR_P should be stored.
2110 WANT_VALUE is nonzero iff we want to use the value of this expression
2111 in another expression.
2113 ARITH_TYPE is the type the computation should be performed in. */
2115 enum gimplify_status
2116 gimplify_self_mod_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2117 bool want_value
, tree arith_type
)
2119 enum tree_code code
;
2120 tree lhs
, lvalue
, rhs
, t1
;
2121 gimple_seq post
= NULL
, *orig_post_p
= post_p
;
2123 enum tree_code arith_code
;
2124 enum gimplify_status ret
;
2125 location_t loc
= EXPR_LOCATION (*expr_p
);
2127 code
= TREE_CODE (*expr_p
);
2129 gcc_assert (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
2130 || code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
);
2132 /* Prefix or postfix? */
2133 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
2134 /* Faster to treat as prefix if result is not used. */
2135 postfix
= want_value
;
2139 /* For postfix, make sure the inner expression's post side effects
2140 are executed after side effects from this expression. */
2144 /* Add or subtract? */
2145 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2146 arith_code
= PLUS_EXPR
;
2148 arith_code
= MINUS_EXPR
;
2150 /* Gimplify the LHS into a GIMPLE lvalue. */
2151 lvalue
= TREE_OPERAND (*expr_p
, 0);
2152 ret
= gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
2153 if (ret
== GS_ERROR
)
2156 /* Extract the operands to the arithmetic operation. */
2158 rhs
= TREE_OPERAND (*expr_p
, 1);
2160 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2161 that as the result value and in the postqueue operation. */
2164 ret
= gimplify_expr (&lhs
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
2165 if (ret
== GS_ERROR
)
2168 lhs
= get_initialized_tmp_var (lhs
, pre_p
, NULL
);
2171 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2172 if (POINTER_TYPE_P (TREE_TYPE (lhs
)))
2174 rhs
= convert_to_ptrofftype_loc (loc
, rhs
);
2175 if (arith_code
== MINUS_EXPR
)
2176 rhs
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
2177 t1
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (*expr_p
), lhs
, rhs
);
2180 t1
= fold_convert (TREE_TYPE (*expr_p
),
2181 fold_build2 (arith_code
, arith_type
,
2182 fold_convert (arith_type
, lhs
),
2183 fold_convert (arith_type
, rhs
)));
2187 gimplify_assign (lvalue
, t1
, pre_p
);
2188 gimplify_seq_add_seq (orig_post_p
, post
);
2194 *expr_p
= build2 (MODIFY_EXPR
, TREE_TYPE (lvalue
), lvalue
, t1
);
2199 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2202 maybe_with_size_expr (tree
*expr_p
)
2204 tree expr
= *expr_p
;
2205 tree type
= TREE_TYPE (expr
);
2208 /* If we've already wrapped this or the type is error_mark_node, we can't do
2210 if (TREE_CODE (expr
) == WITH_SIZE_EXPR
2211 || type
== error_mark_node
)
2214 /* If the size isn't known or is a constant, we have nothing to do. */
2215 size
= TYPE_SIZE_UNIT (type
);
2216 if (!size
|| TREE_CODE (size
) == INTEGER_CST
)
2219 /* Otherwise, make a WITH_SIZE_EXPR. */
2220 size
= unshare_expr (size
);
2221 size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (size
, expr
);
2222 *expr_p
= build2 (WITH_SIZE_EXPR
, type
, expr
, size
);
2225 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2226 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2229 enum gimplify_status
2230 gimplify_arg (tree
*arg_p
, gimple_seq
*pre_p
, location_t call_location
)
2232 bool (*test
) (tree
);
2235 /* In general, we allow lvalues for function arguments to avoid
2236 extra overhead of copying large aggregates out of even larger
2237 aggregates into temporaries only to copy the temporaries to
2238 the argument list. Make optimizers happy by pulling out to
2239 temporaries those types that fit in registers. */
2240 if (is_gimple_reg_type (TREE_TYPE (*arg_p
)))
2241 test
= is_gimple_val
, fb
= fb_rvalue
;
2244 test
= is_gimple_lvalue
, fb
= fb_either
;
2245 /* Also strip a TARGET_EXPR that would force an extra copy. */
2246 if (TREE_CODE (*arg_p
) == TARGET_EXPR
)
2248 tree init
= TARGET_EXPR_INITIAL (*arg_p
);
2250 && !VOID_TYPE_P (TREE_TYPE (init
)))
2255 /* If this is a variable sized type, we must remember the size. */
2256 maybe_with_size_expr (arg_p
);
2258 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2259 /* Make sure arguments have the same location as the function call
2261 protected_set_expr_location (*arg_p
, call_location
);
2263 /* There is a sequence point before a function call. Side effects in
2264 the argument list must occur before the actual call. So, when
2265 gimplifying arguments, force gimplify_expr to use an internal
2266 post queue which is then appended to the end of PRE_P. */
2267 return gimplify_expr (arg_p
, pre_p
, NULL
, test
, fb
);
2270 /* Don't fold inside offloading regions: it can break code by adding decl
2271 references that weren't in the source. We'll do it during omplower pass
2275 maybe_fold_stmt (gimple_stmt_iterator
*gsi
)
2277 struct gimplify_omp_ctx
*ctx
;
2278 for (ctx
= gimplify_omp_ctxp
; ctx
; ctx
= ctx
->outer_context
)
2279 if (ctx
->region_type
== ORT_TARGET
)
2281 return fold_stmt (gsi
);
2284 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2285 WANT_VALUE is true if the result of the call is desired. */
2287 static enum gimplify_status
2288 gimplify_call_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
2290 tree fndecl
, parms
, p
, fnptrtype
;
2291 enum gimplify_status ret
;
2294 bool builtin_va_start_p
= false;
2295 location_t loc
= EXPR_LOCATION (*expr_p
);
2297 gcc_assert (TREE_CODE (*expr_p
) == CALL_EXPR
);
2299 /* For reliable diagnostics during inlining, it is necessary that
2300 every call_expr be annotated with file and line. */
2301 if (! EXPR_HAS_LOCATION (*expr_p
))
2302 SET_EXPR_LOCATION (*expr_p
, input_location
);
2304 /* Gimplify internal functions created in the FEs. */
2305 if (CALL_EXPR_FN (*expr_p
) == NULL_TREE
)
2310 nargs
= call_expr_nargs (*expr_p
);
2311 enum internal_fn ifn
= CALL_EXPR_IFN (*expr_p
);
2312 auto_vec
<tree
> vargs (nargs
);
2314 for (i
= 0; i
< nargs
; i
++)
2316 gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
2317 EXPR_LOCATION (*expr_p
));
2318 vargs
.quick_push (CALL_EXPR_ARG (*expr_p
, i
));
2320 gimple call
= gimple_build_call_internal_vec (ifn
, vargs
);
2321 gimplify_seq_add_stmt (pre_p
, call
);
2325 /* This may be a call to a builtin function.
2327 Builtin function calls may be transformed into different
2328 (and more efficient) builtin function calls under certain
2329 circumstances. Unfortunately, gimplification can muck things
2330 up enough that the builtin expanders are not aware that certain
2331 transformations are still valid.
2333 So we attempt transformation/gimplification of the call before
2334 we gimplify the CALL_EXPR. At this time we do not manage to
2335 transform all calls in the same manner as the expanders do, but
2336 we do transform most of them. */
2337 fndecl
= get_callee_fndecl (*expr_p
);
2339 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
2340 switch (DECL_FUNCTION_CODE (fndecl
))
2342 case BUILT_IN_VA_START
:
2344 builtin_va_start_p
= TRUE
;
2345 if (call_expr_nargs (*expr_p
) < 2)
2347 error ("too few arguments to function %<va_start%>");
2348 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2352 if (fold_builtin_next_arg (*expr_p
, true))
2354 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2361 *expr_p
= build_int_cst (TREE_TYPE (*expr_p
),
2362 LOCATION_LINE (EXPR_LOCATION (*expr_p
)));
2367 const char *locfile
= LOCATION_FILE (EXPR_LOCATION (*expr_p
));
2368 *expr_p
= build_string_literal (strlen (locfile
) + 1, locfile
);
2371 case BUILT_IN_FUNCTION
:
2373 const char *function
;
2374 function
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
2375 *expr_p
= build_string_literal (strlen (function
) + 1, function
);
2381 if (fndecl
&& DECL_BUILT_IN (fndecl
))
2383 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2384 if (new_tree
&& new_tree
!= *expr_p
)
2386 /* There was a transformation of this call which computes the
2387 same value, but in a more efficient way. Return and try
2394 /* Remember the original function pointer type. */
2395 fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*expr_p
));
2397 /* There is a sequence point before the call, so any side effects in
2398 the calling expression must occur before the actual call. Force
2399 gimplify_expr to use an internal post queue. */
2400 ret
= gimplify_expr (&CALL_EXPR_FN (*expr_p
), pre_p
, NULL
,
2401 is_gimple_call_addr
, fb_rvalue
);
2403 nargs
= call_expr_nargs (*expr_p
);
2405 /* Get argument types for verification. */
2406 fndecl
= get_callee_fndecl (*expr_p
);
2409 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2411 parms
= TYPE_ARG_TYPES (TREE_TYPE (fnptrtype
));
2413 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
2414 p
= DECL_ARGUMENTS (fndecl
);
2419 for (i
= 0; i
< nargs
&& p
; i
++, p
= TREE_CHAIN (p
))
2422 /* If the last argument is __builtin_va_arg_pack () and it is not
2423 passed as a named argument, decrease the number of CALL_EXPR
2424 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2427 && TREE_CODE (CALL_EXPR_ARG (*expr_p
, nargs
- 1)) == CALL_EXPR
)
2429 tree last_arg
= CALL_EXPR_ARG (*expr_p
, nargs
- 1);
2430 tree last_arg_fndecl
= get_callee_fndecl (last_arg
);
2433 && TREE_CODE (last_arg_fndecl
) == FUNCTION_DECL
2434 && DECL_BUILT_IN_CLASS (last_arg_fndecl
) == BUILT_IN_NORMAL
2435 && DECL_FUNCTION_CODE (last_arg_fndecl
) == BUILT_IN_VA_ARG_PACK
)
2437 tree call
= *expr_p
;
2440 *expr_p
= build_call_array_loc (loc
, TREE_TYPE (call
),
2441 CALL_EXPR_FN (call
),
2442 nargs
, CALL_EXPR_ARGP (call
));
2444 /* Copy all CALL_EXPR flags, location and block, except
2445 CALL_EXPR_VA_ARG_PACK flag. */
2446 CALL_EXPR_STATIC_CHAIN (*expr_p
) = CALL_EXPR_STATIC_CHAIN (call
);
2447 CALL_EXPR_TAILCALL (*expr_p
) = CALL_EXPR_TAILCALL (call
);
2448 CALL_EXPR_RETURN_SLOT_OPT (*expr_p
)
2449 = CALL_EXPR_RETURN_SLOT_OPT (call
);
2450 CALL_FROM_THUNK_P (*expr_p
) = CALL_FROM_THUNK_P (call
);
2451 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (call
));
2453 /* Set CALL_EXPR_VA_ARG_PACK. */
2454 CALL_EXPR_VA_ARG_PACK (*expr_p
) = 1;
2458 /* Gimplify the function arguments. */
2461 for (i
= (PUSH_ARGS_REVERSED
? nargs
- 1 : 0);
2462 PUSH_ARGS_REVERSED
? i
>= 0 : i
< nargs
;
2463 PUSH_ARGS_REVERSED
? i
-- : i
++)
2465 enum gimplify_status t
;
2467 /* Avoid gimplifying the second argument to va_start, which needs to
2468 be the plain PARM_DECL. */
2469 if ((i
!= 1) || !builtin_va_start_p
)
2471 t
= gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
2472 EXPR_LOCATION (*expr_p
));
2480 /* Gimplify the static chain. */
2481 if (CALL_EXPR_STATIC_CHAIN (*expr_p
))
2483 if (fndecl
&& !DECL_STATIC_CHAIN (fndecl
))
2484 CALL_EXPR_STATIC_CHAIN (*expr_p
) = NULL
;
2487 enum gimplify_status t
;
2488 t
= gimplify_arg (&CALL_EXPR_STATIC_CHAIN (*expr_p
), pre_p
,
2489 EXPR_LOCATION (*expr_p
));
2495 /* Verify the function result. */
2496 if (want_value
&& fndecl
2497 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype
))))
2499 error_at (loc
, "using result of function returning %<void%>");
2503 /* Try this again in case gimplification exposed something. */
2504 if (ret
!= GS_ERROR
)
2506 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2508 if (new_tree
&& new_tree
!= *expr_p
)
2510 /* There was a transformation of this call which computes the
2511 same value, but in a more efficient way. Return and try
2519 *expr_p
= error_mark_node
;
2523 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2524 decl. This allows us to eliminate redundant or useless
2525 calls to "const" functions. */
2526 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
2528 int flags
= call_expr_flags (*expr_p
);
2529 if (flags
& (ECF_CONST
| ECF_PURE
)
2530 /* An infinite loop is considered a side effect. */
2531 && !(flags
& (ECF_LOOPING_CONST_OR_PURE
)))
2532 TREE_SIDE_EFFECTS (*expr_p
) = 0;
2535 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2536 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2537 form and delegate the creation of a GIMPLE_CALL to
2538 gimplify_modify_expr. This is always possible because when
2539 WANT_VALUE is true, the caller wants the result of this call into
2540 a temporary, which means that we will emit an INIT_EXPR in
2541 internal_get_tmp_var which will then be handled by
2542 gimplify_modify_expr. */
2545 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2546 have to do is replicate it as a GIMPLE_CALL tuple. */
2547 gimple_stmt_iterator gsi
;
2548 call
= gimple_build_call_from_tree (*expr_p
);
2549 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
2550 notice_special_calls (call
);
2551 gimplify_seq_add_stmt (pre_p
, call
);
2552 gsi
= gsi_last (*pre_p
);
2553 maybe_fold_stmt (&gsi
);
2554 *expr_p
= NULL_TREE
;
2557 /* Remember the original function type. */
2558 CALL_EXPR_FN (*expr_p
) = build1 (NOP_EXPR
, fnptrtype
,
2559 CALL_EXPR_FN (*expr_p
));
2564 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2565 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2567 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2568 condition is true or false, respectively. If null, we should generate
2569 our own to skip over the evaluation of this specific expression.
2571 LOCUS is the source location of the COND_EXPR.
2573 This function is the tree equivalent of do_jump.
2575 shortcut_cond_r should only be called by shortcut_cond_expr. */
2578 shortcut_cond_r (tree pred
, tree
*true_label_p
, tree
*false_label_p
,
2581 tree local_label
= NULL_TREE
;
2582 tree t
, expr
= NULL
;
2584 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2585 retain the shortcut semantics. Just insert the gotos here;
2586 shortcut_cond_expr will append the real blocks later. */
2587 if (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2589 location_t new_locus
;
2591 /* Turn if (a && b) into
2593 if (a); else goto no;
2594 if (b) goto yes; else goto no;
2597 if (false_label_p
== NULL
)
2598 false_label_p
= &local_label
;
2600 /* Keep the original source location on the first 'if'. */
2601 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), NULL
, false_label_p
, locus
);
2602 append_to_statement_list (t
, &expr
);
2604 /* Set the source location of the && on the second 'if'. */
2605 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2606 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2608 append_to_statement_list (t
, &expr
);
2610 else if (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2612 location_t new_locus
;
2614 /* Turn if (a || b) into
2617 if (b) goto yes; else goto no;
2620 if (true_label_p
== NULL
)
2621 true_label_p
= &local_label
;
2623 /* Keep the original source location on the first 'if'. */
2624 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), true_label_p
, NULL
, locus
);
2625 append_to_statement_list (t
, &expr
);
2627 /* Set the source location of the || on the second 'if'. */
2628 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2629 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2631 append_to_statement_list (t
, &expr
);
2633 else if (TREE_CODE (pred
) == COND_EXPR
2634 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 1)))
2635 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 2))))
2637 location_t new_locus
;
2639 /* As long as we're messing with gotos, turn if (a ? b : c) into
2641 if (b) goto yes; else goto no;
2643 if (c) goto yes; else goto no;
2645 Don't do this if one of the arms has void type, which can happen
2646 in C++ when the arm is throw. */
2648 /* Keep the original source location on the first 'if'. Set the source
2649 location of the ? on the second 'if'. */
2650 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2651 expr
= build3 (COND_EXPR
, void_type_node
, TREE_OPERAND (pred
, 0),
2652 shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
,
2653 false_label_p
, locus
),
2654 shortcut_cond_r (TREE_OPERAND (pred
, 2), true_label_p
,
2655 false_label_p
, new_locus
));
2659 expr
= build3 (COND_EXPR
, void_type_node
, pred
,
2660 build_and_jump (true_label_p
),
2661 build_and_jump (false_label_p
));
2662 SET_EXPR_LOCATION (expr
, locus
);
2667 t
= build1 (LABEL_EXPR
, void_type_node
, local_label
);
2668 append_to_statement_list (t
, &expr
);
2674 /* Given a conditional expression EXPR with short-circuit boolean
2675 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2676 predicate apart into the equivalent sequence of conditionals. */
2679 shortcut_cond_expr (tree expr
)
2681 tree pred
= TREE_OPERAND (expr
, 0);
2682 tree then_
= TREE_OPERAND (expr
, 1);
2683 tree else_
= TREE_OPERAND (expr
, 2);
2684 tree true_label
, false_label
, end_label
, t
;
2686 tree
*false_label_p
;
2687 bool emit_end
, emit_false
, jump_over_else
;
2688 bool then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2689 bool else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2691 /* First do simple transformations. */
2694 /* If there is no 'else', turn
2697 if (a) if (b) then c. */
2698 while (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2700 /* Keep the original source location on the first 'if'. */
2701 location_t locus
= EXPR_LOC_OR_LOC (expr
, input_location
);
2702 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2703 /* Set the source location of the && on the second 'if'. */
2704 if (EXPR_HAS_LOCATION (pred
))
2705 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2706 then_
= shortcut_cond_expr (expr
);
2707 then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2708 pred
= TREE_OPERAND (pred
, 0);
2709 expr
= build3 (COND_EXPR
, void_type_node
, pred
, then_
, NULL_TREE
);
2710 SET_EXPR_LOCATION (expr
, locus
);
2716 /* If there is no 'then', turn
2719 if (a); else if (b); else d. */
2720 while (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2722 /* Keep the original source location on the first 'if'. */
2723 location_t locus
= EXPR_LOC_OR_LOC (expr
, input_location
);
2724 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2725 /* Set the source location of the || on the second 'if'. */
2726 if (EXPR_HAS_LOCATION (pred
))
2727 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2728 else_
= shortcut_cond_expr (expr
);
2729 else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2730 pred
= TREE_OPERAND (pred
, 0);
2731 expr
= build3 (COND_EXPR
, void_type_node
, pred
, NULL_TREE
, else_
);
2732 SET_EXPR_LOCATION (expr
, locus
);
2736 /* If we're done, great. */
2737 if (TREE_CODE (pred
) != TRUTH_ANDIF_EXPR
2738 && TREE_CODE (pred
) != TRUTH_ORIF_EXPR
)
2741 /* Otherwise we need to mess with gotos. Change
2744 if (a); else goto no;
2747 and recursively gimplify the condition. */
2749 true_label
= false_label
= end_label
= NULL_TREE
;
2751 /* If our arms just jump somewhere, hijack those labels so we don't
2752 generate jumps to jumps. */
2755 && TREE_CODE (then_
) == GOTO_EXPR
2756 && TREE_CODE (GOTO_DESTINATION (then_
)) == LABEL_DECL
)
2758 true_label
= GOTO_DESTINATION (then_
);
2764 && TREE_CODE (else_
) == GOTO_EXPR
2765 && TREE_CODE (GOTO_DESTINATION (else_
)) == LABEL_DECL
)
2767 false_label
= GOTO_DESTINATION (else_
);
2772 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2774 true_label_p
= &true_label
;
2776 true_label_p
= NULL
;
2778 /* The 'else' branch also needs a label if it contains interesting code. */
2779 if (false_label
|| else_se
)
2780 false_label_p
= &false_label
;
2782 false_label_p
= NULL
;
2784 /* If there was nothing else in our arms, just forward the label(s). */
2785 if (!then_se
&& !else_se
)
2786 return shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2787 EXPR_LOC_OR_LOC (expr
, input_location
));
2789 /* If our last subexpression already has a terminal label, reuse it. */
2791 t
= expr_last (else_
);
2793 t
= expr_last (then_
);
2796 if (t
&& TREE_CODE (t
) == LABEL_EXPR
)
2797 end_label
= LABEL_EXPR_LABEL (t
);
2799 /* If we don't care about jumping to the 'else' branch, jump to the end
2800 if the condition is false. */
2802 false_label_p
= &end_label
;
2804 /* We only want to emit these labels if we aren't hijacking them. */
2805 emit_end
= (end_label
== NULL_TREE
);
2806 emit_false
= (false_label
== NULL_TREE
);
2808 /* We only emit the jump over the else clause if we have to--if the
2809 then clause may fall through. Otherwise we can wind up with a
2810 useless jump and a useless label at the end of gimplified code,
2811 which will cause us to think that this conditional as a whole
2812 falls through even if it doesn't. If we then inline a function
2813 which ends with such a condition, that can cause us to issue an
2814 inappropriate warning about control reaching the end of a
2815 non-void function. */
2816 jump_over_else
= block_may_fallthru (then_
);
2818 pred
= shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2819 EXPR_LOC_OR_LOC (expr
, input_location
));
2822 append_to_statement_list (pred
, &expr
);
2824 append_to_statement_list (then_
, &expr
);
2829 tree last
= expr_last (expr
);
2830 t
= build_and_jump (&end_label
);
2831 if (EXPR_HAS_LOCATION (last
))
2832 SET_EXPR_LOCATION (t
, EXPR_LOCATION (last
));
2833 append_to_statement_list (t
, &expr
);
2837 t
= build1 (LABEL_EXPR
, void_type_node
, false_label
);
2838 append_to_statement_list (t
, &expr
);
2840 append_to_statement_list (else_
, &expr
);
2842 if (emit_end
&& end_label
)
2844 t
= build1 (LABEL_EXPR
, void_type_node
, end_label
);
2845 append_to_statement_list (t
, &expr
);
2851 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2854 gimple_boolify (tree expr
)
2856 tree type
= TREE_TYPE (expr
);
2857 location_t loc
= EXPR_LOCATION (expr
);
2859 if (TREE_CODE (expr
) == NE_EXPR
2860 && TREE_CODE (TREE_OPERAND (expr
, 0)) == CALL_EXPR
2861 && integer_zerop (TREE_OPERAND (expr
, 1)))
2863 tree call
= TREE_OPERAND (expr
, 0);
2864 tree fn
= get_callee_fndecl (call
);
2866 /* For __builtin_expect ((long) (x), y) recurse into x as well
2867 if x is truth_value_p. */
2869 && DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2870 && DECL_FUNCTION_CODE (fn
) == BUILT_IN_EXPECT
2871 && call_expr_nargs (call
) == 2)
2873 tree arg
= CALL_EXPR_ARG (call
, 0);
2876 if (TREE_CODE (arg
) == NOP_EXPR
2877 && TREE_TYPE (arg
) == TREE_TYPE (call
))
2878 arg
= TREE_OPERAND (arg
, 0);
2879 if (truth_value_p (TREE_CODE (arg
)))
2881 arg
= gimple_boolify (arg
);
2882 CALL_EXPR_ARG (call
, 0)
2883 = fold_convert_loc (loc
, TREE_TYPE (call
), arg
);
2889 switch (TREE_CODE (expr
))
2891 case TRUTH_AND_EXPR
:
2893 case TRUTH_XOR_EXPR
:
2894 case TRUTH_ANDIF_EXPR
:
2895 case TRUTH_ORIF_EXPR
:
2896 /* Also boolify the arguments of truth exprs. */
2897 TREE_OPERAND (expr
, 1) = gimple_boolify (TREE_OPERAND (expr
, 1));
2900 case TRUTH_NOT_EXPR
:
2901 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
2903 /* These expressions always produce boolean results. */
2904 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
2905 TREE_TYPE (expr
) = boolean_type_node
;
2909 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (expr
, 1)))
2911 case annot_expr_ivdep_kind
:
2912 case annot_expr_no_vector_kind
:
2913 case annot_expr_vector_kind
:
2914 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
2915 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
2916 TREE_TYPE (expr
) = boolean_type_node
;
2923 if (COMPARISON_CLASS_P (expr
))
2925 /* There expressions always prduce boolean results. */
2926 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
2927 TREE_TYPE (expr
) = boolean_type_node
;
2930 /* Other expressions that get here must have boolean values, but
2931 might need to be converted to the appropriate mode. */
2932 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
2934 return fold_convert_loc (loc
, boolean_type_node
, expr
);
2938 /* Given a conditional expression *EXPR_P without side effects, gimplify
2939 its operands. New statements are inserted to PRE_P. */
2941 static enum gimplify_status
2942 gimplify_pure_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2944 tree expr
= *expr_p
, cond
;
2945 enum gimplify_status ret
, tret
;
2946 enum tree_code code
;
2948 cond
= gimple_boolify (COND_EXPR_COND (expr
));
2950 /* We need to handle && and || specially, as their gimplification
2951 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
2952 code
= TREE_CODE (cond
);
2953 if (code
== TRUTH_ANDIF_EXPR
)
2954 TREE_SET_CODE (cond
, TRUTH_AND_EXPR
);
2955 else if (code
== TRUTH_ORIF_EXPR
)
2956 TREE_SET_CODE (cond
, TRUTH_OR_EXPR
);
2957 ret
= gimplify_expr (&cond
, pre_p
, NULL
, is_gimple_condexpr
, fb_rvalue
);
2958 COND_EXPR_COND (*expr_p
) = cond
;
2960 tret
= gimplify_expr (&COND_EXPR_THEN (expr
), pre_p
, NULL
,
2961 is_gimple_val
, fb_rvalue
);
2962 ret
= MIN (ret
, tret
);
2963 tret
= gimplify_expr (&COND_EXPR_ELSE (expr
), pre_p
, NULL
,
2964 is_gimple_val
, fb_rvalue
);
2966 return MIN (ret
, tret
);
2969 /* Return true if evaluating EXPR could trap.
2970 EXPR is GENERIC, while tree_could_trap_p can be called
2974 generic_expr_could_trap_p (tree expr
)
2978 if (!expr
|| is_gimple_val (expr
))
2981 if (!EXPR_P (expr
) || tree_could_trap_p (expr
))
2984 n
= TREE_OPERAND_LENGTH (expr
);
2985 for (i
= 0; i
< n
; i
++)
2986 if (generic_expr_could_trap_p (TREE_OPERAND (expr
, i
)))
2992 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3001 The second form is used when *EXPR_P is of type void.
3003 PRE_P points to the list where side effects that must happen before
3004 *EXPR_P should be stored. */
3006 static enum gimplify_status
3007 gimplify_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
, fallback_t fallback
)
3009 tree expr
= *expr_p
;
3010 tree type
= TREE_TYPE (expr
);
3011 location_t loc
= EXPR_LOCATION (expr
);
3012 tree tmp
, arm1
, arm2
;
3013 enum gimplify_status ret
;
3014 tree label_true
, label_false
, label_cont
;
3015 bool have_then_clause_p
, have_else_clause_p
;
3017 enum tree_code pred_code
;
3018 gimple_seq seq
= NULL
;
3020 /* If this COND_EXPR has a value, copy the values into a temporary within
3022 if (!VOID_TYPE_P (type
))
3024 tree then_
= TREE_OPERAND (expr
, 1), else_
= TREE_OPERAND (expr
, 2);
3027 /* If either an rvalue is ok or we do not require an lvalue, create the
3028 temporary. But we cannot do that if the type is addressable. */
3029 if (((fallback
& fb_rvalue
) || !(fallback
& fb_lvalue
))
3030 && !TREE_ADDRESSABLE (type
))
3032 if (gimplify_ctxp
->allow_rhs_cond_expr
3033 /* If either branch has side effects or could trap, it can't be
3034 evaluated unconditionally. */
3035 && !TREE_SIDE_EFFECTS (then_
)
3036 && !generic_expr_could_trap_p (then_
)
3037 && !TREE_SIDE_EFFECTS (else_
)
3038 && !generic_expr_could_trap_p (else_
))
3039 return gimplify_pure_cond_expr (expr_p
, pre_p
);
3041 tmp
= create_tmp_var (type
, "iftmp");
3045 /* Otherwise, only create and copy references to the values. */
3048 type
= build_pointer_type (type
);
3050 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3051 then_
= build_fold_addr_expr_loc (loc
, then_
);
3053 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3054 else_
= build_fold_addr_expr_loc (loc
, else_
);
3057 = build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0), then_
, else_
);
3059 tmp
= create_tmp_var (type
, "iftmp");
3060 result
= build_simple_mem_ref_loc (loc
, tmp
);
3063 /* Build the new then clause, `tmp = then_;'. But don't build the
3064 assignment if the value is void; in C++ it can be if it's a throw. */
3065 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3066 TREE_OPERAND (expr
, 1) = build2 (MODIFY_EXPR
, type
, tmp
, then_
);
3068 /* Similarly, build the new else clause, `tmp = else_;'. */
3069 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3070 TREE_OPERAND (expr
, 2) = build2 (MODIFY_EXPR
, type
, tmp
, else_
);
3072 TREE_TYPE (expr
) = void_type_node
;
3073 recalculate_side_effects (expr
);
3075 /* Move the COND_EXPR to the prequeue. */
3076 gimplify_stmt (&expr
, pre_p
);
3082 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
3083 STRIP_TYPE_NOPS (TREE_OPERAND (expr
, 0));
3084 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == COMPOUND_EXPR
)
3085 gimplify_compound_expr (&TREE_OPERAND (expr
, 0), pre_p
, true);
3087 /* Make sure the condition has BOOLEAN_TYPE. */
3088 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3090 /* Break apart && and || conditions. */
3091 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ANDIF_EXPR
3092 || TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ORIF_EXPR
)
3094 expr
= shortcut_cond_expr (expr
);
3096 if (expr
!= *expr_p
)
3100 /* We can't rely on gimplify_expr to re-gimplify the expanded
3101 form properly, as cleanups might cause the target labels to be
3102 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3103 set up a conditional context. */
3104 gimple_push_condition ();
3105 gimplify_stmt (expr_p
, &seq
);
3106 gimple_pop_condition (pre_p
);
3107 gimple_seq_add_seq (pre_p
, seq
);
3113 /* Now do the normal gimplification. */
3115 /* Gimplify condition. */
3116 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, NULL
, is_gimple_condexpr
,
3118 if (ret
== GS_ERROR
)
3120 gcc_assert (TREE_OPERAND (expr
, 0) != NULL_TREE
);
3122 gimple_push_condition ();
3124 have_then_clause_p
= have_else_clause_p
= false;
3125 if (TREE_OPERAND (expr
, 1) != NULL
3126 && TREE_CODE (TREE_OPERAND (expr
, 1)) == GOTO_EXPR
3127 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 1))) == LABEL_DECL
3128 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 1)))
3129 == current_function_decl
)
3130 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3131 have different locations, otherwise we end up with incorrect
3132 location information on the branches. */
3134 || !EXPR_HAS_LOCATION (expr
)
3135 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 1))
3136 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 1))))
3138 label_true
= GOTO_DESTINATION (TREE_OPERAND (expr
, 1));
3139 have_then_clause_p
= true;
3142 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
3143 if (TREE_OPERAND (expr
, 2) != NULL
3144 && TREE_CODE (TREE_OPERAND (expr
, 2)) == GOTO_EXPR
3145 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 2))) == LABEL_DECL
3146 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 2)))
3147 == current_function_decl
)
3148 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3149 have different locations, otherwise we end up with incorrect
3150 location information on the branches. */
3152 || !EXPR_HAS_LOCATION (expr
)
3153 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 2))
3154 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 2))))
3156 label_false
= GOTO_DESTINATION (TREE_OPERAND (expr
, 2));
3157 have_else_clause_p
= true;
3160 label_false
= create_artificial_label (UNKNOWN_LOCATION
);
3162 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr
), &pred_code
, &arm1
,
3165 cond_stmt
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
,
3168 gimplify_seq_add_stmt (&seq
, cond_stmt
);
3169 label_cont
= NULL_TREE
;
3170 if (!have_then_clause_p
)
3172 /* For if (...) {} else { code; } put label_true after
3174 if (TREE_OPERAND (expr
, 1) == NULL_TREE
3175 && !have_else_clause_p
3176 && TREE_OPERAND (expr
, 2) != NULL_TREE
)
3177 label_cont
= label_true
;
3180 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_true
));
3181 have_then_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 1), &seq
);
3182 /* For if (...) { code; } else {} or
3183 if (...) { code; } else goto label; or
3184 if (...) { code; return; } else { ... }
3185 label_cont isn't needed. */
3186 if (!have_else_clause_p
3187 && TREE_OPERAND (expr
, 2) != NULL_TREE
3188 && gimple_seq_may_fallthru (seq
))
3191 label_cont
= create_artificial_label (UNKNOWN_LOCATION
);
3193 g
= gimple_build_goto (label_cont
);
3195 /* GIMPLE_COND's are very low level; they have embedded
3196 gotos. This particular embedded goto should not be marked
3197 with the location of the original COND_EXPR, as it would
3198 correspond to the COND_EXPR's condition, not the ELSE or the
3199 THEN arms. To avoid marking it with the wrong location, flag
3200 it as "no location". */
3201 gimple_set_do_not_emit_location (g
);
3203 gimplify_seq_add_stmt (&seq
, g
);
3207 if (!have_else_clause_p
)
3209 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_false
));
3210 have_else_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 2), &seq
);
3213 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_cont
));
3215 gimple_pop_condition (pre_p
);
3216 gimple_seq_add_seq (pre_p
, seq
);
3218 if (ret
== GS_ERROR
)
3220 else if (have_then_clause_p
|| have_else_clause_p
)
3224 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3225 expr
= TREE_OPERAND (expr
, 0);
3226 gimplify_stmt (&expr
, pre_p
);
3233 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3234 to be marked addressable.
3236 We cannot rely on such an expression being directly markable if a temporary
3237 has been created by the gimplification. In this case, we create another
3238 temporary and initialize it with a copy, which will become a store after we
3239 mark it addressable. This can happen if the front-end passed us something
3240 that it could not mark addressable yet, like a Fortran pass-by-reference
3241 parameter (int) floatvar. */
3244 prepare_gimple_addressable (tree
*expr_p
, gimple_seq
*seq_p
)
3246 while (handled_component_p (*expr_p
))
3247 expr_p
= &TREE_OPERAND (*expr_p
, 0);
3248 if (is_gimple_reg (*expr_p
))
3250 tree var
= get_initialized_tmp_var (*expr_p
, seq_p
, NULL
);
3251 DECL_GIMPLE_REG_P (var
) = 0;
3256 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3257 a call to __builtin_memcpy. */
3259 static enum gimplify_status
3260 gimplify_modify_expr_to_memcpy (tree
*expr_p
, tree size
, bool want_value
,
3263 tree t
, to
, to_ptr
, from
, from_ptr
;
3265 location_t loc
= EXPR_LOCATION (*expr_p
);
3267 to
= TREE_OPERAND (*expr_p
, 0);
3268 from
= TREE_OPERAND (*expr_p
, 1);
3270 /* Mark the RHS addressable. Beware that it may not be possible to do so
3271 directly if a temporary has been created by the gimplification. */
3272 prepare_gimple_addressable (&from
, seq_p
);
3274 mark_addressable (from
);
3275 from_ptr
= build_fold_addr_expr_loc (loc
, from
);
3276 gimplify_arg (&from_ptr
, seq_p
, loc
);
3278 mark_addressable (to
);
3279 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3280 gimplify_arg (&to_ptr
, seq_p
, loc
);
3282 t
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3284 gs
= gimple_build_call (t
, 3, to_ptr
, from_ptr
, size
);
3288 /* tmp = memcpy() */
3289 t
= create_tmp_var (TREE_TYPE (to_ptr
));
3290 gimple_call_set_lhs (gs
, t
);
3291 gimplify_seq_add_stmt (seq_p
, gs
);
3293 *expr_p
= build_simple_mem_ref (t
);
3297 gimplify_seq_add_stmt (seq_p
, gs
);
3302 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3303 a call to __builtin_memset. In this case we know that the RHS is
3304 a CONSTRUCTOR with an empty element list. */
3306 static enum gimplify_status
3307 gimplify_modify_expr_to_memset (tree
*expr_p
, tree size
, bool want_value
,
3310 tree t
, from
, to
, to_ptr
;
3312 location_t loc
= EXPR_LOCATION (*expr_p
);
3314 /* Assert our assumptions, to abort instead of producing wrong code
3315 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3316 not be immediately exposed. */
3317 from
= TREE_OPERAND (*expr_p
, 1);
3318 if (TREE_CODE (from
) == WITH_SIZE_EXPR
)
3319 from
= TREE_OPERAND (from
, 0);
3321 gcc_assert (TREE_CODE (from
) == CONSTRUCTOR
3322 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from
)));
3325 to
= TREE_OPERAND (*expr_p
, 0);
3327 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3328 gimplify_arg (&to_ptr
, seq_p
, loc
);
3329 t
= builtin_decl_implicit (BUILT_IN_MEMSET
);
3331 gs
= gimple_build_call (t
, 3, to_ptr
, integer_zero_node
, size
);
3335 /* tmp = memset() */
3336 t
= create_tmp_var (TREE_TYPE (to_ptr
));
3337 gimple_call_set_lhs (gs
, t
);
3338 gimplify_seq_add_stmt (seq_p
, gs
);
3340 *expr_p
= build1 (INDIRECT_REF
, TREE_TYPE (to
), t
);
3344 gimplify_seq_add_stmt (seq_p
, gs
);
3349 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3350 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3351 assignment. Return non-null if we detect a potential overlap. */
3353 struct gimplify_init_ctor_preeval_data
3355 /* The base decl of the lhs object. May be NULL, in which case we
3356 have to assume the lhs is indirect. */
3359 /* The alias set of the lhs object. */
3360 alias_set_type lhs_alias_set
;
3364 gimplify_init_ctor_preeval_1 (tree
*tp
, int *walk_subtrees
, void *xdata
)
3366 struct gimplify_init_ctor_preeval_data
*data
3367 = (struct gimplify_init_ctor_preeval_data
*) xdata
;
3370 /* If we find the base object, obviously we have overlap. */
3371 if (data
->lhs_base_decl
== t
)
3374 /* If the constructor component is indirect, determine if we have a
3375 potential overlap with the lhs. The only bits of information we
3376 have to go on at this point are addressability and alias sets. */
3377 if ((INDIRECT_REF_P (t
)
3378 || TREE_CODE (t
) == MEM_REF
)
3379 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3380 && alias_sets_conflict_p (data
->lhs_alias_set
, get_alias_set (t
)))
3383 /* If the constructor component is a call, determine if it can hide a
3384 potential overlap with the lhs through an INDIRECT_REF like above.
3385 ??? Ugh - this is completely broken. In fact this whole analysis
3386 doesn't look conservative. */
3387 if (TREE_CODE (t
) == CALL_EXPR
)
3389 tree type
, fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t
)));
3391 for (type
= TYPE_ARG_TYPES (fntype
); type
; type
= TREE_CHAIN (type
))
3392 if (POINTER_TYPE_P (TREE_VALUE (type
))
3393 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3394 && alias_sets_conflict_p (data
->lhs_alias_set
,
3396 (TREE_TYPE (TREE_VALUE (type
)))))
3400 if (IS_TYPE_OR_DECL_P (t
))
3405 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3406 force values that overlap with the lhs (as described by *DATA)
3407 into temporaries. */
3410 gimplify_init_ctor_preeval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3411 struct gimplify_init_ctor_preeval_data
*data
)
3413 enum gimplify_status one
;
3415 /* If the value is constant, then there's nothing to pre-evaluate. */
3416 if (TREE_CONSTANT (*expr_p
))
3418 /* Ensure it does not have side effects, it might contain a reference to
3419 the object we're initializing. */
3420 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p
));
3424 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3425 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p
)))
3428 /* Recurse for nested constructors. */
3429 if (TREE_CODE (*expr_p
) == CONSTRUCTOR
)
3431 unsigned HOST_WIDE_INT ix
;
3432 constructor_elt
*ce
;
3433 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (*expr_p
);
3435 FOR_EACH_VEC_SAFE_ELT (v
, ix
, ce
)
3436 gimplify_init_ctor_preeval (&ce
->value
, pre_p
, post_p
, data
);
3441 /* If this is a variable sized type, we must remember the size. */
3442 maybe_with_size_expr (expr_p
);
3444 /* Gimplify the constructor element to something appropriate for the rhs
3445 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3446 the gimplifier will consider this a store to memory. Doing this
3447 gimplification now means that we won't have to deal with complicated
3448 language-specific trees, nor trees like SAVE_EXPR that can induce
3449 exponential search behavior. */
3450 one
= gimplify_expr (expr_p
, pre_p
, post_p
, is_gimple_mem_rhs
, fb_rvalue
);
3451 if (one
== GS_ERROR
)
3457 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3458 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3459 always be true for all scalars, since is_gimple_mem_rhs insists on a
3460 temporary variable for them. */
3461 if (DECL_P (*expr_p
))
3464 /* If this is of variable size, we have no choice but to assume it doesn't
3465 overlap since we can't make a temporary for it. */
3466 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p
))) != INTEGER_CST
)
3469 /* Otherwise, we must search for overlap ... */
3470 if (!walk_tree (expr_p
, gimplify_init_ctor_preeval_1
, data
, NULL
))
3473 /* ... and if found, force the value into a temporary. */
3474 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
3477 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3478 a RANGE_EXPR in a CONSTRUCTOR for an array.
3482 object[var] = value;
3489 We increment var _after_ the loop exit check because we might otherwise
3490 fail if upper == TYPE_MAX_VALUE (type for upper).
3492 Note that we never have to deal with SAVE_EXPRs here, because this has
3493 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3495 static void gimplify_init_ctor_eval (tree
, vec
<constructor_elt
, va_gc
> *,
3496 gimple_seq
*, bool);
3499 gimplify_init_ctor_eval_range (tree object
, tree lower
, tree upper
,
3500 tree value
, tree array_elt_type
,
3501 gimple_seq
*pre_p
, bool cleared
)
3503 tree loop_entry_label
, loop_exit_label
, fall_thru_label
;
3504 tree var
, var_type
, cref
, tmp
;
3506 loop_entry_label
= create_artificial_label (UNKNOWN_LOCATION
);
3507 loop_exit_label
= create_artificial_label (UNKNOWN_LOCATION
);
3508 fall_thru_label
= create_artificial_label (UNKNOWN_LOCATION
);
3510 /* Create and initialize the index variable. */
3511 var_type
= TREE_TYPE (upper
);
3512 var
= create_tmp_var (var_type
);
3513 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, lower
));
3515 /* Add the loop entry label. */
3516 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_entry_label
));
3518 /* Build the reference. */
3519 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3520 var
, NULL_TREE
, NULL_TREE
);
3522 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3523 the store. Otherwise just assign value to the reference. */
3525 if (TREE_CODE (value
) == CONSTRUCTOR
)
3526 /* NB we might have to call ourself recursively through
3527 gimplify_init_ctor_eval if the value is a constructor. */
3528 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3531 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (cref
, value
));
3533 /* We exit the loop when the index var is equal to the upper bound. */
3534 gimplify_seq_add_stmt (pre_p
,
3535 gimple_build_cond (EQ_EXPR
, var
, upper
,
3536 loop_exit_label
, fall_thru_label
));
3538 gimplify_seq_add_stmt (pre_p
, gimple_build_label (fall_thru_label
));
3540 /* Otherwise, increment the index var... */
3541 tmp
= build2 (PLUS_EXPR
, var_type
, var
,
3542 fold_convert (var_type
, integer_one_node
));
3543 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, tmp
));
3545 /* ...and jump back to the loop entry. */
3546 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (loop_entry_label
));
3548 /* Add the loop exit label. */
3549 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_exit_label
));
3552 /* Return true if FDECL is accessing a field that is zero sized. */
3555 zero_sized_field_decl (const_tree fdecl
)
3557 if (TREE_CODE (fdecl
) == FIELD_DECL
&& DECL_SIZE (fdecl
)
3558 && integer_zerop (DECL_SIZE (fdecl
)))
3563 /* Return true if TYPE is zero sized. */
3566 zero_sized_type (const_tree type
)
3568 if (AGGREGATE_TYPE_P (type
) && TYPE_SIZE (type
)
3569 && integer_zerop (TYPE_SIZE (type
)))
3574 /* A subroutine of gimplify_init_constructor. Generate individual
3575 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3576 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3577 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3581 gimplify_init_ctor_eval (tree object
, vec
<constructor_elt
, va_gc
> *elts
,
3582 gimple_seq
*pre_p
, bool cleared
)
3584 tree array_elt_type
= NULL
;
3585 unsigned HOST_WIDE_INT ix
;
3586 tree purpose
, value
;
3588 if (TREE_CODE (TREE_TYPE (object
)) == ARRAY_TYPE
)
3589 array_elt_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object
)));
3591 FOR_EACH_CONSTRUCTOR_ELT (elts
, ix
, purpose
, value
)
3595 /* NULL values are created above for gimplification errors. */
3599 if (cleared
&& initializer_zerop (value
))
3602 /* ??? Here's to hoping the front end fills in all of the indices,
3603 so we don't have to figure out what's missing ourselves. */
3604 gcc_assert (purpose
);
3606 /* Skip zero-sized fields, unless value has side-effects. This can
3607 happen with calls to functions returning a zero-sized type, which
3608 we shouldn't discard. As a number of downstream passes don't
3609 expect sets of zero-sized fields, we rely on the gimplification of
3610 the MODIFY_EXPR we make below to drop the assignment statement. */
3611 if (! TREE_SIDE_EFFECTS (value
) && zero_sized_field_decl (purpose
))
3614 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3616 if (TREE_CODE (purpose
) == RANGE_EXPR
)
3618 tree lower
= TREE_OPERAND (purpose
, 0);
3619 tree upper
= TREE_OPERAND (purpose
, 1);
3621 /* If the lower bound is equal to upper, just treat it as if
3622 upper was the index. */
3623 if (simple_cst_equal (lower
, upper
))
3627 gimplify_init_ctor_eval_range (object
, lower
, upper
, value
,
3628 array_elt_type
, pre_p
, cleared
);
3635 /* Do not use bitsizetype for ARRAY_REF indices. */
3636 if (TYPE_DOMAIN (TREE_TYPE (object
)))
3638 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object
))),
3640 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3641 purpose
, NULL_TREE
, NULL_TREE
);
3645 gcc_assert (TREE_CODE (purpose
) == FIELD_DECL
);
3646 cref
= build3 (COMPONENT_REF
, TREE_TYPE (purpose
),
3647 unshare_expr (object
), purpose
, NULL_TREE
);
3650 if (TREE_CODE (value
) == CONSTRUCTOR
3651 && TREE_CODE (TREE_TYPE (value
)) != VECTOR_TYPE
)
3652 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3656 tree init
= build2 (INIT_EXPR
, TREE_TYPE (cref
), cref
, value
);
3657 gimplify_and_add (init
, pre_p
);
3663 /* Return the appropriate RHS predicate for this LHS. */
3666 rhs_predicate_for (tree lhs
)
3668 if (is_gimple_reg (lhs
))
3669 return is_gimple_reg_rhs_or_call
;
3671 return is_gimple_mem_rhs_or_call
;
3674 /* Gimplify a C99 compound literal expression. This just means adding
3675 the DECL_EXPR before the current statement and using its anonymous
3678 static enum gimplify_status
3679 gimplify_compound_literal_expr (tree
*expr_p
, gimple_seq
*pre_p
,
3680 bool (*gimple_test_f
) (tree
),
3681 fallback_t fallback
)
3683 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p
);
3684 tree decl
= DECL_EXPR_DECL (decl_s
);
3685 tree init
= DECL_INITIAL (decl
);
3686 /* Mark the decl as addressable if the compound literal
3687 expression is addressable now, otherwise it is marked too late
3688 after we gimplify the initialization expression. */
3689 if (TREE_ADDRESSABLE (*expr_p
))
3690 TREE_ADDRESSABLE (decl
) = 1;
3691 /* Otherwise, if we don't need an lvalue and have a literal directly
3692 substitute it. Check if it matches the gimple predicate, as
3693 otherwise we'd generate a new temporary, and we can as well just
3694 use the decl we already have. */
3695 else if (!TREE_ADDRESSABLE (decl
)
3697 && (fallback
& fb_lvalue
) == 0
3698 && gimple_test_f (init
))
3704 /* Preliminarily mark non-addressed complex variables as eligible
3705 for promotion to gimple registers. We'll transform their uses
3707 if ((TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
3708 || TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
)
3709 && !TREE_THIS_VOLATILE (decl
)
3710 && !needs_to_live_in_memory (decl
))
3711 DECL_GIMPLE_REG_P (decl
) = 1;
3713 /* If the decl is not addressable, then it is being used in some
3714 expression or on the right hand side of a statement, and it can
3715 be put into a readonly data section. */
3716 if (!TREE_ADDRESSABLE (decl
) && (fallback
& fb_lvalue
) == 0)
3717 TREE_READONLY (decl
) = 1;
3719 /* This decl isn't mentioned in the enclosing block, so add it to the
3720 list of temps. FIXME it seems a bit of a kludge to say that
3721 anonymous artificial vars aren't pushed, but everything else is. */
3722 if (DECL_NAME (decl
) == NULL_TREE
&& !DECL_SEEN_IN_BIND_EXPR_P (decl
))
3723 gimple_add_tmp_var (decl
);
3725 gimplify_and_add (decl_s
, pre_p
);
3730 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3731 return a new CONSTRUCTOR if something changed. */
3734 optimize_compound_literals_in_ctor (tree orig_ctor
)
3736 tree ctor
= orig_ctor
;
3737 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
3738 unsigned int idx
, num
= vec_safe_length (elts
);
3740 for (idx
= 0; idx
< num
; idx
++)
3742 tree value
= (*elts
)[idx
].value
;
3743 tree newval
= value
;
3744 if (TREE_CODE (value
) == CONSTRUCTOR
)
3745 newval
= optimize_compound_literals_in_ctor (value
);
3746 else if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
3748 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (value
);
3749 tree decl
= DECL_EXPR_DECL (decl_s
);
3750 tree init
= DECL_INITIAL (decl
);
3752 if (!TREE_ADDRESSABLE (value
)
3753 && !TREE_ADDRESSABLE (decl
)
3755 && TREE_CODE (init
) == CONSTRUCTOR
)
3756 newval
= optimize_compound_literals_in_ctor (init
);
3758 if (newval
== value
)
3761 if (ctor
== orig_ctor
)
3763 ctor
= copy_node (orig_ctor
);
3764 CONSTRUCTOR_ELTS (ctor
) = vec_safe_copy (elts
);
3765 elts
= CONSTRUCTOR_ELTS (ctor
);
3767 (*elts
)[idx
].value
= newval
;
3772 /* A subroutine of gimplify_modify_expr. Break out elements of a
3773 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3775 Note that we still need to clear any elements that don't have explicit
3776 initializers, so if not all elements are initialized we keep the
3777 original MODIFY_EXPR, we just remove all of the constructor elements.
3779 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3780 GS_ERROR if we would have to create a temporary when gimplifying
3781 this constructor. Otherwise, return GS_OK.
3783 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3785 static enum gimplify_status
3786 gimplify_init_constructor (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3787 bool want_value
, bool notify_temp_creation
)
3789 tree object
, ctor
, type
;
3790 enum gimplify_status ret
;
3791 vec
<constructor_elt
, va_gc
> *elts
;
3793 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == CONSTRUCTOR
);
3795 if (!notify_temp_creation
)
3797 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
3798 is_gimple_lvalue
, fb_lvalue
);
3799 if (ret
== GS_ERROR
)
3803 object
= TREE_OPERAND (*expr_p
, 0);
3804 ctor
= TREE_OPERAND (*expr_p
, 1) =
3805 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p
, 1));
3806 type
= TREE_TYPE (ctor
);
3807 elts
= CONSTRUCTOR_ELTS (ctor
);
3810 switch (TREE_CODE (type
))
3814 case QUAL_UNION_TYPE
:
3817 struct gimplify_init_ctor_preeval_data preeval_data
;
3818 HOST_WIDE_INT num_ctor_elements
, num_nonzero_elements
;
3819 bool cleared
, complete_p
, valid_const_initializer
;
3821 /* Aggregate types must lower constructors to initialization of
3822 individual elements. The exception is that a CONSTRUCTOR node
3823 with no elements indicates zero-initialization of the whole. */
3824 if (vec_safe_is_empty (elts
))
3826 if (notify_temp_creation
)
3831 /* Fetch information about the constructor to direct later processing.
3832 We might want to make static versions of it in various cases, and
3833 can only do so if it known to be a valid constant initializer. */
3834 valid_const_initializer
3835 = categorize_ctor_elements (ctor
, &num_nonzero_elements
,
3836 &num_ctor_elements
, &complete_p
);
3838 /* If a const aggregate variable is being initialized, then it
3839 should never be a lose to promote the variable to be static. */
3840 if (valid_const_initializer
3841 && num_nonzero_elements
> 1
3842 && TREE_READONLY (object
)
3843 && TREE_CODE (object
) == VAR_DECL
3844 && (flag_merge_constants
>= 2 || !TREE_ADDRESSABLE (object
)))
3846 if (notify_temp_creation
)
3848 DECL_INITIAL (object
) = ctor
;
3849 TREE_STATIC (object
) = 1;
3850 if (!DECL_NAME (object
))
3851 DECL_NAME (object
) = create_tmp_var_name ("C");
3852 walk_tree (&DECL_INITIAL (object
), force_labels_r
, NULL
, NULL
);
3854 /* ??? C++ doesn't automatically append a .<number> to the
3855 assembler name, and even when it does, it looks at FE private
3856 data structures to figure out what that number should be,
3857 which are not set for this variable. I suppose this is
3858 important for local statics for inline functions, which aren't
3859 "local" in the object file sense. So in order to get a unique
3860 TU-local symbol, we must invoke the lhd version now. */
3861 lhd_set_decl_assembler_name (object
);
3863 *expr_p
= NULL_TREE
;
3867 /* If there are "lots" of initialized elements, even discounting
3868 those that are not address constants (and thus *must* be
3869 computed at runtime), then partition the constructor into
3870 constant and non-constant parts. Block copy the constant
3871 parts in, then generate code for the non-constant parts. */
3872 /* TODO. There's code in cp/typeck.c to do this. */
3874 if (int_size_in_bytes (TREE_TYPE (ctor
)) < 0)
3875 /* store_constructor will ignore the clearing of variable-sized
3876 objects. Initializers for such objects must explicitly set
3877 every field that needs to be set. */
3879 else if (!complete_p
&& !CONSTRUCTOR_NO_CLEARING (ctor
))
3880 /* If the constructor isn't complete, clear the whole object
3881 beforehand, unless CONSTRUCTOR_NO_CLEARING is set on it.
3883 ??? This ought not to be needed. For any element not present
3884 in the initializer, we should simply set them to zero. Except
3885 we'd need to *find* the elements that are not present, and that
3886 requires trickery to avoid quadratic compile-time behavior in
3887 large cases or excessive memory use in small cases. */
3889 else if (num_ctor_elements
- num_nonzero_elements
3890 > CLEAR_RATIO (optimize_function_for_speed_p (cfun
))
3891 && num_nonzero_elements
< num_ctor_elements
/ 4)
3892 /* If there are "lots" of zeros, it's more efficient to clear
3893 the memory and then set the nonzero elements. */
3898 /* If there are "lots" of initialized elements, and all of them
3899 are valid address constants, then the entire initializer can
3900 be dropped to memory, and then memcpy'd out. Don't do this
3901 for sparse arrays, though, as it's more efficient to follow
3902 the standard CONSTRUCTOR behavior of memset followed by
3903 individual element initialization. Also don't do this for small
3904 all-zero initializers (which aren't big enough to merit
3905 clearing), and don't try to make bitwise copies of
3906 TREE_ADDRESSABLE types.
3908 We cannot apply such transformation when compiling chkp static
3909 initializer because creation of initializer image in the memory
3910 will require static initialization of bounds for it. It should
3911 result in another gimplification of similar initializer and we
3912 may fall into infinite loop. */
3913 if (valid_const_initializer
3914 && !(cleared
|| num_nonzero_elements
== 0)
3915 && !TREE_ADDRESSABLE (type
)
3916 && (!current_function_decl
3917 || !lookup_attribute ("chkp ctor",
3918 DECL_ATTRIBUTES (current_function_decl
))))
3920 HOST_WIDE_INT size
= int_size_in_bytes (type
);
3923 /* ??? We can still get unbounded array types, at least
3924 from the C++ front end. This seems wrong, but attempt
3925 to work around it for now. */
3928 size
= int_size_in_bytes (TREE_TYPE (object
));
3930 TREE_TYPE (ctor
) = type
= TREE_TYPE (object
);
3933 /* Find the maximum alignment we can assume for the object. */
3934 /* ??? Make use of DECL_OFFSET_ALIGN. */
3935 if (DECL_P (object
))
3936 align
= DECL_ALIGN (object
);
3938 align
= TYPE_ALIGN (type
);
3940 /* Do a block move either if the size is so small as to make
3941 each individual move a sub-unit move on average, or if it
3942 is so large as to make individual moves inefficient. */
3944 && num_nonzero_elements
> 1
3945 && (size
< num_nonzero_elements
3946 || !can_move_by_pieces (size
, align
)))
3948 if (notify_temp_creation
)
3951 walk_tree (&ctor
, force_labels_r
, NULL
, NULL
);
3952 ctor
= tree_output_constant_def (ctor
);
3953 if (!useless_type_conversion_p (type
, TREE_TYPE (ctor
)))
3954 ctor
= build1 (VIEW_CONVERT_EXPR
, type
, ctor
);
3955 TREE_OPERAND (*expr_p
, 1) = ctor
;
3957 /* This is no longer an assignment of a CONSTRUCTOR, but
3958 we still may have processing to do on the LHS. So
3959 pretend we didn't do anything here to let that happen. */
3960 return GS_UNHANDLED
;
3964 /* If the target is volatile, we have non-zero elements and more than
3965 one field to assign, initialize the target from a temporary. */
3966 if (TREE_THIS_VOLATILE (object
)
3967 && !TREE_ADDRESSABLE (type
)
3968 && num_nonzero_elements
> 0
3969 && vec_safe_length (elts
) > 1)
3971 tree temp
= create_tmp_var (TYPE_MAIN_VARIANT (type
));
3972 TREE_OPERAND (*expr_p
, 0) = temp
;
3973 *expr_p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*expr_p
),
3975 build2 (MODIFY_EXPR
, void_type_node
,
3980 if (notify_temp_creation
)
3983 /* If there are nonzero elements and if needed, pre-evaluate to capture
3984 elements overlapping with the lhs into temporaries. We must do this
3985 before clearing to fetch the values before they are zeroed-out. */
3986 if (num_nonzero_elements
> 0 && TREE_CODE (*expr_p
) != INIT_EXPR
)
3988 preeval_data
.lhs_base_decl
= get_base_address (object
);
3989 if (!DECL_P (preeval_data
.lhs_base_decl
))
3990 preeval_data
.lhs_base_decl
= NULL
;
3991 preeval_data
.lhs_alias_set
= get_alias_set (object
);
3993 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p
, 1),
3994 pre_p
, post_p
, &preeval_data
);
3997 bool ctor_has_side_effects_p
3998 = TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p
, 1));
4002 /* Zap the CONSTRUCTOR element list, which simplifies this case.
4003 Note that we still have to gimplify, in order to handle the
4004 case of variable sized types. Avoid shared tree structures. */
4005 CONSTRUCTOR_ELTS (ctor
) = NULL
;
4006 TREE_SIDE_EFFECTS (ctor
) = 0;
4007 object
= unshare_expr (object
);
4008 gimplify_stmt (expr_p
, pre_p
);
4011 /* If we have not block cleared the object, or if there are nonzero
4012 elements in the constructor, or if the constructor has side effects,
4013 add assignments to the individual scalar fields of the object. */
4015 || num_nonzero_elements
> 0
4016 || ctor_has_side_effects_p
)
4017 gimplify_init_ctor_eval (object
, elts
, pre_p
, cleared
);
4019 *expr_p
= NULL_TREE
;
4027 if (notify_temp_creation
)
4030 /* Extract the real and imaginary parts out of the ctor. */
4031 gcc_assert (elts
->length () == 2);
4032 r
= (*elts
)[0].value
;
4033 i
= (*elts
)[1].value
;
4034 if (r
== NULL
|| i
== NULL
)
4036 tree zero
= build_zero_cst (TREE_TYPE (type
));
4043 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
4044 represent creation of a complex value. */
4045 if (TREE_CONSTANT (r
) && TREE_CONSTANT (i
))
4047 ctor
= build_complex (type
, r
, i
);
4048 TREE_OPERAND (*expr_p
, 1) = ctor
;
4052 ctor
= build2 (COMPLEX_EXPR
, type
, r
, i
);
4053 TREE_OPERAND (*expr_p
, 1) = ctor
;
4054 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1),
4057 rhs_predicate_for (TREE_OPERAND (*expr_p
, 0)),
4065 unsigned HOST_WIDE_INT ix
;
4066 constructor_elt
*ce
;
4068 if (notify_temp_creation
)
4071 /* Go ahead and simplify constant constructors to VECTOR_CST. */
4072 if (TREE_CONSTANT (ctor
))
4074 bool constant_p
= true;
4077 /* Even when ctor is constant, it might contain non-*_CST
4078 elements, such as addresses or trapping values like
4079 1.0/0.0 - 1.0/0.0. Such expressions don't belong
4080 in VECTOR_CST nodes. */
4081 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
4082 if (!CONSTANT_CLASS_P (value
))
4090 TREE_OPERAND (*expr_p
, 1) = build_vector_from_ctor (type
, elts
);
4094 TREE_CONSTANT (ctor
) = 0;
4097 /* Vector types use CONSTRUCTOR all the way through gimple
4098 compilation as a general initializer. */
4099 FOR_EACH_VEC_SAFE_ELT (elts
, ix
, ce
)
4101 enum gimplify_status tret
;
4102 tret
= gimplify_expr (&ce
->value
, pre_p
, post_p
, is_gimple_val
,
4104 if (tret
== GS_ERROR
)
4107 if (!is_gimple_reg (TREE_OPERAND (*expr_p
, 0)))
4108 TREE_OPERAND (*expr_p
, 1) = get_formal_tmp_var (ctor
, pre_p
);
4113 /* So how did we get a CONSTRUCTOR for a scalar type? */
4117 if (ret
== GS_ERROR
)
4119 else if (want_value
)
4126 /* If we have gimplified both sides of the initializer but have
4127 not emitted an assignment, do so now. */
4130 tree lhs
= TREE_OPERAND (*expr_p
, 0);
4131 tree rhs
= TREE_OPERAND (*expr_p
, 1);
4132 gassign
*init
= gimple_build_assign (lhs
, rhs
);
4133 gimplify_seq_add_stmt (pre_p
, init
);
4141 /* Given a pointer value OP0, return a simplified version of an
4142 indirection through OP0, or NULL_TREE if no simplification is
4143 possible. This may only be applied to a rhs of an expression.
4144 Note that the resulting type may be different from the type pointed
4145 to in the sense that it is still compatible from the langhooks
4149 gimple_fold_indirect_ref_rhs (tree t
)
4151 return gimple_fold_indirect_ref (t
);
4154 /* Subroutine of gimplify_modify_expr to do simplifications of
4155 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4156 something changes. */
4158 static enum gimplify_status
4159 gimplify_modify_expr_rhs (tree
*expr_p
, tree
*from_p
, tree
*to_p
,
4160 gimple_seq
*pre_p
, gimple_seq
*post_p
,
4163 enum gimplify_status ret
= GS_UNHANDLED
;
4169 switch (TREE_CODE (*from_p
))
4172 /* If we're assigning from a read-only variable initialized with
4173 a constructor, do the direct assignment from the constructor,
4174 but only if neither source nor target are volatile since this
4175 latter assignment might end up being done on a per-field basis. */
4176 if (DECL_INITIAL (*from_p
)
4177 && TREE_READONLY (*from_p
)
4178 && !TREE_THIS_VOLATILE (*from_p
)
4179 && !TREE_THIS_VOLATILE (*to_p
)
4180 && TREE_CODE (DECL_INITIAL (*from_p
)) == CONSTRUCTOR
)
4182 tree old_from
= *from_p
;
4183 enum gimplify_status subret
;
4185 /* Move the constructor into the RHS. */
4186 *from_p
= unshare_expr (DECL_INITIAL (*from_p
));
4188 /* Let's see if gimplify_init_constructor will need to put
4190 subret
= gimplify_init_constructor (expr_p
, NULL
, NULL
,
4192 if (subret
== GS_ERROR
)
4194 /* If so, revert the change. */
4206 /* If we have code like
4210 where the type of "x" is a (possibly cv-qualified variant
4211 of "A"), treat the entire expression as identical to "x".
4212 This kind of code arises in C++ when an object is bound
4213 to a const reference, and if "x" is a TARGET_EXPR we want
4214 to take advantage of the optimization below. */
4215 bool volatile_p
= TREE_THIS_VOLATILE (*from_p
);
4216 tree t
= gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p
, 0));
4219 if (TREE_THIS_VOLATILE (t
) != volatile_p
)
4221 if (TREE_CODE_CLASS (TREE_CODE (t
)) == tcc_declaration
)
4222 t
= build_simple_mem_ref_loc (EXPR_LOCATION (*from_p
),
4223 build_fold_addr_expr (t
));
4224 if (REFERENCE_CLASS_P (t
))
4225 TREE_THIS_VOLATILE (t
) = volatile_p
;
4236 /* If we are initializing something from a TARGET_EXPR, strip the
4237 TARGET_EXPR and initialize it directly, if possible. This can't
4238 be done if the initializer is void, since that implies that the
4239 temporary is set in some non-trivial way.
4241 ??? What about code that pulls out the temp and uses it
4242 elsewhere? I think that such code never uses the TARGET_EXPR as
4243 an initializer. If I'm wrong, we'll die because the temp won't
4244 have any RTL. In that case, I guess we'll need to replace
4245 references somehow. */
4246 tree init
= TARGET_EXPR_INITIAL (*from_p
);
4249 && !VOID_TYPE_P (TREE_TYPE (init
)))
4259 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4261 gimplify_compound_expr (from_p
, pre_p
, true);
4267 /* If we already made some changes, let the front end have a
4268 crack at this before we break it down. */
4269 if (ret
!= GS_UNHANDLED
)
4271 /* If we're initializing from a CONSTRUCTOR, break this into
4272 individual MODIFY_EXPRs. */
4273 return gimplify_init_constructor (expr_p
, pre_p
, post_p
, want_value
,
4277 /* If we're assigning to a non-register type, push the assignment
4278 down into the branches. This is mandatory for ADDRESSABLE types,
4279 since we cannot generate temporaries for such, but it saves a
4280 copy in other cases as well. */
4281 if (!is_gimple_reg_type (TREE_TYPE (*from_p
)))
4283 /* This code should mirror the code in gimplify_cond_expr. */
4284 enum tree_code code
= TREE_CODE (*expr_p
);
4285 tree cond
= *from_p
;
4286 tree result
= *to_p
;
4288 ret
= gimplify_expr (&result
, pre_p
, post_p
,
4289 is_gimple_lvalue
, fb_lvalue
);
4290 if (ret
!= GS_ERROR
)
4293 if (TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
)
4294 TREE_OPERAND (cond
, 1)
4295 = build2 (code
, void_type_node
, result
,
4296 TREE_OPERAND (cond
, 1));
4297 if (TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
4298 TREE_OPERAND (cond
, 2)
4299 = build2 (code
, void_type_node
, unshare_expr (result
),
4300 TREE_OPERAND (cond
, 2));
4302 TREE_TYPE (cond
) = void_type_node
;
4303 recalculate_side_effects (cond
);
4307 gimplify_and_add (cond
, pre_p
);
4308 *expr_p
= unshare_expr (result
);
4317 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4318 return slot so that we don't generate a temporary. */
4319 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p
)
4320 && aggregate_value_p (*from_p
, *from_p
))
4324 if (!(rhs_predicate_for (*to_p
))(*from_p
))
4325 /* If we need a temporary, *to_p isn't accurate. */
4327 /* It's OK to use the return slot directly unless it's an NRV. */
4328 else if (TREE_CODE (*to_p
) == RESULT_DECL
4329 && DECL_NAME (*to_p
) == NULL_TREE
4330 && needs_to_live_in_memory (*to_p
))
4332 else if (is_gimple_reg_type (TREE_TYPE (*to_p
))
4333 || (DECL_P (*to_p
) && DECL_REGISTER (*to_p
)))
4334 /* Don't force regs into memory. */
4336 else if (TREE_CODE (*expr_p
) == INIT_EXPR
)
4337 /* It's OK to use the target directly if it's being
4340 else if (variably_modified_type_p (TREE_TYPE (*to_p
), NULL_TREE
))
4341 /* Always use the target and thus RSO for variable-sized types.
4342 GIMPLE cannot deal with a variable-sized assignment
4343 embedded in a call statement. */
4345 else if (TREE_CODE (*to_p
) != SSA_NAME
4346 && (!is_gimple_variable (*to_p
)
4347 || needs_to_live_in_memory (*to_p
)))
4348 /* Don't use the original target if it's already addressable;
4349 if its address escapes, and the called function uses the
4350 NRV optimization, a conforming program could see *to_p
4351 change before the called function returns; see c++/19317.
4352 When optimizing, the return_slot pass marks more functions
4353 as safe after we have escape info. */
4360 CALL_EXPR_RETURN_SLOT_OPT (*from_p
) = 1;
4361 mark_addressable (*to_p
);
4366 case WITH_SIZE_EXPR
:
4367 /* Likewise for calls that return an aggregate of non-constant size,
4368 since we would not be able to generate a temporary at all. */
4369 if (TREE_CODE (TREE_OPERAND (*from_p
, 0)) == CALL_EXPR
)
4371 *from_p
= TREE_OPERAND (*from_p
, 0);
4372 /* We don't change ret in this case because the
4373 WITH_SIZE_EXPR might have been added in
4374 gimplify_modify_expr, so returning GS_OK would lead to an
4380 /* If we're initializing from a container, push the initialization
4382 case CLEANUP_POINT_EXPR
:
4384 case STATEMENT_LIST
:
4386 tree wrap
= *from_p
;
4389 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_min_lval
,
4391 if (ret
!= GS_ERROR
)
4394 t
= voidify_wrapper_expr (wrap
, *expr_p
);
4395 gcc_assert (t
== *expr_p
);
4399 gimplify_and_add (wrap
, pre_p
);
4400 *expr_p
= unshare_expr (*to_p
);
4407 case COMPOUND_LITERAL_EXPR
:
4409 tree complit
= TREE_OPERAND (*expr_p
, 1);
4410 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (complit
);
4411 tree decl
= DECL_EXPR_DECL (decl_s
);
4412 tree init
= DECL_INITIAL (decl
);
4414 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4415 into struct T x = { 0, 1, 2 } if the address of the
4416 compound literal has never been taken. */
4417 if (!TREE_ADDRESSABLE (complit
)
4418 && !TREE_ADDRESSABLE (decl
)
4421 *expr_p
= copy_node (*expr_p
);
4422 TREE_OPERAND (*expr_p
, 1) = init
;
4437 /* Return true if T looks like a valid GIMPLE statement. */
4440 is_gimple_stmt (tree t
)
4442 const enum tree_code code
= TREE_CODE (t
);
4447 /* The only valid NOP_EXPR is the empty statement. */
4448 return IS_EMPTY_STMT (t
);
4452 /* These are only valid if they're void. */
4453 return TREE_TYPE (t
) == NULL
|| VOID_TYPE_P (TREE_TYPE (t
));
4459 case CASE_LABEL_EXPR
:
4460 case TRY_CATCH_EXPR
:
4461 case TRY_FINALLY_EXPR
:
4462 case EH_FILTER_EXPR
:
4465 case STATEMENT_LIST
:
4469 case OACC_HOST_DATA
:
4472 case OACC_ENTER_DATA
:
4473 case OACC_EXIT_DATA
:
4479 case OMP_DISTRIBUTE
:
4489 /* These are always void. */
4495 /* These are valid regardless of their type. */
4504 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4505 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4506 DECL_GIMPLE_REG_P set.
4508 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4509 other, unmodified part of the complex object just before the total store.
4510 As a consequence, if the object is still uninitialized, an undefined value
4511 will be loaded into a register, which may result in a spurious exception
4512 if the register is floating-point and the value happens to be a signaling
4513 NaN for example. Then the fully-fledged complex operations lowering pass
4514 followed by a DCE pass are necessary in order to fix things up. */
4516 static enum gimplify_status
4517 gimplify_modify_expr_complex_part (tree
*expr_p
, gimple_seq
*pre_p
,
4520 enum tree_code code
, ocode
;
4521 tree lhs
, rhs
, new_rhs
, other
, realpart
, imagpart
;
4523 lhs
= TREE_OPERAND (*expr_p
, 0);
4524 rhs
= TREE_OPERAND (*expr_p
, 1);
4525 code
= TREE_CODE (lhs
);
4526 lhs
= TREE_OPERAND (lhs
, 0);
4528 ocode
= code
== REALPART_EXPR
? IMAGPART_EXPR
: REALPART_EXPR
;
4529 other
= build1 (ocode
, TREE_TYPE (rhs
), lhs
);
4530 TREE_NO_WARNING (other
) = 1;
4531 other
= get_formal_tmp_var (other
, pre_p
);
4533 realpart
= code
== REALPART_EXPR
? rhs
: other
;
4534 imagpart
= code
== REALPART_EXPR
? other
: rhs
;
4536 if (TREE_CONSTANT (realpart
) && TREE_CONSTANT (imagpart
))
4537 new_rhs
= build_complex (TREE_TYPE (lhs
), realpart
, imagpart
);
4539 new_rhs
= build2 (COMPLEX_EXPR
, TREE_TYPE (lhs
), realpart
, imagpart
);
4541 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (lhs
, new_rhs
));
4542 *expr_p
= (want_value
) ? rhs
: NULL_TREE
;
4547 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4553 PRE_P points to the list where side effects that must happen before
4554 *EXPR_P should be stored.
4556 POST_P points to the list where side effects that must happen after
4557 *EXPR_P should be stored.
4559 WANT_VALUE is nonzero iff we want to use the value of this expression
4560 in another expression. */
4562 static enum gimplify_status
4563 gimplify_modify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4566 tree
*from_p
= &TREE_OPERAND (*expr_p
, 1);
4567 tree
*to_p
= &TREE_OPERAND (*expr_p
, 0);
4568 enum gimplify_status ret
= GS_UNHANDLED
;
4570 location_t loc
= EXPR_LOCATION (*expr_p
);
4571 gimple_stmt_iterator gsi
;
4572 tree ap
= NULL_TREE
, ap_copy
= NULL_TREE
;
4574 gcc_assert (TREE_CODE (*expr_p
) == MODIFY_EXPR
4575 || TREE_CODE (*expr_p
) == INIT_EXPR
);
4577 /* Trying to simplify a clobber using normal logic doesn't work,
4578 so handle it here. */
4579 if (TREE_CLOBBER_P (*from_p
))
4581 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4582 if (ret
== GS_ERROR
)
4584 gcc_assert (!want_value
4585 && (TREE_CODE (*to_p
) == VAR_DECL
4586 || TREE_CODE (*to_p
) == MEM_REF
));
4587 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (*to_p
, *from_p
));
4592 /* Insert pointer conversions required by the middle-end that are not
4593 required by the frontend. This fixes middle-end type checking for
4594 for example gcc.dg/redecl-6.c. */
4595 if (POINTER_TYPE_P (TREE_TYPE (*to_p
)))
4597 STRIP_USELESS_TYPE_CONVERSION (*from_p
);
4598 if (!useless_type_conversion_p (TREE_TYPE (*to_p
), TREE_TYPE (*from_p
)))
4599 *from_p
= fold_convert_loc (loc
, TREE_TYPE (*to_p
), *from_p
);
4602 /* See if any simplifications can be done based on what the RHS is. */
4603 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4605 if (ret
!= GS_UNHANDLED
)
4608 /* For zero sized types only gimplify the left hand side and right hand
4609 side as statements and throw away the assignment. Do this after
4610 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4612 if (zero_sized_type (TREE_TYPE (*from_p
)) && !want_value
)
4614 gimplify_stmt (from_p
, pre_p
);
4615 gimplify_stmt (to_p
, pre_p
);
4616 *expr_p
= NULL_TREE
;
4620 /* If the value being copied is of variable width, compute the length
4621 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4622 before gimplifying any of the operands so that we can resolve any
4623 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4624 the size of the expression to be copied, not of the destination, so
4625 that is what we must do here. */
4626 maybe_with_size_expr (from_p
);
4628 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4629 if (ret
== GS_ERROR
)
4632 /* As a special case, we have to temporarily allow for assignments
4633 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4634 a toplevel statement, when gimplifying the GENERIC expression
4635 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4636 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4638 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4639 prevent gimplify_expr from trying to create a new temporary for
4640 foo's LHS, we tell it that it should only gimplify until it
4641 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4642 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4643 and all we need to do here is set 'a' to be its LHS. */
4644 ret
= gimplify_expr (from_p
, pre_p
, post_p
, rhs_predicate_for (*to_p
),
4646 if (ret
== GS_ERROR
)
4649 /* In case of va_arg internal fn wrappped in a WITH_SIZE_EXPR, add the type
4650 size as argument to the the call. */
4651 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
4653 tree call
= TREE_OPERAND (*from_p
, 0);
4654 tree vlasize
= TREE_OPERAND (*from_p
, 1);
4656 if (TREE_CODE (call
) == CALL_EXPR
4657 && CALL_EXPR_IFN (call
) == IFN_VA_ARG
)
4659 tree type
= TREE_TYPE (call
);
4660 tree ap
= CALL_EXPR_ARG (call
, 0);
4661 tree tag
= CALL_EXPR_ARG (call
, 1);
4662 tree newcall
= build_call_expr_internal_loc (EXPR_LOCATION (call
),
4663 IFN_VA_ARG
, type
, 3, ap
,
4665 tree
*call_p
= &(TREE_OPERAND (*from_p
, 0));
4670 /* Now see if the above changed *from_p to something we handle specially. */
4671 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4673 if (ret
!= GS_UNHANDLED
)
4676 /* If we've got a variable sized assignment between two lvalues (i.e. does
4677 not involve a call), then we can make things a bit more straightforward
4678 by converting the assignment to memcpy or memset. */
4679 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
4681 tree from
= TREE_OPERAND (*from_p
, 0);
4682 tree size
= TREE_OPERAND (*from_p
, 1);
4684 if (TREE_CODE (from
) == CONSTRUCTOR
)
4685 return gimplify_modify_expr_to_memset (expr_p
, size
, want_value
, pre_p
);
4687 if (is_gimple_addressable (from
))
4690 return gimplify_modify_expr_to_memcpy (expr_p
, size
, want_value
,
4695 /* Transform partial stores to non-addressable complex variables into
4696 total stores. This allows us to use real instead of virtual operands
4697 for these variables, which improves optimization. */
4698 if ((TREE_CODE (*to_p
) == REALPART_EXPR
4699 || TREE_CODE (*to_p
) == IMAGPART_EXPR
)
4700 && is_gimple_reg (TREE_OPERAND (*to_p
, 0)))
4701 return gimplify_modify_expr_complex_part (expr_p
, pre_p
, want_value
);
4703 /* Try to alleviate the effects of the gimplification creating artificial
4704 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
4705 if (!gimplify_ctxp
->into_ssa
4706 && TREE_CODE (*from_p
) == VAR_DECL
4707 && DECL_IGNORED_P (*from_p
)
4709 && !DECL_IGNORED_P (*to_p
))
4711 if (!DECL_NAME (*from_p
) && DECL_NAME (*to_p
))
4713 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p
)));
4714 DECL_HAS_DEBUG_EXPR_P (*from_p
) = 1;
4715 SET_DECL_DEBUG_EXPR (*from_p
, *to_p
);
4718 if (want_value
&& TREE_THIS_VOLATILE (*to_p
))
4719 *from_p
= get_initialized_tmp_var (*from_p
, pre_p
, post_p
);
4721 if (TREE_CODE (*from_p
) == CALL_EXPR
)
4723 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4724 instead of a GIMPLE_ASSIGN. */
4726 if (CALL_EXPR_FN (*from_p
) == NULL_TREE
)
4728 /* Gimplify internal functions created in the FEs. */
4729 int nargs
= call_expr_nargs (*from_p
), i
;
4730 enum internal_fn ifn
= CALL_EXPR_IFN (*from_p
);
4731 auto_vec
<tree
> vargs (nargs
);
4733 if (ifn
== IFN_VA_ARG
)
4734 ap
= unshare_expr (CALL_EXPR_ARG (*from_p
, 0));
4735 for (i
= 0; i
< nargs
; i
++)
4737 gimplify_arg (&CALL_EXPR_ARG (*from_p
, i
), pre_p
,
4738 EXPR_LOCATION (*from_p
));
4739 vargs
.quick_push (CALL_EXPR_ARG (*from_p
, i
));
4741 if (ifn
== IFN_VA_ARG
)
4742 ap_copy
= CALL_EXPR_ARG (*from_p
, 0);
4743 call_stmt
= gimple_build_call_internal_vec (ifn
, vargs
);
4744 gimple_set_location (call_stmt
, EXPR_LOCATION (*expr_p
));
4748 tree fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*from_p
));
4749 CALL_EXPR_FN (*from_p
) = TREE_OPERAND (CALL_EXPR_FN (*from_p
), 0);
4750 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p
));
4751 tree fndecl
= get_callee_fndecl (*from_p
);
4753 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
4754 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_EXPECT
4755 && call_expr_nargs (*from_p
) == 3)
4756 call_stmt
= gimple_build_call_internal (IFN_BUILTIN_EXPECT
, 3,
4757 CALL_EXPR_ARG (*from_p
, 0),
4758 CALL_EXPR_ARG (*from_p
, 1),
4759 CALL_EXPR_ARG (*from_p
, 2));
4762 call_stmt
= gimple_build_call_from_tree (*from_p
);
4763 gimple_call_set_fntype (call_stmt
, TREE_TYPE (fnptrtype
));
4766 notice_special_calls (call_stmt
);
4767 if (!gimple_call_noreturn_p (call_stmt
))
4768 gimple_call_set_lhs (call_stmt
, *to_p
);
4773 assign
= gimple_build_assign (*to_p
, *from_p
);
4774 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
4777 if (gimplify_ctxp
->into_ssa
&& is_gimple_reg (*to_p
))
4779 /* We should have got an SSA name from the start. */
4780 gcc_assert (TREE_CODE (*to_p
) == SSA_NAME
);
4783 gimplify_seq_add_stmt (pre_p
, assign
);
4784 gsi
= gsi_last (*pre_p
);
4785 maybe_fold_stmt (&gsi
);
4787 /* When gimplifying the &ap argument of va_arg, we might end up with
4790 We need to assign ap.1 back to ap, otherwise va_arg has no effect on
4793 && TREE_CODE (ap
) == ADDR_EXPR
4794 && TREE_CODE (ap_copy
) == ADDR_EXPR
4795 && TREE_OPERAND (ap
, 0) != TREE_OPERAND (ap_copy
, 0))
4796 gimplify_assign (TREE_OPERAND (ap
, 0), TREE_OPERAND (ap_copy
, 0), pre_p
);
4800 *expr_p
= TREE_THIS_VOLATILE (*to_p
) ? *from_p
: unshare_expr (*to_p
);
4809 /* Gimplify a comparison between two variable-sized objects. Do this
4810 with a call to BUILT_IN_MEMCMP. */
4812 static enum gimplify_status
4813 gimplify_variable_sized_compare (tree
*expr_p
)
4815 location_t loc
= EXPR_LOCATION (*expr_p
);
4816 tree op0
= TREE_OPERAND (*expr_p
, 0);
4817 tree op1
= TREE_OPERAND (*expr_p
, 1);
4818 tree t
, arg
, dest
, src
, expr
;
4820 arg
= TYPE_SIZE_UNIT (TREE_TYPE (op0
));
4821 arg
= unshare_expr (arg
);
4822 arg
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg
, op0
);
4823 src
= build_fold_addr_expr_loc (loc
, op1
);
4824 dest
= build_fold_addr_expr_loc (loc
, op0
);
4825 t
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
4826 t
= build_call_expr_loc (loc
, t
, 3, dest
, src
, arg
);
4829 = build2 (TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), t
, integer_zero_node
);
4830 SET_EXPR_LOCATION (expr
, loc
);
4836 /* Gimplify a comparison between two aggregate objects of integral scalar
4837 mode as a comparison between the bitwise equivalent scalar values. */
4839 static enum gimplify_status
4840 gimplify_scalar_mode_aggregate_compare (tree
*expr_p
)
4842 location_t loc
= EXPR_LOCATION (*expr_p
);
4843 tree op0
= TREE_OPERAND (*expr_p
, 0);
4844 tree op1
= TREE_OPERAND (*expr_p
, 1);
4846 tree type
= TREE_TYPE (op0
);
4847 tree scalar_type
= lang_hooks
.types
.type_for_mode (TYPE_MODE (type
), 1);
4849 op0
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op0
);
4850 op1
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op1
);
4853 = fold_build2_loc (loc
, TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), op0
, op1
);
4858 /* Gimplify an expression sequence. This function gimplifies each
4859 expression and rewrites the original expression with the last
4860 expression of the sequence in GIMPLE form.
4862 PRE_P points to the list where the side effects for all the
4863 expressions in the sequence will be emitted.
4865 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
4867 static enum gimplify_status
4868 gimplify_compound_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
4874 tree
*sub_p
= &TREE_OPERAND (t
, 0);
4876 if (TREE_CODE (*sub_p
) == COMPOUND_EXPR
)
4877 gimplify_compound_expr (sub_p
, pre_p
, false);
4879 gimplify_stmt (sub_p
, pre_p
);
4881 t
= TREE_OPERAND (t
, 1);
4883 while (TREE_CODE (t
) == COMPOUND_EXPR
);
4890 gimplify_stmt (expr_p
, pre_p
);
4895 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
4896 gimplify. After gimplification, EXPR_P will point to a new temporary
4897 that holds the original value of the SAVE_EXPR node.
4899 PRE_P points to the list where side effects that must happen before
4900 *EXPR_P should be stored. */
4902 static enum gimplify_status
4903 gimplify_save_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4905 enum gimplify_status ret
= GS_ALL_DONE
;
4908 gcc_assert (TREE_CODE (*expr_p
) == SAVE_EXPR
);
4909 val
= TREE_OPERAND (*expr_p
, 0);
4911 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
4912 if (!SAVE_EXPR_RESOLVED_P (*expr_p
))
4914 /* The operand may be a void-valued expression such as SAVE_EXPRs
4915 generated by the Java frontend for class initialization. It is
4916 being executed only for its side-effects. */
4917 if (TREE_TYPE (val
) == void_type_node
)
4919 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
4920 is_gimple_stmt
, fb_none
);
4924 val
= get_initialized_tmp_var (val
, pre_p
, post_p
);
4926 TREE_OPERAND (*expr_p
, 0) = val
;
4927 SAVE_EXPR_RESOLVED_P (*expr_p
) = 1;
4935 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
4942 PRE_P points to the list where side effects that must happen before
4943 *EXPR_P should be stored.
4945 POST_P points to the list where side effects that must happen after
4946 *EXPR_P should be stored. */
4948 static enum gimplify_status
4949 gimplify_addr_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4951 tree expr
= *expr_p
;
4952 tree op0
= TREE_OPERAND (expr
, 0);
4953 enum gimplify_status ret
;
4954 location_t loc
= EXPR_LOCATION (*expr_p
);
4956 switch (TREE_CODE (op0
))
4960 /* Check if we are dealing with an expression of the form '&*ptr'.
4961 While the front end folds away '&*ptr' into 'ptr', these
4962 expressions may be generated internally by the compiler (e.g.,
4963 builtins like __builtin_va_end). */
4964 /* Caution: the silent array decomposition semantics we allow for
4965 ADDR_EXPR means we can't always discard the pair. */
4966 /* Gimplification of the ADDR_EXPR operand may drop
4967 cv-qualification conversions, so make sure we add them if
4970 tree op00
= TREE_OPERAND (op0
, 0);
4971 tree t_expr
= TREE_TYPE (expr
);
4972 tree t_op00
= TREE_TYPE (op00
);
4974 if (!useless_type_conversion_p (t_expr
, t_op00
))
4975 op00
= fold_convert_loc (loc
, TREE_TYPE (expr
), op00
);
4981 case VIEW_CONVERT_EXPR
:
4982 /* Take the address of our operand and then convert it to the type of
4985 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
4986 all clear. The impact of this transformation is even less clear. */
4988 /* If the operand is a useless conversion, look through it. Doing so
4989 guarantees that the ADDR_EXPR and its operand will remain of the
4991 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0
, 0)))
4992 op0
= TREE_OPERAND (op0
, 0);
4994 *expr_p
= fold_convert_loc (loc
, TREE_TYPE (expr
),
4995 build_fold_addr_expr_loc (loc
,
4996 TREE_OPERAND (op0
, 0)));
5001 /* If we see a call to a declared builtin or see its address
5002 being taken (we can unify those cases here) then we can mark
5003 the builtin for implicit generation by GCC. */
5004 if (TREE_CODE (op0
) == FUNCTION_DECL
5005 && DECL_BUILT_IN_CLASS (op0
) == BUILT_IN_NORMAL
5006 && builtin_decl_declared_p (DECL_FUNCTION_CODE (op0
)))
5007 set_builtin_decl_implicit_p (DECL_FUNCTION_CODE (op0
), true);
5009 /* We use fb_either here because the C frontend sometimes takes
5010 the address of a call that returns a struct; see
5011 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
5012 the implied temporary explicit. */
5014 /* Make the operand addressable. */
5015 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, post_p
,
5016 is_gimple_addressable
, fb_either
);
5017 if (ret
== GS_ERROR
)
5020 /* Then mark it. Beware that it may not be possible to do so directly
5021 if a temporary has been created by the gimplification. */
5022 prepare_gimple_addressable (&TREE_OPERAND (expr
, 0), pre_p
);
5024 op0
= TREE_OPERAND (expr
, 0);
5026 /* For various reasons, the gimplification of the expression
5027 may have made a new INDIRECT_REF. */
5028 if (TREE_CODE (op0
) == INDIRECT_REF
)
5029 goto do_indirect_ref
;
5031 mark_addressable (TREE_OPERAND (expr
, 0));
5033 /* The FEs may end up building ADDR_EXPRs early on a decl with
5034 an incomplete type. Re-build ADDR_EXPRs in canonical form
5036 if (!types_compatible_p (TREE_TYPE (op0
), TREE_TYPE (TREE_TYPE (expr
))))
5037 *expr_p
= build_fold_addr_expr (op0
);
5039 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
5040 recompute_tree_invariant_for_addr_expr (*expr_p
);
5042 /* If we re-built the ADDR_EXPR add a conversion to the original type
5044 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
5045 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
5053 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
5054 value; output operands should be a gimple lvalue. */
5056 static enum gimplify_status
5057 gimplify_asm_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5061 const char **oconstraints
;
5064 const char *constraint
;
5065 bool allows_mem
, allows_reg
, is_inout
;
5066 enum gimplify_status ret
, tret
;
5068 vec
<tree
, va_gc
> *inputs
;
5069 vec
<tree
, va_gc
> *outputs
;
5070 vec
<tree
, va_gc
> *clobbers
;
5071 vec
<tree
, va_gc
> *labels
;
5075 noutputs
= list_length (ASM_OUTPUTS (expr
));
5076 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
5084 link_next
= NULL_TREE
;
5085 for (i
= 0, link
= ASM_OUTPUTS (expr
); link
; ++i
, link
= link_next
)
5088 size_t constraint_len
;
5090 link_next
= TREE_CHAIN (link
);
5094 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5095 constraint_len
= strlen (constraint
);
5096 if (constraint_len
== 0)
5099 ok
= parse_output_constraint (&constraint
, i
, 0, 0,
5100 &allows_mem
, &allows_reg
, &is_inout
);
5107 if (!allows_reg
&& allows_mem
)
5108 mark_addressable (TREE_VALUE (link
));
5110 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5111 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
5112 fb_lvalue
| fb_mayfail
);
5113 if (tret
== GS_ERROR
)
5115 error ("invalid lvalue in asm output %d", i
);
5119 vec_safe_push (outputs
, link
);
5120 TREE_CHAIN (link
) = NULL_TREE
;
5124 /* An input/output operand. To give the optimizers more
5125 flexibility, split it into separate input and output
5130 /* Turn the in/out constraint into an output constraint. */
5131 char *p
= xstrdup (constraint
);
5133 TREE_VALUE (TREE_PURPOSE (link
)) = build_string (constraint_len
, p
);
5135 /* And add a matching input constraint. */
5138 sprintf (buf
, "%d", i
);
5140 /* If there are multiple alternatives in the constraint,
5141 handle each of them individually. Those that allow register
5142 will be replaced with operand number, the others will stay
5144 if (strchr (p
, ',') != NULL
)
5146 size_t len
= 0, buflen
= strlen (buf
);
5147 char *beg
, *end
, *str
, *dst
;
5151 end
= strchr (beg
, ',');
5153 end
= strchr (beg
, '\0');
5154 if ((size_t) (end
- beg
) < buflen
)
5157 len
+= end
- beg
+ 1;
5164 str
= (char *) alloca (len
);
5165 for (beg
= p
+ 1, dst
= str
;;)
5168 bool mem_p
, reg_p
, inout_p
;
5170 end
= strchr (beg
, ',');
5175 parse_output_constraint (&tem
, i
, 0, 0,
5176 &mem_p
, ®_p
, &inout_p
);
5181 memcpy (dst
, buf
, buflen
);
5190 memcpy (dst
, beg
, len
);
5199 input
= build_string (dst
- str
, str
);
5202 input
= build_string (strlen (buf
), buf
);
5205 input
= build_string (constraint_len
- 1, constraint
+ 1);
5209 input
= build_tree_list (build_tree_list (NULL_TREE
, input
),
5210 unshare_expr (TREE_VALUE (link
)));
5211 ASM_INPUTS (expr
) = chainon (ASM_INPUTS (expr
), input
);
5215 link_next
= NULL_TREE
;
5216 for (link
= ASM_INPUTS (expr
); link
; ++i
, link
= link_next
)
5218 link_next
= TREE_CHAIN (link
);
5219 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5220 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
5221 oconstraints
, &allows_mem
, &allows_reg
);
5223 /* If we can't make copies, we can only accept memory. */
5224 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link
))))
5230 error ("impossible constraint in %<asm%>");
5231 error ("non-memory input %d must stay in memory", i
);
5236 /* If the operand is a memory input, it should be an lvalue. */
5237 if (!allows_reg
&& allows_mem
)
5239 tree inputv
= TREE_VALUE (link
);
5240 STRIP_NOPS (inputv
);
5241 if (TREE_CODE (inputv
) == PREDECREMENT_EXPR
5242 || TREE_CODE (inputv
) == PREINCREMENT_EXPR
5243 || TREE_CODE (inputv
) == POSTDECREMENT_EXPR
5244 || TREE_CODE (inputv
) == POSTINCREMENT_EXPR
)
5245 TREE_VALUE (link
) = error_mark_node
;
5246 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5247 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
5248 mark_addressable (TREE_VALUE (link
));
5249 if (tret
== GS_ERROR
)
5251 if (EXPR_HAS_LOCATION (TREE_VALUE (link
)))
5252 input_location
= EXPR_LOCATION (TREE_VALUE (link
));
5253 error ("memory input %d is not directly addressable", i
);
5259 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5260 is_gimple_asm_val
, fb_rvalue
);
5261 if (tret
== GS_ERROR
)
5265 TREE_CHAIN (link
) = NULL_TREE
;
5266 vec_safe_push (inputs
, link
);
5269 link_next
= NULL_TREE
;
5270 for (link
= ASM_CLOBBERS (expr
); link
; ++i
, link
= link_next
)
5272 link_next
= TREE_CHAIN (link
);
5273 TREE_CHAIN (link
) = NULL_TREE
;
5274 vec_safe_push (clobbers
, link
);
5277 link_next
= NULL_TREE
;
5278 for (link
= ASM_LABELS (expr
); link
; ++i
, link
= link_next
)
5280 link_next
= TREE_CHAIN (link
);
5281 TREE_CHAIN (link
) = NULL_TREE
;
5282 vec_safe_push (labels
, link
);
5285 /* Do not add ASMs with errors to the gimple IL stream. */
5286 if (ret
!= GS_ERROR
)
5288 stmt
= gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr
)),
5289 inputs
, outputs
, clobbers
, labels
);
5291 gimple_asm_set_volatile (stmt
, ASM_VOLATILE_P (expr
));
5292 gimple_asm_set_input (stmt
, ASM_INPUT_P (expr
));
5294 gimplify_seq_add_stmt (pre_p
, stmt
);
5300 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
5301 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
5302 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
5303 return to this function.
5305 FIXME should we complexify the prequeue handling instead? Or use flags
5306 for all the cleanups and let the optimizer tighten them up? The current
5307 code seems pretty fragile; it will break on a cleanup within any
5308 non-conditional nesting. But any such nesting would be broken, anyway;
5309 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
5310 and continues out of it. We can do that at the RTL level, though, so
5311 having an optimizer to tighten up try/finally regions would be a Good
5314 static enum gimplify_status
5315 gimplify_cleanup_point_expr (tree
*expr_p
, gimple_seq
*pre_p
)
5317 gimple_stmt_iterator iter
;
5318 gimple_seq body_sequence
= NULL
;
5320 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
5322 /* We only care about the number of conditions between the innermost
5323 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5324 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5325 int old_conds
= gimplify_ctxp
->conditions
;
5326 gimple_seq old_cleanups
= gimplify_ctxp
->conditional_cleanups
;
5327 bool old_in_cleanup_point_expr
= gimplify_ctxp
->in_cleanup_point_expr
;
5328 gimplify_ctxp
->conditions
= 0;
5329 gimplify_ctxp
->conditional_cleanups
= NULL
;
5330 gimplify_ctxp
->in_cleanup_point_expr
= true;
5332 gimplify_stmt (&TREE_OPERAND (*expr_p
, 0), &body_sequence
);
5334 gimplify_ctxp
->conditions
= old_conds
;
5335 gimplify_ctxp
->conditional_cleanups
= old_cleanups
;
5336 gimplify_ctxp
->in_cleanup_point_expr
= old_in_cleanup_point_expr
;
5338 for (iter
= gsi_start (body_sequence
); !gsi_end_p (iter
); )
5340 gimple wce
= gsi_stmt (iter
);
5342 if (gimple_code (wce
) == GIMPLE_WITH_CLEANUP_EXPR
)
5344 if (gsi_one_before_end_p (iter
))
5346 /* Note that gsi_insert_seq_before and gsi_remove do not
5347 scan operands, unlike some other sequence mutators. */
5348 if (!gimple_wce_cleanup_eh_only (wce
))
5349 gsi_insert_seq_before_without_update (&iter
,
5350 gimple_wce_cleanup (wce
),
5352 gsi_remove (&iter
, true);
5359 enum gimple_try_flags kind
;
5361 if (gimple_wce_cleanup_eh_only (wce
))
5362 kind
= GIMPLE_TRY_CATCH
;
5364 kind
= GIMPLE_TRY_FINALLY
;
5365 seq
= gsi_split_seq_after (iter
);
5367 gtry
= gimple_build_try (seq
, gimple_wce_cleanup (wce
), kind
);
5368 /* Do not use gsi_replace here, as it may scan operands.
5369 We want to do a simple structural modification only. */
5370 gsi_set_stmt (&iter
, gtry
);
5371 iter
= gsi_start (gtry
->eval
);
5378 gimplify_seq_add_seq (pre_p
, body_sequence
);
5391 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5392 is the cleanup action required. EH_ONLY is true if the cleanup should
5393 only be executed if an exception is thrown, not on normal exit. */
5396 gimple_push_cleanup (tree var
, tree cleanup
, bool eh_only
, gimple_seq
*pre_p
)
5399 gimple_seq cleanup_stmts
= NULL
;
5401 /* Errors can result in improperly nested cleanups. Which results in
5402 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5406 if (gimple_conditional_context ())
5408 /* If we're in a conditional context, this is more complex. We only
5409 want to run the cleanup if we actually ran the initialization that
5410 necessitates it, but we want to run it after the end of the
5411 conditional context. So we wrap the try/finally around the
5412 condition and use a flag to determine whether or not to actually
5413 run the destructor. Thus
5417 becomes (approximately)
5421 if (test) { A::A(temp); flag = 1; val = f(temp); }
5424 if (flag) A::~A(temp);
5428 tree flag
= create_tmp_var (boolean_type_node
, "cleanup");
5429 gassign
*ffalse
= gimple_build_assign (flag
, boolean_false_node
);
5430 gassign
*ftrue
= gimple_build_assign (flag
, boolean_true_node
);
5432 cleanup
= build3 (COND_EXPR
, void_type_node
, flag
, cleanup
, NULL
);
5433 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5434 wce
= gimple_build_wce (cleanup_stmts
);
5436 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, ffalse
);
5437 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
5438 gimplify_seq_add_stmt (pre_p
, ftrue
);
5440 /* Because of this manipulation, and the EH edges that jump
5441 threading cannot redirect, the temporary (VAR) will appear
5442 to be used uninitialized. Don't warn. */
5443 TREE_NO_WARNING (var
) = 1;
5447 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5448 wce
= gimple_build_wce (cleanup_stmts
);
5449 gimple_wce_set_cleanup_eh_only (wce
, eh_only
);
5450 gimplify_seq_add_stmt (pre_p
, wce
);
5454 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5456 static enum gimplify_status
5457 gimplify_target_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5459 tree targ
= *expr_p
;
5460 tree temp
= TARGET_EXPR_SLOT (targ
);
5461 tree init
= TARGET_EXPR_INITIAL (targ
);
5462 enum gimplify_status ret
;
5466 tree cleanup
= NULL_TREE
;
5468 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5469 to the temps list. Handle also variable length TARGET_EXPRs. */
5470 if (TREE_CODE (DECL_SIZE (temp
)) != INTEGER_CST
)
5472 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp
)))
5473 gimplify_type_sizes (TREE_TYPE (temp
), pre_p
);
5474 gimplify_vla_decl (temp
, pre_p
);
5477 gimple_add_tmp_var (temp
);
5479 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5480 expression is supposed to initialize the slot. */
5481 if (VOID_TYPE_P (TREE_TYPE (init
)))
5482 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5485 tree init_expr
= build2 (INIT_EXPR
, void_type_node
, temp
, init
);
5487 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5489 ggc_free (init_expr
);
5491 if (ret
== GS_ERROR
)
5493 /* PR c++/28266 Make sure this is expanded only once. */
5494 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5498 gimplify_and_add (init
, pre_p
);
5500 /* If needed, push the cleanup for the temp. */
5501 if (TARGET_EXPR_CLEANUP (targ
))
5503 if (CLEANUP_EH_ONLY (targ
))
5504 gimple_push_cleanup (temp
, TARGET_EXPR_CLEANUP (targ
),
5505 CLEANUP_EH_ONLY (targ
), pre_p
);
5507 cleanup
= TARGET_EXPR_CLEANUP (targ
);
5510 /* Add a clobber for the temporary going out of scope, like
5511 gimplify_bind_expr. */
5512 if (gimplify_ctxp
->in_cleanup_point_expr
5513 && needs_to_live_in_memory (temp
)
5514 && flag_stack_reuse
== SR_ALL
)
5516 tree clobber
= build_constructor (TREE_TYPE (temp
),
5518 TREE_THIS_VOLATILE (clobber
) = true;
5519 clobber
= build2 (MODIFY_EXPR
, TREE_TYPE (temp
), temp
, clobber
);
5521 cleanup
= build2 (COMPOUND_EXPR
, void_type_node
, cleanup
,
5528 gimple_push_cleanup (temp
, cleanup
, false, pre_p
);
5530 /* Only expand this once. */
5531 TREE_OPERAND (targ
, 3) = init
;
5532 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5535 /* We should have expanded this before. */
5536 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp
));
5542 /* Gimplification of expression trees. */
5544 /* Gimplify an expression which appears at statement context. The
5545 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5546 NULL, a new sequence is allocated.
5548 Return true if we actually added a statement to the queue. */
5551 gimplify_stmt (tree
*stmt_p
, gimple_seq
*seq_p
)
5553 gimple_seq_node last
;
5555 last
= gimple_seq_last (*seq_p
);
5556 gimplify_expr (stmt_p
, seq_p
, NULL
, is_gimple_stmt
, fb_none
);
5557 return last
!= gimple_seq_last (*seq_p
);
5560 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5561 to CTX. If entries already exist, force them to be some flavor of private.
5562 If there is no enclosing parallel, do nothing. */
5565 omp_firstprivatize_variable (struct gimplify_omp_ctx
*ctx
, tree decl
)
5569 if (decl
== NULL
|| !DECL_P (decl
))
5574 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5577 if (n
->value
& GOVD_SHARED
)
5578 n
->value
= GOVD_FIRSTPRIVATE
| (n
->value
& GOVD_SEEN
);
5579 else if (n
->value
& GOVD_MAP
)
5580 n
->value
|= GOVD_MAP_TO_ONLY
;
5584 else if (ctx
->region_type
== ORT_TARGET
)
5585 omp_add_variable (ctx
, decl
, GOVD_MAP
| GOVD_MAP_TO_ONLY
);
5586 else if (ctx
->region_type
!= ORT_WORKSHARE
5587 && ctx
->region_type
!= ORT_SIMD
5588 && ctx
->region_type
!= ORT_TARGET_DATA
)
5589 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
5591 ctx
= ctx
->outer_context
;
5596 /* Similarly for each of the type sizes of TYPE. */
5599 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx
*ctx
, tree type
)
5601 if (type
== NULL
|| type
== error_mark_node
)
5603 type
= TYPE_MAIN_VARIANT (type
);
5605 if (ctx
->privatized_types
->add (type
))
5608 switch (TREE_CODE (type
))
5614 case FIXED_POINT_TYPE
:
5615 omp_firstprivatize_variable (ctx
, TYPE_MIN_VALUE (type
));
5616 omp_firstprivatize_variable (ctx
, TYPE_MAX_VALUE (type
));
5620 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5621 omp_firstprivatize_type_sizes (ctx
, TYPE_DOMAIN (type
));
5626 case QUAL_UNION_TYPE
:
5629 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
5630 if (TREE_CODE (field
) == FIELD_DECL
)
5632 omp_firstprivatize_variable (ctx
, DECL_FIELD_OFFSET (field
));
5633 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (field
));
5639 case REFERENCE_TYPE
:
5640 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5647 omp_firstprivatize_variable (ctx
, TYPE_SIZE (type
));
5648 omp_firstprivatize_variable (ctx
, TYPE_SIZE_UNIT (type
));
5649 lang_hooks
.types
.omp_firstprivatize_type_sizes (ctx
, type
);
5652 /* Add an entry for DECL in the OMP context CTX with FLAGS. */
5655 omp_add_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned int flags
)
5658 unsigned int nflags
;
5661 if (error_operand_p (decl
))
5664 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5665 there are constructors involved somewhere. */
5666 if (TREE_ADDRESSABLE (TREE_TYPE (decl
))
5667 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
5670 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5671 if (n
!= NULL
&& n
->value
!= GOVD_ALIGNED
)
5673 /* We shouldn't be re-adding the decl with the same data
5675 gcc_assert ((n
->value
& GOVD_DATA_SHARE_CLASS
& flags
) == 0);
5676 /* The only combination of data sharing classes we should see is
5677 FIRSTPRIVATE and LASTPRIVATE. */
5678 nflags
= n
->value
| flags
;
5679 gcc_assert ((nflags
& GOVD_DATA_SHARE_CLASS
)
5680 == (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
)
5681 || (flags
& GOVD_DATA_SHARE_CLASS
) == 0);
5686 /* When adding a variable-sized variable, we have to handle all sorts
5687 of additional bits of data: the pointer replacement variable, and
5688 the parameters of the type. */
5689 if (DECL_SIZE (decl
) && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5691 /* Add the pointer replacement variable as PRIVATE if the variable
5692 replacement is private, else FIRSTPRIVATE since we'll need the
5693 address of the original variable either for SHARED, or for the
5694 copy into or out of the context. */
5695 if (!(flags
& GOVD_LOCAL
))
5697 if (flags
& GOVD_MAP
)
5698 nflags
= GOVD_MAP
| GOVD_MAP_TO_ONLY
| GOVD_EXPLICIT
;
5699 else if (flags
& GOVD_PRIVATE
)
5700 nflags
= GOVD_PRIVATE
;
5702 nflags
= GOVD_FIRSTPRIVATE
;
5703 nflags
|= flags
& GOVD_SEEN
;
5704 t
= DECL_VALUE_EXPR (decl
);
5705 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5706 t
= TREE_OPERAND (t
, 0);
5707 gcc_assert (DECL_P (t
));
5708 omp_add_variable (ctx
, t
, nflags
);
5711 /* Add all of the variable and type parameters (which should have
5712 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5713 omp_firstprivatize_variable (ctx
, DECL_SIZE_UNIT (decl
));
5714 omp_firstprivatize_variable (ctx
, DECL_SIZE (decl
));
5715 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5717 /* The variable-sized variable itself is never SHARED, only some form
5718 of PRIVATE. The sharing would take place via the pointer variable
5719 which we remapped above. */
5720 if (flags
& GOVD_SHARED
)
5721 flags
= GOVD_PRIVATE
| GOVD_DEBUG_PRIVATE
5722 | (flags
& (GOVD_SEEN
| GOVD_EXPLICIT
));
5724 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5725 alloca statement we generate for the variable, so make sure it
5726 is available. This isn't automatically needed for the SHARED
5727 case, since we won't be allocating local storage then.
5728 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5729 in this case omp_notice_variable will be called later
5730 on when it is gimplified. */
5731 else if (! (flags
& (GOVD_LOCAL
| GOVD_MAP
))
5732 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl
))))
5733 omp_notice_variable (ctx
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)), true);
5735 else if ((flags
& (GOVD_MAP
| GOVD_LOCAL
)) == 0
5736 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
5738 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5740 /* Similar to the direct variable sized case above, we'll need the
5741 size of references being privatized. */
5742 if ((flags
& GOVD_SHARED
) == 0)
5744 t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
5745 if (TREE_CODE (t
) != INTEGER_CST
)
5746 omp_notice_variable (ctx
, t
, true);
5753 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, flags
);
5756 /* Notice a threadprivate variable DECL used in OMP context CTX.
5757 This just prints out diagnostics about threadprivate variable uses
5758 in untied tasks. If DECL2 is non-NULL, prevent this warning
5759 on that variable. */
5762 omp_notice_threadprivate_variable (struct gimplify_omp_ctx
*ctx
, tree decl
,
5766 struct gimplify_omp_ctx
*octx
;
5768 for (octx
= ctx
; octx
; octx
= octx
->outer_context
)
5769 if (octx
->region_type
== ORT_TARGET
)
5771 n
= splay_tree_lookup (octx
->variables
, (splay_tree_key
)decl
);
5774 error ("threadprivate variable %qE used in target region",
5776 error_at (octx
->location
, "enclosing target region");
5777 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl
, 0);
5780 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl2
, 0);
5783 if (ctx
->region_type
!= ORT_UNTIED_TASK
)
5785 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5788 error ("threadprivate variable %qE used in untied task",
5790 error_at (ctx
->location
, "enclosing task");
5791 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, 0);
5794 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl2
, 0);
5798 /* Record the fact that DECL was used within the OMP context CTX.
5799 IN_CODE is true when real code uses DECL, and false when we should
5800 merely emit default(none) errors. Return true if DECL is going to
5801 be remapped and thus DECL shouldn't be gimplified into its
5802 DECL_VALUE_EXPR (if any). */
5805 omp_notice_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, bool in_code
)
5808 unsigned flags
= in_code
? GOVD_SEEN
: 0;
5809 bool ret
= false, shared
;
5811 if (error_operand_p (decl
))
5814 /* Threadprivate variables are predetermined. */
5815 if (is_global_var (decl
))
5817 if (DECL_THREAD_LOCAL_P (decl
))
5818 return omp_notice_threadprivate_variable (ctx
, decl
, NULL_TREE
);
5820 if (DECL_HAS_VALUE_EXPR_P (decl
))
5822 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
5824 if (value
&& DECL_P (value
) && DECL_THREAD_LOCAL_P (value
))
5825 return omp_notice_threadprivate_variable (ctx
, decl
, value
);
5829 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5830 if (ctx
->region_type
== ORT_TARGET
)
5832 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, true);
5835 if (!lang_hooks
.types
.omp_mappable_type (TREE_TYPE (decl
)))
5837 error ("%qD referenced in target region does not have "
5838 "a mappable type", decl
);
5839 omp_add_variable (ctx
, decl
, GOVD_MAP
| GOVD_EXPLICIT
| flags
);
5842 omp_add_variable (ctx
, decl
, GOVD_MAP
| flags
);
5846 /* If nothing changed, there's nothing left to do. */
5847 if ((n
->value
& flags
) == flags
)
5856 enum omp_clause_default_kind default_kind
, kind
;
5857 struct gimplify_omp_ctx
*octx
;
5859 if (ctx
->region_type
== ORT_WORKSHARE
5860 || ctx
->region_type
== ORT_SIMD
5861 || ctx
->region_type
== ORT_TARGET_DATA
)
5864 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
5865 remapped firstprivate instead of shared. To some extent this is
5866 addressed in omp_firstprivatize_type_sizes, but not effectively. */
5867 default_kind
= ctx
->default_kind
;
5868 kind
= lang_hooks
.decls
.omp_predetermined_sharing (decl
);
5869 if (kind
!= OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
5870 default_kind
= kind
;
5872 switch (default_kind
)
5874 case OMP_CLAUSE_DEFAULT_NONE
:
5875 if ((ctx
->region_type
& ORT_PARALLEL
) != 0)
5877 error ("%qE not specified in enclosing parallel",
5878 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5879 error_at (ctx
->location
, "enclosing parallel");
5881 else if ((ctx
->region_type
& ORT_TASK
) != 0)
5883 error ("%qE not specified in enclosing task",
5884 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5885 error_at (ctx
->location
, "enclosing task");
5887 else if (ctx
->region_type
== ORT_TEAMS
)
5889 error ("%qE not specified in enclosing teams construct",
5890 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5891 error_at (ctx
->location
, "enclosing teams construct");
5896 case OMP_CLAUSE_DEFAULT_SHARED
:
5897 flags
|= GOVD_SHARED
;
5899 case OMP_CLAUSE_DEFAULT_PRIVATE
:
5900 flags
|= GOVD_PRIVATE
;
5902 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
5903 flags
|= GOVD_FIRSTPRIVATE
;
5905 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
5906 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
5907 gcc_assert ((ctx
->region_type
& ORT_TASK
) != 0);
5908 if (ctx
->outer_context
)
5909 omp_notice_variable (ctx
->outer_context
, decl
, in_code
);
5910 for (octx
= ctx
->outer_context
; octx
; octx
= octx
->outer_context
)
5914 if ((octx
->region_type
& (ORT_TARGET_DATA
| ORT_TARGET
)) != 0)
5916 n2
= splay_tree_lookup (octx
->variables
, (splay_tree_key
) decl
);
5917 if (n2
&& (n2
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
)
5919 flags
|= GOVD_FIRSTPRIVATE
;
5922 if ((octx
->region_type
& (ORT_PARALLEL
| ORT_TEAMS
)) != 0)
5925 if (flags
& GOVD_FIRSTPRIVATE
)
5928 && (TREE_CODE (decl
) == PARM_DECL
5929 || (!is_global_var (decl
)
5930 && DECL_CONTEXT (decl
) == current_function_decl
)))
5932 flags
|= GOVD_FIRSTPRIVATE
;
5935 flags
|= GOVD_SHARED
;
5941 if ((flags
& GOVD_PRIVATE
)
5942 && lang_hooks
.decls
.omp_private_outer_ref (decl
))
5943 flags
|= GOVD_PRIVATE_OUTER_REF
;
5945 omp_add_variable (ctx
, decl
, flags
);
5947 shared
= (flags
& GOVD_SHARED
) != 0;
5948 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
5952 if ((n
->value
& (GOVD_SEEN
| GOVD_LOCAL
)) == 0
5953 && (flags
& (GOVD_SEEN
| GOVD_LOCAL
)) == GOVD_SEEN
5955 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5958 tree t
= DECL_VALUE_EXPR (decl
);
5959 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5960 t
= TREE_OPERAND (t
, 0);
5961 gcc_assert (DECL_P (t
));
5962 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
5963 n2
->value
|= GOVD_SEEN
;
5966 shared
= ((flags
| n
->value
) & GOVD_SHARED
) != 0;
5967 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
5969 /* If nothing changed, there's nothing left to do. */
5970 if ((n
->value
& flags
) == flags
)
5976 /* If the variable is private in the current context, then we don't
5977 need to propagate anything to an outer context. */
5978 if ((flags
& GOVD_PRIVATE
) && !(flags
& GOVD_PRIVATE_OUTER_REF
))
5980 if (ctx
->outer_context
5981 && omp_notice_variable (ctx
->outer_context
, decl
, in_code
))
5986 /* Verify that DECL is private within CTX. If there's specific information
5987 to the contrary in the innermost scope, generate an error. */
5990 omp_is_private (struct gimplify_omp_ctx
*ctx
, tree decl
, int simd
)
5994 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5997 if (n
->value
& GOVD_SHARED
)
5999 if (ctx
== gimplify_omp_ctxp
)
6002 error ("iteration variable %qE is predetermined linear",
6005 error ("iteration variable %qE should be private",
6007 n
->value
= GOVD_PRIVATE
;
6013 else if ((n
->value
& GOVD_EXPLICIT
) != 0
6014 && (ctx
== gimplify_omp_ctxp
6015 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6016 && gimplify_omp_ctxp
->outer_context
== ctx
)))
6018 if ((n
->value
& GOVD_FIRSTPRIVATE
) != 0)
6019 error ("iteration variable %qE should not be firstprivate",
6021 else if ((n
->value
& GOVD_REDUCTION
) != 0)
6022 error ("iteration variable %qE should not be reduction",
6024 else if (simd
== 1 && (n
->value
& GOVD_LASTPRIVATE
) != 0)
6025 error ("iteration variable %qE should not be lastprivate",
6027 else if (simd
&& (n
->value
& GOVD_PRIVATE
) != 0)
6028 error ("iteration variable %qE should not be private",
6030 else if (simd
== 2 && (n
->value
& GOVD_LINEAR
) != 0)
6031 error ("iteration variable %qE is predetermined linear",
6034 return (ctx
== gimplify_omp_ctxp
6035 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6036 && gimplify_omp_ctxp
->outer_context
== ctx
));
6039 if (ctx
->region_type
!= ORT_WORKSHARE
6040 && ctx
->region_type
!= ORT_SIMD
)
6042 else if (ctx
->outer_context
)
6043 return omp_is_private (ctx
->outer_context
, decl
, simd
);
6047 /* Return true if DECL is private within a parallel region
6048 that binds to the current construct's context or in parallel
6049 region's REDUCTION clause. */
6052 omp_check_private (struct gimplify_omp_ctx
*ctx
, tree decl
, bool copyprivate
)
6058 ctx
= ctx
->outer_context
;
6060 return !(is_global_var (decl
)
6061 /* References might be private, but might be shared too,
6062 when checking for copyprivate, assume they might be
6063 private, otherwise assume they might be shared. */
6065 && lang_hooks
.decls
.omp_privatize_by_reference (decl
)));
6067 if ((ctx
->region_type
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0)
6070 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6072 return (n
->value
& GOVD_SHARED
) == 0;
6074 while (ctx
->region_type
== ORT_WORKSHARE
6075 || ctx
->region_type
== ORT_SIMD
);
6079 /* Scan the OMP clauses in *LIST_P, installing mappings into a new
6080 and previous omp contexts. */
6083 gimplify_scan_omp_clauses (tree
*list_p
, gimple_seq
*pre_p
,
6084 enum omp_region_type region_type
)
6086 struct gimplify_omp_ctx
*ctx
, *outer_ctx
;
6089 ctx
= new_omp_context (region_type
);
6090 outer_ctx
= ctx
->outer_context
;
6092 while ((c
= *list_p
) != NULL
)
6094 bool remove
= false;
6095 bool notice_outer
= true;
6096 const char *check_non_private
= NULL
;
6100 switch (OMP_CLAUSE_CODE (c
))
6102 case OMP_CLAUSE_PRIVATE
:
6103 flags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
6104 if (lang_hooks
.decls
.omp_private_outer_ref (OMP_CLAUSE_DECL (c
)))
6106 flags
|= GOVD_PRIVATE_OUTER_REF
;
6107 OMP_CLAUSE_PRIVATE_OUTER_REF (c
) = 1;
6110 notice_outer
= false;
6112 case OMP_CLAUSE_SHARED
:
6113 flags
= GOVD_SHARED
| GOVD_EXPLICIT
;
6115 case OMP_CLAUSE_FIRSTPRIVATE
:
6116 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
6117 check_non_private
= "firstprivate";
6119 case OMP_CLAUSE_LASTPRIVATE
:
6120 flags
= GOVD_LASTPRIVATE
| GOVD_SEEN
| GOVD_EXPLICIT
;
6121 check_non_private
= "lastprivate";
6123 case OMP_CLAUSE_REDUCTION
:
6124 flags
= GOVD_REDUCTION
| GOVD_SEEN
| GOVD_EXPLICIT
;
6125 check_non_private
= "reduction";
6127 case OMP_CLAUSE_LINEAR
:
6128 if (gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
), pre_p
, NULL
,
6129 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6134 flags
= GOVD_LINEAR
| GOVD_EXPLICIT
;
6137 case OMP_CLAUSE_MAP
:
6138 decl
= OMP_CLAUSE_DECL (c
);
6139 if (error_operand_p (decl
))
6144 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
6145 OMP_CLAUSE_SIZE (c
) = DECL_P (decl
) ? DECL_SIZE_UNIT (decl
)
6146 : TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6147 if (gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
6148 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6155 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
,
6156 NULL
, is_gimple_lvalue
, fb_lvalue
)
6164 flags
= GOVD_MAP
| GOVD_EXPLICIT
;
6167 case OMP_CLAUSE_DEPEND
:
6168 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == COMPOUND_EXPR
)
6170 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0), pre_p
,
6171 NULL
, is_gimple_val
, fb_rvalue
);
6172 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (OMP_CLAUSE_DECL (c
), 1);
6174 if (error_operand_p (OMP_CLAUSE_DECL (c
)))
6179 OMP_CLAUSE_DECL (c
) = build_fold_addr_expr (OMP_CLAUSE_DECL (c
));
6180 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
, NULL
,
6181 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6189 case OMP_CLAUSE_FROM
:
6190 case OMP_CLAUSE__CACHE_
:
6191 decl
= OMP_CLAUSE_DECL (c
);
6192 if (error_operand_p (decl
))
6197 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
6198 OMP_CLAUSE_SIZE (c
) = DECL_P (decl
) ? DECL_SIZE_UNIT (decl
)
6199 : TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6200 if (gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
6201 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6208 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
,
6209 NULL
, is_gimple_lvalue
, fb_lvalue
)
6220 decl
= OMP_CLAUSE_DECL (c
);
6221 if (error_operand_p (decl
))
6226 omp_add_variable (ctx
, decl
, flags
);
6227 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
6228 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
6230 omp_add_variable (ctx
, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
),
6231 GOVD_LOCAL
| GOVD_SEEN
);
6232 gimplify_omp_ctxp
= ctx
;
6233 push_gimplify_context ();
6235 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
6236 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
6238 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c
),
6239 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
6240 pop_gimplify_context
6241 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
)));
6242 push_gimplify_context ();
6243 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c
),
6244 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
6245 pop_gimplify_context
6246 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
)));
6247 OMP_CLAUSE_REDUCTION_INIT (c
) = NULL_TREE
;
6248 OMP_CLAUSE_REDUCTION_MERGE (c
) = NULL_TREE
;
6250 gimplify_omp_ctxp
= outer_ctx
;
6252 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6253 && OMP_CLAUSE_LASTPRIVATE_STMT (c
))
6255 gimplify_omp_ctxp
= ctx
;
6256 push_gimplify_context ();
6257 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c
)) != BIND_EXPR
)
6259 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
6261 TREE_SIDE_EFFECTS (bind
) = 1;
6262 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LASTPRIVATE_STMT (c
);
6263 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = bind
;
6265 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c
),
6266 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6267 pop_gimplify_context
6268 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
)));
6269 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = NULL_TREE
;
6271 gimplify_omp_ctxp
= outer_ctx
;
6273 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
6274 && OMP_CLAUSE_LINEAR_STMT (c
))
6276 gimplify_omp_ctxp
= ctx
;
6277 push_gimplify_context ();
6278 if (TREE_CODE (OMP_CLAUSE_LINEAR_STMT (c
)) != BIND_EXPR
)
6280 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
6282 TREE_SIDE_EFFECTS (bind
) = 1;
6283 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LINEAR_STMT (c
);
6284 OMP_CLAUSE_LINEAR_STMT (c
) = bind
;
6286 gimplify_and_add (OMP_CLAUSE_LINEAR_STMT (c
),
6287 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
));
6288 pop_gimplify_context
6289 (gimple_seq_first_stmt (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
)));
6290 OMP_CLAUSE_LINEAR_STMT (c
) = NULL_TREE
;
6292 gimplify_omp_ctxp
= outer_ctx
;
6298 case OMP_CLAUSE_COPYIN
:
6299 case OMP_CLAUSE_COPYPRIVATE
:
6300 decl
= OMP_CLAUSE_DECL (c
);
6301 if (error_operand_p (decl
))
6306 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_COPYPRIVATE
6308 && !omp_check_private (ctx
, decl
, true))
6311 if (is_global_var (decl
))
6313 if (DECL_THREAD_LOCAL_P (decl
))
6315 else if (DECL_HAS_VALUE_EXPR_P (decl
))
6317 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
6321 && DECL_THREAD_LOCAL_P (value
))
6326 error_at (OMP_CLAUSE_LOCATION (c
),
6327 "copyprivate variable %qE is not threadprivate"
6328 " or private in outer context", DECL_NAME (decl
));
6332 omp_notice_variable (outer_ctx
, decl
, true);
6333 if (check_non_private
6334 && region_type
== ORT_WORKSHARE
6335 && omp_check_private (ctx
, decl
, false))
6337 error ("%s variable %qE is private in outer context",
6338 check_non_private
, DECL_NAME (decl
));
6343 case OMP_CLAUSE_FINAL
:
6345 OMP_CLAUSE_OPERAND (c
, 0)
6346 = gimple_boolify (OMP_CLAUSE_OPERAND (c
, 0));
6349 case OMP_CLAUSE_SCHEDULE
:
6350 case OMP_CLAUSE_NUM_THREADS
:
6351 case OMP_CLAUSE_NUM_TEAMS
:
6352 case OMP_CLAUSE_THREAD_LIMIT
:
6353 case OMP_CLAUSE_DIST_SCHEDULE
:
6354 case OMP_CLAUSE_DEVICE
:
6355 case OMP_CLAUSE__CILK_FOR_COUNT_
:
6356 case OMP_CLAUSE_ASYNC
:
6357 case OMP_CLAUSE_WAIT
:
6358 case OMP_CLAUSE_NUM_GANGS
:
6359 case OMP_CLAUSE_NUM_WORKERS
:
6360 case OMP_CLAUSE_VECTOR_LENGTH
:
6361 case OMP_CLAUSE_GANG
:
6362 case OMP_CLAUSE_WORKER
:
6363 case OMP_CLAUSE_VECTOR
:
6364 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
6365 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6367 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_GANG
6368 && gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 1), pre_p
, NULL
,
6369 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6373 case OMP_CLAUSE_DEVICE_RESIDENT
:
6374 case OMP_CLAUSE_USE_DEVICE
:
6375 case OMP_CLAUSE_INDEPENDENT
:
6379 case OMP_CLAUSE_NOWAIT
:
6380 case OMP_CLAUSE_ORDERED
:
6381 case OMP_CLAUSE_UNTIED
:
6382 case OMP_CLAUSE_COLLAPSE
:
6383 case OMP_CLAUSE_AUTO
:
6384 case OMP_CLAUSE_SEQ
:
6385 case OMP_CLAUSE_MERGEABLE
:
6386 case OMP_CLAUSE_PROC_BIND
:
6387 case OMP_CLAUSE_SAFELEN
:
6390 case OMP_CLAUSE_ALIGNED
:
6391 decl
= OMP_CLAUSE_DECL (c
);
6392 if (error_operand_p (decl
))
6397 if (gimplify_expr (&OMP_CLAUSE_ALIGNED_ALIGNMENT (c
), pre_p
, NULL
,
6398 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6403 if (!is_global_var (decl
)
6404 && TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
6405 omp_add_variable (ctx
, decl
, GOVD_ALIGNED
);
6408 case OMP_CLAUSE_DEFAULT
:
6409 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
6417 *list_p
= OMP_CLAUSE_CHAIN (c
);
6419 list_p
= &OMP_CLAUSE_CHAIN (c
);
6422 gimplify_omp_ctxp
= ctx
;
6425 struct gimplify_adjust_omp_clauses_data
6431 /* For all variables that were not actually used within the context,
6432 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
6435 gimplify_adjust_omp_clauses_1 (splay_tree_node n
, void *data
)
6437 tree
*list_p
= ((struct gimplify_adjust_omp_clauses_data
*) data
)->list_p
;
6439 = ((struct gimplify_adjust_omp_clauses_data
*) data
)->pre_p
;
6440 tree decl
= (tree
) n
->key
;
6441 unsigned flags
= n
->value
;
6442 enum omp_clause_code code
;
6446 if (flags
& (GOVD_EXPLICIT
| GOVD_LOCAL
))
6448 if ((flags
& GOVD_SEEN
) == 0)
6450 if (flags
& GOVD_DEBUG_PRIVATE
)
6452 gcc_assert ((flags
& GOVD_DATA_SHARE_CLASS
) == GOVD_PRIVATE
);
6453 private_debug
= true;
6455 else if (flags
& GOVD_MAP
)
6456 private_debug
= false;
6459 = lang_hooks
.decls
.omp_private_debug_clause (decl
,
6460 !!(flags
& GOVD_SHARED
));
6462 code
= OMP_CLAUSE_PRIVATE
;
6463 else if (flags
& GOVD_MAP
)
6464 code
= OMP_CLAUSE_MAP
;
6465 else if (flags
& GOVD_SHARED
)
6467 if (is_global_var (decl
))
6469 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
6473 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6474 if (on
&& (on
->value
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
6475 | GOVD_PRIVATE
| GOVD_REDUCTION
6476 | GOVD_LINEAR
| GOVD_MAP
)) != 0)
6478 ctx
= ctx
->outer_context
;
6483 code
= OMP_CLAUSE_SHARED
;
6485 else if (flags
& GOVD_PRIVATE
)
6486 code
= OMP_CLAUSE_PRIVATE
;
6487 else if (flags
& GOVD_FIRSTPRIVATE
)
6488 code
= OMP_CLAUSE_FIRSTPRIVATE
;
6489 else if (flags
& GOVD_LASTPRIVATE
)
6490 code
= OMP_CLAUSE_LASTPRIVATE
;
6491 else if (flags
& GOVD_ALIGNED
)
6496 clause
= build_omp_clause (input_location
, code
);
6497 OMP_CLAUSE_DECL (clause
) = decl
;
6498 OMP_CLAUSE_CHAIN (clause
) = *list_p
;
6500 OMP_CLAUSE_PRIVATE_DEBUG (clause
) = 1;
6501 else if (code
== OMP_CLAUSE_PRIVATE
&& (flags
& GOVD_PRIVATE_OUTER_REF
))
6502 OMP_CLAUSE_PRIVATE_OUTER_REF (clause
) = 1;
6503 else if (code
== OMP_CLAUSE_MAP
)
6505 OMP_CLAUSE_SET_MAP_KIND (clause
,
6506 flags
& GOVD_MAP_TO_ONLY
6509 if (DECL_SIZE (decl
)
6510 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6512 tree decl2
= DECL_VALUE_EXPR (decl
);
6513 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
6514 decl2
= TREE_OPERAND (decl2
, 0);
6515 gcc_assert (DECL_P (decl2
));
6516 tree mem
= build_simple_mem_ref (decl2
);
6517 OMP_CLAUSE_DECL (clause
) = mem
;
6518 OMP_CLAUSE_SIZE (clause
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6519 if (gimplify_omp_ctxp
->outer_context
)
6521 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
6522 omp_notice_variable (ctx
, decl2
, true);
6523 omp_notice_variable (ctx
, OMP_CLAUSE_SIZE (clause
), true);
6525 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
),
6527 OMP_CLAUSE_DECL (nc
) = decl
;
6528 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
6529 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_POINTER
);
6530 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (clause
);
6531 OMP_CLAUSE_CHAIN (clause
) = nc
;
6534 OMP_CLAUSE_SIZE (clause
) = DECL_SIZE_UNIT (decl
);
6536 if (code
== OMP_CLAUSE_FIRSTPRIVATE
&& (flags
& GOVD_LASTPRIVATE
) != 0)
6538 tree nc
= build_omp_clause (input_location
, OMP_CLAUSE_LASTPRIVATE
);
6539 OMP_CLAUSE_DECL (nc
) = decl
;
6540 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (nc
) = 1;
6541 OMP_CLAUSE_CHAIN (nc
) = *list_p
;
6542 OMP_CLAUSE_CHAIN (clause
) = nc
;
6543 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6544 gimplify_omp_ctxp
= ctx
->outer_context
;
6545 lang_hooks
.decls
.omp_finish_clause (nc
, pre_p
);
6546 gimplify_omp_ctxp
= ctx
;
6549 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6550 gimplify_omp_ctxp
= ctx
->outer_context
;
6551 lang_hooks
.decls
.omp_finish_clause (clause
, pre_p
);
6552 gimplify_omp_ctxp
= ctx
;
6557 gimplify_adjust_omp_clauses (gimple_seq
*pre_p
, tree
*list_p
)
6559 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6562 while ((c
= *list_p
) != NULL
)
6565 bool remove
= false;
6567 switch (OMP_CLAUSE_CODE (c
))
6569 case OMP_CLAUSE_PRIVATE
:
6570 case OMP_CLAUSE_SHARED
:
6571 case OMP_CLAUSE_FIRSTPRIVATE
:
6572 case OMP_CLAUSE_LINEAR
:
6573 decl
= OMP_CLAUSE_DECL (c
);
6574 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6575 remove
= !(n
->value
& GOVD_SEEN
);
6578 bool shared
= OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
;
6579 if ((n
->value
& GOVD_DEBUG_PRIVATE
)
6580 || lang_hooks
.decls
.omp_private_debug_clause (decl
, shared
))
6582 gcc_assert ((n
->value
& GOVD_DEBUG_PRIVATE
) == 0
6583 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
6585 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_PRIVATE
);
6586 OMP_CLAUSE_PRIVATE_DEBUG (c
) = 1;
6588 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
6589 && ctx
->outer_context
6590 && !(OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
6591 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)))
6593 if (ctx
->outer_context
->combined_loop
6594 && !OMP_CLAUSE_LINEAR_NO_COPYIN (c
))
6596 n
= splay_tree_lookup (ctx
->outer_context
->variables
,
6597 (splay_tree_key
) decl
);
6599 || (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
6601 int flags
= GOVD_FIRSTPRIVATE
;
6602 /* #pragma omp distribute does not allow
6603 lastprivate clause. */
6604 if (!ctx
->outer_context
->distribute
)
6605 flags
|= GOVD_LASTPRIVATE
;
6607 omp_add_variable (ctx
->outer_context
, decl
,
6610 n
->value
|= flags
| GOVD_SEEN
;
6613 else if (!is_global_var (decl
))
6614 omp_notice_variable (ctx
->outer_context
, decl
, true);
6619 case OMP_CLAUSE_LASTPRIVATE
:
6620 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
6621 accurately reflect the presence of a FIRSTPRIVATE clause. */
6622 decl
= OMP_CLAUSE_DECL (c
);
6623 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6624 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
6625 = (n
->value
& GOVD_FIRSTPRIVATE
) != 0;
6628 case OMP_CLAUSE_ALIGNED
:
6629 decl
= OMP_CLAUSE_DECL (c
);
6630 if (!is_global_var (decl
))
6632 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6633 remove
= n
== NULL
|| !(n
->value
& GOVD_SEEN
);
6634 if (!remove
&& TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
6636 struct gimplify_omp_ctx
*octx
;
6638 && (n
->value
& (GOVD_DATA_SHARE_CLASS
6639 & ~GOVD_FIRSTPRIVATE
)))
6642 for (octx
= ctx
->outer_context
; octx
;
6643 octx
= octx
->outer_context
)
6645 n
= splay_tree_lookup (octx
->variables
,
6646 (splay_tree_key
) decl
);
6649 if (n
->value
& GOVD_LOCAL
)
6651 /* We have to avoid assigning a shared variable
6652 to itself when trying to add
6653 __builtin_assume_aligned. */
6654 if (n
->value
& GOVD_SHARED
)
6662 else if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
6664 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6665 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
6670 case OMP_CLAUSE_MAP
:
6671 decl
= OMP_CLAUSE_DECL (c
);
6674 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6675 if (ctx
->region_type
== ORT_TARGET
&& !(n
->value
& GOVD_SEEN
))
6677 else if (DECL_SIZE (decl
)
6678 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
6679 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_POINTER
)
6681 /* For GOMP_MAP_FORCE_DEVICEPTR, we'll never enter here, because
6682 for these, TREE_CODE (DECL_SIZE (decl)) will always be
6684 gcc_assert (OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_FORCE_DEVICEPTR
);
6686 tree decl2
= DECL_VALUE_EXPR (decl
);
6687 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
6688 decl2
= TREE_OPERAND (decl2
, 0);
6689 gcc_assert (DECL_P (decl2
));
6690 tree mem
= build_simple_mem_ref (decl2
);
6691 OMP_CLAUSE_DECL (c
) = mem
;
6692 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6693 if (ctx
->outer_context
)
6695 omp_notice_variable (ctx
->outer_context
, decl2
, true);
6696 omp_notice_variable (ctx
->outer_context
,
6697 OMP_CLAUSE_SIZE (c
), true);
6699 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
6701 OMP_CLAUSE_DECL (nc
) = decl
;
6702 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
6703 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_POINTER
);
6704 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (c
);
6705 OMP_CLAUSE_CHAIN (c
) = nc
;
6708 else if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
6709 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
6713 case OMP_CLAUSE_FROM
:
6714 case OMP_CLAUSE__CACHE_
:
6715 decl
= OMP_CLAUSE_DECL (c
);
6718 if (DECL_SIZE (decl
)
6719 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6721 tree decl2
= DECL_VALUE_EXPR (decl
);
6722 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
6723 decl2
= TREE_OPERAND (decl2
, 0);
6724 gcc_assert (DECL_P (decl2
));
6725 tree mem
= build_simple_mem_ref (decl2
);
6726 OMP_CLAUSE_DECL (c
) = mem
;
6727 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6728 if (ctx
->outer_context
)
6730 omp_notice_variable (ctx
->outer_context
, decl2
, true);
6731 omp_notice_variable (ctx
->outer_context
,
6732 OMP_CLAUSE_SIZE (c
), true);
6735 else if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
6736 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
6739 case OMP_CLAUSE_REDUCTION
:
6740 case OMP_CLAUSE_COPYIN
:
6741 case OMP_CLAUSE_COPYPRIVATE
:
6743 case OMP_CLAUSE_NUM_THREADS
:
6744 case OMP_CLAUSE_NUM_TEAMS
:
6745 case OMP_CLAUSE_THREAD_LIMIT
:
6746 case OMP_CLAUSE_DIST_SCHEDULE
:
6747 case OMP_CLAUSE_DEVICE
:
6748 case OMP_CLAUSE_SCHEDULE
:
6749 case OMP_CLAUSE_NOWAIT
:
6750 case OMP_CLAUSE_ORDERED
:
6751 case OMP_CLAUSE_DEFAULT
:
6752 case OMP_CLAUSE_UNTIED
:
6753 case OMP_CLAUSE_COLLAPSE
:
6754 case OMP_CLAUSE_FINAL
:
6755 case OMP_CLAUSE_MERGEABLE
:
6756 case OMP_CLAUSE_PROC_BIND
:
6757 case OMP_CLAUSE_SAFELEN
:
6758 case OMP_CLAUSE_DEPEND
:
6759 case OMP_CLAUSE__CILK_FOR_COUNT_
:
6760 case OMP_CLAUSE_ASYNC
:
6761 case OMP_CLAUSE_WAIT
:
6762 case OMP_CLAUSE_DEVICE_RESIDENT
:
6763 case OMP_CLAUSE_USE_DEVICE
:
6764 case OMP_CLAUSE_INDEPENDENT
:
6765 case OMP_CLAUSE_NUM_GANGS
:
6766 case OMP_CLAUSE_NUM_WORKERS
:
6767 case OMP_CLAUSE_VECTOR_LENGTH
:
6768 case OMP_CLAUSE_GANG
:
6769 case OMP_CLAUSE_WORKER
:
6770 case OMP_CLAUSE_VECTOR
:
6771 case OMP_CLAUSE_AUTO
:
6772 case OMP_CLAUSE_SEQ
:
6780 *list_p
= OMP_CLAUSE_CHAIN (c
);
6782 list_p
= &OMP_CLAUSE_CHAIN (c
);
6785 /* Add in any implicit data sharing. */
6786 struct gimplify_adjust_omp_clauses_data data
;
6787 data
.list_p
= list_p
;
6789 splay_tree_foreach (ctx
->variables
, gimplify_adjust_omp_clauses_1
, &data
);
6791 gimplify_omp_ctxp
= ctx
->outer_context
;
6792 delete_omp_context (ctx
);
6795 /* Gimplify OACC_CACHE. */
6798 gimplify_oacc_cache (tree
*expr_p
, gimple_seq
*pre_p
)
6800 tree expr
= *expr_p
;
6802 gimplify_scan_omp_clauses (&OACC_CACHE_CLAUSES (expr
), pre_p
, ORT_WORKSHARE
);
6803 gimplify_adjust_omp_clauses (pre_p
, &OACC_CACHE_CLAUSES (expr
));
6805 /* TODO: Do something sensible with this information. */
6807 *expr_p
= NULL_TREE
;
6810 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
6811 gimplification of the body, as well as scanning the body for used
6812 variables. We need to do this scan now, because variable-sized
6813 decls will be decomposed during gimplification. */
6816 gimplify_omp_parallel (tree
*expr_p
, gimple_seq
*pre_p
)
6818 tree expr
= *expr_p
;
6820 gimple_seq body
= NULL
;
6822 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
), pre_p
,
6823 OMP_PARALLEL_COMBINED (expr
)
6824 ? ORT_COMBINED_PARALLEL
6827 push_gimplify_context ();
6829 g
= gimplify_and_return_first (OMP_PARALLEL_BODY (expr
), &body
);
6830 if (gimple_code (g
) == GIMPLE_BIND
)
6831 pop_gimplify_context (g
);
6833 pop_gimplify_context (NULL
);
6835 gimplify_adjust_omp_clauses (pre_p
, &OMP_PARALLEL_CLAUSES (expr
));
6837 g
= gimple_build_omp_parallel (body
,
6838 OMP_PARALLEL_CLAUSES (expr
),
6839 NULL_TREE
, NULL_TREE
);
6840 if (OMP_PARALLEL_COMBINED (expr
))
6841 gimple_omp_set_subcode (g
, GF_OMP_PARALLEL_COMBINED
);
6842 gimplify_seq_add_stmt (pre_p
, g
);
6843 *expr_p
= NULL_TREE
;
6846 /* Gimplify the contents of an OMP_TASK statement. This involves
6847 gimplification of the body, as well as scanning the body for used
6848 variables. We need to do this scan now, because variable-sized
6849 decls will be decomposed during gimplification. */
6852 gimplify_omp_task (tree
*expr_p
, gimple_seq
*pre_p
)
6854 tree expr
= *expr_p
;
6856 gimple_seq body
= NULL
;
6858 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr
), pre_p
,
6859 find_omp_clause (OMP_TASK_CLAUSES (expr
),
6861 ? ORT_UNTIED_TASK
: ORT_TASK
);
6863 push_gimplify_context ();
6865 g
= gimplify_and_return_first (OMP_TASK_BODY (expr
), &body
);
6866 if (gimple_code (g
) == GIMPLE_BIND
)
6867 pop_gimplify_context (g
);
6869 pop_gimplify_context (NULL
);
6871 gimplify_adjust_omp_clauses (pre_p
, &OMP_TASK_CLAUSES (expr
));
6873 g
= gimple_build_omp_task (body
,
6874 OMP_TASK_CLAUSES (expr
),
6875 NULL_TREE
, NULL_TREE
,
6876 NULL_TREE
, NULL_TREE
, NULL_TREE
);
6877 gimplify_seq_add_stmt (pre_p
, g
);
6878 *expr_p
= NULL_TREE
;
6881 /* Helper function of gimplify_omp_for, find OMP_FOR resp. OMP_SIMD
6882 with non-NULL OMP_FOR_INIT. */
6885 find_combined_omp_for (tree
*tp
, int *walk_subtrees
, void *)
6888 switch (TREE_CODE (*tp
))
6894 if (OMP_FOR_INIT (*tp
) != NULL_TREE
)
6898 case STATEMENT_LIST
:
6908 /* Gimplify the gross structure of an OMP_FOR statement. */
6910 static enum gimplify_status
6911 gimplify_omp_for (tree
*expr_p
, gimple_seq
*pre_p
)
6913 tree for_stmt
, orig_for_stmt
, decl
, var
, t
;
6914 enum gimplify_status ret
= GS_ALL_DONE
;
6915 enum gimplify_status tret
;
6917 gimple_seq for_body
, for_pre_body
;
6920 bitmap has_decl_expr
= NULL
;
6922 orig_for_stmt
= for_stmt
= *expr_p
;
6924 switch (TREE_CODE (for_stmt
))
6928 case OMP_DISTRIBUTE
:
6940 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
), pre_p
,
6941 simd
? ORT_SIMD
: ORT_WORKSHARE
);
6942 if (TREE_CODE (for_stmt
) == OMP_DISTRIBUTE
)
6943 gimplify_omp_ctxp
->distribute
= true;
6945 /* Handle OMP_FOR_INIT. */
6946 for_pre_body
= NULL
;
6947 if (simd
&& OMP_FOR_PRE_BODY (for_stmt
))
6949 has_decl_expr
= BITMAP_ALLOC (NULL
);
6950 if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == DECL_EXPR
6951 && TREE_CODE (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt
)))
6954 t
= OMP_FOR_PRE_BODY (for_stmt
);
6955 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
6957 else if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == STATEMENT_LIST
)
6959 tree_stmt_iterator si
;
6960 for (si
= tsi_start (OMP_FOR_PRE_BODY (for_stmt
)); !tsi_end_p (si
);
6964 if (TREE_CODE (t
) == DECL_EXPR
6965 && TREE_CODE (DECL_EXPR_DECL (t
)) == VAR_DECL
)
6966 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
6970 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
6971 OMP_FOR_PRE_BODY (for_stmt
) = NULL_TREE
;
6973 if (OMP_FOR_INIT (for_stmt
) == NULL_TREE
)
6975 gcc_assert (TREE_CODE (for_stmt
) != OACC_LOOP
);
6976 for_stmt
= walk_tree (&OMP_FOR_BODY (for_stmt
), find_combined_omp_for
,
6978 gcc_assert (for_stmt
!= NULL_TREE
);
6979 gimplify_omp_ctxp
->combined_loop
= true;
6983 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6984 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt
)));
6985 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6986 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt
)));
6987 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6989 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6990 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6991 decl
= TREE_OPERAND (t
, 0);
6992 gcc_assert (DECL_P (decl
));
6993 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl
))
6994 || POINTER_TYPE_P (TREE_TYPE (decl
)));
6996 /* Make sure the iteration variable is private. */
6998 tree c2
= NULL_TREE
;
6999 if (orig_for_stmt
!= for_stmt
)
7000 /* Do this only on innermost construct for combined ones. */;
7003 splay_tree_node n
= splay_tree_lookup (gimplify_omp_ctxp
->variables
,
7004 (splay_tree_key
)decl
);
7005 omp_is_private (gimplify_omp_ctxp
, decl
,
7006 1 + (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
7008 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
7009 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
7010 else if (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
7012 c
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
7013 OMP_CLAUSE_LINEAR_NO_COPYIN (c
) = 1;
7015 && bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)))
7016 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
7017 OMP_CLAUSE_DECL (c
) = decl
;
7018 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
7019 OMP_FOR_CLAUSES (for_stmt
) = c
;
7020 omp_add_variable (gimplify_omp_ctxp
, decl
,
7021 GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
);
7027 || !bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)));
7029 && gimplify_omp_ctxp
->outer_context
7030 && gimplify_omp_ctxp
->outer_context
->region_type
7032 && gimplify_omp_ctxp
->outer_context
->combined_loop
7033 && !gimplify_omp_ctxp
->outer_context
->distribute
)
7035 struct gimplify_omp_ctx
*outer
7036 = gimplify_omp_ctxp
->outer_context
;
7037 n
= splay_tree_lookup (outer
->variables
,
7038 (splay_tree_key
) decl
);
7040 && (n
->value
& GOVD_DATA_SHARE_CLASS
) == GOVD_LOCAL
)
7041 lastprivate
= false;
7042 else if (omp_check_private (outer
, decl
, false))
7043 error ("lastprivate variable %qE is private in outer "
7044 "context", DECL_NAME (decl
));
7047 omp_add_variable (outer
, decl
,
7048 GOVD_LASTPRIVATE
| GOVD_SEEN
);
7049 if (outer
->outer_context
)
7050 omp_notice_variable (outer
->outer_context
, decl
, true);
7053 c
= build_omp_clause (input_location
,
7054 lastprivate
? OMP_CLAUSE_LASTPRIVATE
7055 : OMP_CLAUSE_PRIVATE
);
7056 OMP_CLAUSE_DECL (c
) = decl
;
7057 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
7058 OMP_FOR_CLAUSES (for_stmt
) = c
;
7059 omp_add_variable (gimplify_omp_ctxp
, decl
,
7060 (lastprivate
? GOVD_LASTPRIVATE
: GOVD_PRIVATE
)
7061 | GOVD_EXPLICIT
| GOVD_SEEN
);
7065 else if (omp_is_private (gimplify_omp_ctxp
, decl
, 0))
7066 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
7068 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_PRIVATE
| GOVD_SEEN
);
7070 /* If DECL is not a gimple register, create a temporary variable to act
7071 as an iteration counter. This is valid, since DECL cannot be
7072 modified in the body of the loop. Similarly for any iteration vars
7073 in simd with collapse > 1 where the iterator vars must be
7075 if (orig_for_stmt
!= for_stmt
)
7077 else if (!is_gimple_reg (decl
)
7078 || (simd
&& TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1))
7080 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
7081 TREE_OPERAND (t
, 0) = var
;
7083 gimplify_seq_add_stmt (&for_body
, gimple_build_assign (decl
, var
));
7085 if (simd
&& TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
7087 c2
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
7088 OMP_CLAUSE_LINEAR_NO_COPYIN (c2
) = 1;
7089 OMP_CLAUSE_LINEAR_NO_COPYOUT (c2
) = 1;
7090 OMP_CLAUSE_DECL (c2
) = var
;
7091 OMP_CLAUSE_CHAIN (c2
) = OMP_FOR_CLAUSES (for_stmt
);
7092 OMP_FOR_CLAUSES (for_stmt
) = c2
;
7093 omp_add_variable (gimplify_omp_ctxp
, var
,
7094 GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
);
7102 omp_add_variable (gimplify_omp_ctxp
, var
,
7103 GOVD_PRIVATE
| GOVD_SEEN
);
7108 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
7109 is_gimple_val
, fb_rvalue
);
7110 ret
= MIN (ret
, tret
);
7111 if (ret
== GS_ERROR
)
7114 /* Handle OMP_FOR_COND. */
7115 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
7116 gcc_assert (COMPARISON_CLASS_P (t
));
7117 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
7119 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
7120 is_gimple_val
, fb_rvalue
);
7121 ret
= MIN (ret
, tret
);
7123 /* Handle OMP_FOR_INCR. */
7124 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7125 switch (TREE_CODE (t
))
7127 case PREINCREMENT_EXPR
:
7128 case POSTINCREMENT_EXPR
:
7130 tree decl
= TREE_OPERAND (t
, 0);
7131 /* c_omp_for_incr_canonicalize_ptr() should have been
7132 called to massage things appropriately. */
7133 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl
)));
7135 if (orig_for_stmt
!= for_stmt
)
7137 t
= build_int_cst (TREE_TYPE (decl
), 1);
7139 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
7140 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
7141 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
7142 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
7146 case PREDECREMENT_EXPR
:
7147 case POSTDECREMENT_EXPR
:
7148 /* c_omp_for_incr_canonicalize_ptr() should have been
7149 called to massage things appropriately. */
7150 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl
)));
7151 if (orig_for_stmt
!= for_stmt
)
7153 t
= build_int_cst (TREE_TYPE (decl
), -1);
7155 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
7156 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
7157 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
7158 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
7162 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
7163 TREE_OPERAND (t
, 0) = var
;
7165 t
= TREE_OPERAND (t
, 1);
7166 switch (TREE_CODE (t
))
7169 if (TREE_OPERAND (t
, 1) == decl
)
7171 TREE_OPERAND (t
, 1) = TREE_OPERAND (t
, 0);
7172 TREE_OPERAND (t
, 0) = var
;
7178 case POINTER_PLUS_EXPR
:
7179 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
7180 TREE_OPERAND (t
, 0) = var
;
7186 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
7187 is_gimple_val
, fb_rvalue
);
7188 ret
= MIN (ret
, tret
);
7191 tree step
= TREE_OPERAND (t
, 1);
7192 tree stept
= TREE_TYPE (decl
);
7193 if (POINTER_TYPE_P (stept
))
7195 step
= fold_convert (stept
, step
);
7196 if (TREE_CODE (t
) == MINUS_EXPR
)
7197 step
= fold_build1 (NEGATE_EXPR
, stept
, step
);
7198 OMP_CLAUSE_LINEAR_STEP (c
) = step
;
7199 if (step
!= TREE_OPERAND (t
, 1))
7201 tret
= gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
),
7202 &for_pre_body
, NULL
,
7203 is_gimple_val
, fb_rvalue
);
7204 ret
= MIN (ret
, tret
);
7216 OMP_CLAUSE_LINEAR_STEP (c2
) = OMP_CLAUSE_LINEAR_STEP (c
);
7219 if ((var
!= decl
|| TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1)
7220 && orig_for_stmt
== for_stmt
)
7222 for (c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
7223 if (((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
7224 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) == NULL
)
7225 || (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
7226 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)
7227 && OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
) == NULL
))
7228 && OMP_CLAUSE_DECL (c
) == decl
)
7230 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7231 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
7232 gcc_assert (TREE_OPERAND (t
, 0) == var
);
7233 t
= TREE_OPERAND (t
, 1);
7234 gcc_assert (TREE_CODE (t
) == PLUS_EXPR
7235 || TREE_CODE (t
) == MINUS_EXPR
7236 || TREE_CODE (t
) == POINTER_PLUS_EXPR
);
7237 gcc_assert (TREE_OPERAND (t
, 0) == var
);
7238 t
= build2 (TREE_CODE (t
), TREE_TYPE (decl
), decl
,
7239 TREE_OPERAND (t
, 1));
7241 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
7242 seq
= &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
);
7244 seq
= &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
);
7245 gimplify_assign (decl
, t
, seq
);
7250 BITMAP_FREE (has_decl_expr
);
7252 gimplify_and_add (OMP_FOR_BODY (orig_for_stmt
), &for_body
);
7254 if (orig_for_stmt
!= for_stmt
)
7255 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
7257 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
7258 decl
= TREE_OPERAND (t
, 0);
7259 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
7260 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
7261 TREE_OPERAND (t
, 0) = var
;
7262 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7263 TREE_OPERAND (t
, 1) = copy_node (TREE_OPERAND (t
, 1));
7264 TREE_OPERAND (TREE_OPERAND (t
, 1), 0) = var
;
7267 gimplify_adjust_omp_clauses (pre_p
, &OMP_FOR_CLAUSES (orig_for_stmt
));
7270 switch (TREE_CODE (orig_for_stmt
))
7272 case OMP_FOR
: kind
= GF_OMP_FOR_KIND_FOR
; break;
7273 case OMP_SIMD
: kind
= GF_OMP_FOR_KIND_SIMD
; break;
7274 case CILK_SIMD
: kind
= GF_OMP_FOR_KIND_CILKSIMD
; break;
7275 case CILK_FOR
: kind
= GF_OMP_FOR_KIND_CILKFOR
; break;
7276 case OMP_DISTRIBUTE
: kind
= GF_OMP_FOR_KIND_DISTRIBUTE
; break;
7277 case OACC_LOOP
: kind
= GF_OMP_FOR_KIND_OACC_LOOP
; break;
7281 gfor
= gimple_build_omp_for (for_body
, kind
, OMP_FOR_CLAUSES (orig_for_stmt
),
7282 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)),
7284 if (orig_for_stmt
!= for_stmt
)
7285 gimple_omp_for_set_combined_p (gfor
, true);
7286 if (gimplify_omp_ctxp
7287 && (gimplify_omp_ctxp
->combined_loop
7288 || (gimplify_omp_ctxp
->region_type
== ORT_COMBINED_PARALLEL
7289 && gimplify_omp_ctxp
->outer_context
7290 && gimplify_omp_ctxp
->outer_context
->combined_loop
)))
7292 gimple_omp_for_set_combined_into_p (gfor
, true);
7293 if (gimplify_omp_ctxp
->combined_loop
)
7294 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_SIMD
);
7296 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_FOR
);
7299 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
7301 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
7302 gimple_omp_for_set_index (gfor
, i
, TREE_OPERAND (t
, 0));
7303 gimple_omp_for_set_initial (gfor
, i
, TREE_OPERAND (t
, 1));
7304 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
7305 gimple_omp_for_set_cond (gfor
, i
, TREE_CODE (t
));
7306 gimple_omp_for_set_final (gfor
, i
, TREE_OPERAND (t
, 1));
7307 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7308 gimple_omp_for_set_incr (gfor
, i
, TREE_OPERAND (t
, 1));
7311 gimplify_seq_add_stmt (pre_p
, gfor
);
7312 if (ret
!= GS_ALL_DONE
)
7314 *expr_p
= NULL_TREE
;
7318 /* Gimplify the gross structure of several OMP constructs. */
7321 gimplify_omp_workshare (tree
*expr_p
, gimple_seq
*pre_p
)
7323 tree expr
= *expr_p
;
7325 gimple_seq body
= NULL
;
7326 enum omp_region_type ort
;
7328 switch (TREE_CODE (expr
))
7332 ort
= ORT_WORKSHARE
;
7340 case OMP_TARGET_DATA
:
7341 ort
= ORT_TARGET_DATA
;
7349 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr
), pre_p
, ort
);
7350 if (ort
== ORT_TARGET
|| ort
== ORT_TARGET_DATA
)
7352 push_gimplify_context ();
7353 gimple g
= gimplify_and_return_first (OMP_BODY (expr
), &body
);
7354 if (gimple_code (g
) == GIMPLE_BIND
)
7355 pop_gimplify_context (g
);
7357 pop_gimplify_context (NULL
);
7358 if (ort
== ORT_TARGET_DATA
)
7360 enum built_in_function end_ix
;
7361 switch (TREE_CODE (expr
))
7364 end_ix
= BUILT_IN_GOACC_DATA_END
;
7366 case OMP_TARGET_DATA
:
7367 end_ix
= BUILT_IN_GOMP_TARGET_END_DATA
;
7372 tree fn
= builtin_decl_explicit (end_ix
);
7373 g
= gimple_build_call (fn
, 0);
7374 gimple_seq cleanup
= NULL
;
7375 gimple_seq_add_stmt (&cleanup
, g
);
7376 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
7378 gimple_seq_add_stmt (&body
, g
);
7382 gimplify_and_add (OMP_BODY (expr
), &body
);
7383 gimplify_adjust_omp_clauses (pre_p
, &OMP_CLAUSES (expr
));
7385 switch (TREE_CODE (expr
))
7388 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_DATA
,
7389 OMP_CLAUSES (expr
));
7392 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_KERNELS
,
7393 OMP_CLAUSES (expr
));
7396 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_PARALLEL
,
7397 OMP_CLAUSES (expr
));
7400 stmt
= gimple_build_omp_sections (body
, OMP_CLAUSES (expr
));
7403 stmt
= gimple_build_omp_single (body
, OMP_CLAUSES (expr
));
7406 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_REGION
,
7407 OMP_CLAUSES (expr
));
7409 case OMP_TARGET_DATA
:
7410 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_DATA
,
7411 OMP_CLAUSES (expr
));
7414 stmt
= gimple_build_omp_teams (body
, OMP_CLAUSES (expr
));
7420 gimplify_seq_add_stmt (pre_p
, stmt
);
7421 *expr_p
= NULL_TREE
;
7424 /* Gimplify the gross structure of OpenACC enter/exit data, update, and OpenMP
7425 target update constructs. */
7428 gimplify_omp_target_update (tree
*expr_p
, gimple_seq
*pre_p
)
7430 tree expr
= *expr_p
, clauses
;
7434 switch (TREE_CODE (expr
))
7436 case OACC_ENTER_DATA
:
7437 clauses
= OACC_ENTER_DATA_CLAUSES (expr
);
7438 kind
= GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
;
7440 case OACC_EXIT_DATA
:
7441 clauses
= OACC_EXIT_DATA_CLAUSES (expr
);
7442 kind
= GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
;
7445 clauses
= OACC_UPDATE_CLAUSES (expr
);
7446 kind
= GF_OMP_TARGET_KIND_OACC_UPDATE
;
7448 case OMP_TARGET_UPDATE
:
7449 clauses
= OMP_TARGET_UPDATE_CLAUSES (expr
);
7450 kind
= GF_OMP_TARGET_KIND_UPDATE
;
7455 gimplify_scan_omp_clauses (&clauses
, pre_p
, ORT_WORKSHARE
);
7456 gimplify_adjust_omp_clauses (pre_p
, &clauses
);
7457 stmt
= gimple_build_omp_target (NULL
, kind
, clauses
);
7459 gimplify_seq_add_stmt (pre_p
, stmt
);
7460 *expr_p
= NULL_TREE
;
7463 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
7464 stabilized the lhs of the atomic operation as *ADDR. Return true if
7465 EXPR is this stabilized form. */
7468 goa_lhs_expr_p (tree expr
, tree addr
)
7470 /* Also include casts to other type variants. The C front end is fond
7471 of adding these for e.g. volatile variables. This is like
7472 STRIP_TYPE_NOPS but includes the main variant lookup. */
7473 STRIP_USELESS_TYPE_CONVERSION (expr
);
7475 if (TREE_CODE (expr
) == INDIRECT_REF
)
7477 expr
= TREE_OPERAND (expr
, 0);
7479 && (CONVERT_EXPR_P (expr
)
7480 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
7481 && TREE_CODE (expr
) == TREE_CODE (addr
)
7482 && types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (addr
)))
7484 expr
= TREE_OPERAND (expr
, 0);
7485 addr
= TREE_OPERAND (addr
, 0);
7489 return (TREE_CODE (addr
) == ADDR_EXPR
7490 && TREE_CODE (expr
) == ADDR_EXPR
7491 && TREE_OPERAND (addr
, 0) == TREE_OPERAND (expr
, 0));
7493 if (TREE_CODE (addr
) == ADDR_EXPR
&& expr
== TREE_OPERAND (addr
, 0))
7498 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
7499 expression does not involve the lhs, evaluate it into a temporary.
7500 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
7501 or -1 if an error was encountered. */
7504 goa_stabilize_expr (tree
*expr_p
, gimple_seq
*pre_p
, tree lhs_addr
,
7507 tree expr
= *expr_p
;
7510 if (goa_lhs_expr_p (expr
, lhs_addr
))
7515 if (is_gimple_val (expr
))
7519 switch (TREE_CODE_CLASS (TREE_CODE (expr
)))
7522 case tcc_comparison
:
7523 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
, lhs_addr
,
7526 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
, lhs_addr
,
7529 case tcc_expression
:
7530 switch (TREE_CODE (expr
))
7532 case TRUTH_ANDIF_EXPR
:
7533 case TRUTH_ORIF_EXPR
:
7534 case TRUTH_AND_EXPR
:
7536 case TRUTH_XOR_EXPR
:
7537 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
,
7539 case TRUTH_NOT_EXPR
:
7540 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
7544 /* Break out any preevaluations from cp_build_modify_expr. */
7545 for (; TREE_CODE (expr
) == COMPOUND_EXPR
;
7546 expr
= TREE_OPERAND (expr
, 1))
7547 gimplify_stmt (&TREE_OPERAND (expr
, 0), pre_p
);
7549 return goa_stabilize_expr (expr_p
, pre_p
, lhs_addr
, lhs_var
);
7560 enum gimplify_status gs
;
7561 gs
= gimplify_expr (expr_p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
7562 if (gs
!= GS_ALL_DONE
)
7569 /* Gimplify an OMP_ATOMIC statement. */
7571 static enum gimplify_status
7572 gimplify_omp_atomic (tree
*expr_p
, gimple_seq
*pre_p
)
7574 tree addr
= TREE_OPERAND (*expr_p
, 0);
7575 tree rhs
= TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
7576 ? NULL
: TREE_OPERAND (*expr_p
, 1);
7577 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
7579 gomp_atomic_load
*loadstmt
;
7580 gomp_atomic_store
*storestmt
;
7582 tmp_load
= create_tmp_reg (type
);
7583 if (rhs
&& goa_stabilize_expr (&rhs
, pre_p
, addr
, tmp_load
) < 0)
7586 if (gimplify_expr (&addr
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7590 loadstmt
= gimple_build_omp_atomic_load (tmp_load
, addr
);
7591 gimplify_seq_add_stmt (pre_p
, loadstmt
);
7592 if (rhs
&& gimplify_expr (&rhs
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7596 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
)
7598 storestmt
= gimple_build_omp_atomic_store (rhs
);
7599 gimplify_seq_add_stmt (pre_p
, storestmt
);
7600 if (OMP_ATOMIC_SEQ_CST (*expr_p
))
7602 gimple_omp_atomic_set_seq_cst (loadstmt
);
7603 gimple_omp_atomic_set_seq_cst (storestmt
);
7605 switch (TREE_CODE (*expr_p
))
7607 case OMP_ATOMIC_READ
:
7608 case OMP_ATOMIC_CAPTURE_OLD
:
7610 gimple_omp_atomic_set_need_value (loadstmt
);
7612 case OMP_ATOMIC_CAPTURE_NEW
:
7614 gimple_omp_atomic_set_need_value (storestmt
);
7624 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
7625 body, and adding some EH bits. */
7627 static enum gimplify_status
7628 gimplify_transaction (tree
*expr_p
, gimple_seq
*pre_p
)
7630 tree expr
= *expr_p
, temp
, tbody
= TRANSACTION_EXPR_BODY (expr
);
7632 gtransaction
*trans_stmt
;
7633 gimple_seq body
= NULL
;
7636 /* Wrap the transaction body in a BIND_EXPR so we have a context
7637 where to put decls for OMP. */
7638 if (TREE_CODE (tbody
) != BIND_EXPR
)
7640 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, tbody
, NULL
);
7641 TREE_SIDE_EFFECTS (bind
) = 1;
7642 SET_EXPR_LOCATION (bind
, EXPR_LOCATION (tbody
));
7643 TRANSACTION_EXPR_BODY (expr
) = bind
;
7646 push_gimplify_context ();
7647 temp
= voidify_wrapper_expr (*expr_p
, NULL
);
7649 body_stmt
= gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr
), &body
);
7650 pop_gimplify_context (body_stmt
);
7652 trans_stmt
= gimple_build_transaction (body
, NULL
);
7653 if (TRANSACTION_EXPR_OUTER (expr
))
7654 subcode
= GTMA_IS_OUTER
;
7655 else if (TRANSACTION_EXPR_RELAXED (expr
))
7656 subcode
= GTMA_IS_RELAXED
;
7657 gimple_transaction_set_subcode (trans_stmt
, subcode
);
7659 gimplify_seq_add_stmt (pre_p
, trans_stmt
);
7667 *expr_p
= NULL_TREE
;
7671 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
7672 expression produces a value to be used as an operand inside a GIMPLE
7673 statement, the value will be stored back in *EXPR_P. This value will
7674 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
7675 an SSA_NAME. The corresponding sequence of GIMPLE statements is
7676 emitted in PRE_P and POST_P.
7678 Additionally, this process may overwrite parts of the input
7679 expression during gimplification. Ideally, it should be
7680 possible to do non-destructive gimplification.
7682 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
7683 the expression needs to evaluate to a value to be used as
7684 an operand in a GIMPLE statement, this value will be stored in
7685 *EXPR_P on exit. This happens when the caller specifies one
7686 of fb_lvalue or fb_rvalue fallback flags.
7688 PRE_P will contain the sequence of GIMPLE statements corresponding
7689 to the evaluation of EXPR and all the side-effects that must
7690 be executed before the main expression. On exit, the last
7691 statement of PRE_P is the core statement being gimplified. For
7692 instance, when gimplifying 'if (++a)' the last statement in
7693 PRE_P will be 'if (t.1)' where t.1 is the result of
7694 pre-incrementing 'a'.
7696 POST_P will contain the sequence of GIMPLE statements corresponding
7697 to the evaluation of all the side-effects that must be executed
7698 after the main expression. If this is NULL, the post
7699 side-effects are stored at the end of PRE_P.
7701 The reason why the output is split in two is to handle post
7702 side-effects explicitly. In some cases, an expression may have
7703 inner and outer post side-effects which need to be emitted in
7704 an order different from the one given by the recursive
7705 traversal. For instance, for the expression (*p--)++ the post
7706 side-effects of '--' must actually occur *after* the post
7707 side-effects of '++'. However, gimplification will first visit
7708 the inner expression, so if a separate POST sequence was not
7709 used, the resulting sequence would be:
7716 However, the post-decrement operation in line #2 must not be
7717 evaluated until after the store to *p at line #4, so the
7718 correct sequence should be:
7725 So, by specifying a separate post queue, it is possible
7726 to emit the post side-effects in the correct order.
7727 If POST_P is NULL, an internal queue will be used. Before
7728 returning to the caller, the sequence POST_P is appended to
7729 the main output sequence PRE_P.
7731 GIMPLE_TEST_F points to a function that takes a tree T and
7732 returns nonzero if T is in the GIMPLE form requested by the
7733 caller. The GIMPLE predicates are in gimple.c.
7735 FALLBACK tells the function what sort of a temporary we want if
7736 gimplification cannot produce an expression that complies with
7739 fb_none means that no temporary should be generated
7740 fb_rvalue means that an rvalue is OK to generate
7741 fb_lvalue means that an lvalue is OK to generate
7742 fb_either means that either is OK, but an lvalue is preferable.
7743 fb_mayfail means that gimplification may fail (in which case
7744 GS_ERROR will be returned)
7746 The return value is either GS_ERROR or GS_ALL_DONE, since this
7747 function iterates until EXPR is completely gimplified or an error
7750 enum gimplify_status
7751 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
7752 bool (*gimple_test_f
) (tree
), fallback_t fallback
)
7755 gimple_seq internal_pre
= NULL
;
7756 gimple_seq internal_post
= NULL
;
7759 location_t saved_location
;
7760 enum gimplify_status ret
;
7761 gimple_stmt_iterator pre_last_gsi
, post_last_gsi
;
7763 save_expr
= *expr_p
;
7764 if (save_expr
== NULL_TREE
)
7767 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
7768 is_statement
= gimple_test_f
== is_gimple_stmt
;
7772 /* Consistency checks. */
7773 if (gimple_test_f
== is_gimple_reg
)
7774 gcc_assert (fallback
& (fb_rvalue
| fb_lvalue
));
7775 else if (gimple_test_f
== is_gimple_val
7776 || gimple_test_f
== is_gimple_call_addr
7777 || gimple_test_f
== is_gimple_condexpr
7778 || gimple_test_f
== is_gimple_mem_rhs
7779 || gimple_test_f
== is_gimple_mem_rhs_or_call
7780 || gimple_test_f
== is_gimple_reg_rhs
7781 || gimple_test_f
== is_gimple_reg_rhs_or_call
7782 || gimple_test_f
== is_gimple_asm_val
7783 || gimple_test_f
== is_gimple_mem_ref_addr
)
7784 gcc_assert (fallback
& fb_rvalue
);
7785 else if (gimple_test_f
== is_gimple_min_lval
7786 || gimple_test_f
== is_gimple_lvalue
)
7787 gcc_assert (fallback
& fb_lvalue
);
7788 else if (gimple_test_f
== is_gimple_addressable
)
7789 gcc_assert (fallback
& fb_either
);
7790 else if (gimple_test_f
== is_gimple_stmt
)
7791 gcc_assert (fallback
== fb_none
);
7794 /* We should have recognized the GIMPLE_TEST_F predicate to
7795 know what kind of fallback to use in case a temporary is
7796 needed to hold the value or address of *EXPR_P. */
7800 /* We used to check the predicate here and return immediately if it
7801 succeeds. This is wrong; the design is for gimplification to be
7802 idempotent, and for the predicates to only test for valid forms, not
7803 whether they are fully simplified. */
7805 pre_p
= &internal_pre
;
7808 post_p
= &internal_post
;
7810 /* Remember the last statements added to PRE_P and POST_P. Every
7811 new statement added by the gimplification helpers needs to be
7812 annotated with location information. To centralize the
7813 responsibility, we remember the last statement that had been
7814 added to both queues before gimplifying *EXPR_P. If
7815 gimplification produces new statements in PRE_P and POST_P, those
7816 statements will be annotated with the same location information
7818 pre_last_gsi
= gsi_last (*pre_p
);
7819 post_last_gsi
= gsi_last (*post_p
);
7821 saved_location
= input_location
;
7822 if (save_expr
!= error_mark_node
7823 && EXPR_HAS_LOCATION (*expr_p
))
7824 input_location
= EXPR_LOCATION (*expr_p
);
7826 /* Loop over the specific gimplifiers until the toplevel node
7827 remains the same. */
7830 /* Strip away as many useless type conversions as possible
7832 STRIP_USELESS_TYPE_CONVERSION (*expr_p
);
7834 /* Remember the expr. */
7835 save_expr
= *expr_p
;
7837 /* Die, die, die, my darling. */
7838 if (save_expr
== error_mark_node
7839 || (TREE_TYPE (save_expr
)
7840 && TREE_TYPE (save_expr
) == error_mark_node
))
7846 /* Do any language-specific gimplification. */
7847 ret
= ((enum gimplify_status
)
7848 lang_hooks
.gimplify_expr (expr_p
, pre_p
, post_p
));
7851 if (*expr_p
== NULL_TREE
)
7853 if (*expr_p
!= save_expr
)
7856 else if (ret
!= GS_UNHANDLED
)
7859 /* Make sure that all the cases set 'ret' appropriately. */
7861 switch (TREE_CODE (*expr_p
))
7863 /* First deal with the special cases. */
7865 case POSTINCREMENT_EXPR
:
7866 case POSTDECREMENT_EXPR
:
7867 case PREINCREMENT_EXPR
:
7868 case PREDECREMENT_EXPR
:
7869 ret
= gimplify_self_mod_expr (expr_p
, pre_p
, post_p
,
7870 fallback
!= fb_none
,
7871 TREE_TYPE (*expr_p
));
7874 case VIEW_CONVERT_EXPR
:
7875 if (is_gimple_reg_type (TREE_TYPE (*expr_p
))
7876 && is_gimple_reg_type (TREE_TYPE (TREE_OPERAND (*expr_p
, 0))))
7878 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7879 post_p
, is_gimple_val
, fb_rvalue
);
7880 recalculate_side_effects (*expr_p
);
7886 case ARRAY_RANGE_REF
:
7890 ret
= gimplify_compound_lval (expr_p
, pre_p
, post_p
,
7891 fallback
? fallback
: fb_rvalue
);
7895 ret
= gimplify_cond_expr (expr_p
, pre_p
, fallback
);
7897 /* C99 code may assign to an array in a structure value of a
7898 conditional expression, and this has undefined behavior
7899 only on execution, so create a temporary if an lvalue is
7901 if (fallback
== fb_lvalue
)
7903 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7904 mark_addressable (*expr_p
);
7910 ret
= gimplify_call_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7912 /* C99 code may assign to an array in a structure returned
7913 from a function, and this has undefined behavior only on
7914 execution, so create a temporary if an lvalue is
7916 if (fallback
== fb_lvalue
)
7918 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7919 mark_addressable (*expr_p
);
7928 ret
= gimplify_compound_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7931 case COMPOUND_LITERAL_EXPR
:
7932 ret
= gimplify_compound_literal_expr (expr_p
, pre_p
,
7933 gimple_test_f
, fallback
);
7938 ret
= gimplify_modify_expr (expr_p
, pre_p
, post_p
,
7939 fallback
!= fb_none
);
7942 case TRUTH_ANDIF_EXPR
:
7943 case TRUTH_ORIF_EXPR
:
7945 /* Preserve the original type of the expression and the
7946 source location of the outer expression. */
7947 tree org_type
= TREE_TYPE (*expr_p
);
7948 *expr_p
= gimple_boolify (*expr_p
);
7949 *expr_p
= build3_loc (input_location
, COND_EXPR
,
7953 org_type
, boolean_true_node
),
7956 org_type
, boolean_false_node
));
7961 case TRUTH_NOT_EXPR
:
7963 tree type
= TREE_TYPE (*expr_p
);
7964 /* The parsers are careful to generate TRUTH_NOT_EXPR
7965 only with operands that are always zero or one.
7966 We do not fold here but handle the only interesting case
7967 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
7968 *expr_p
= gimple_boolify (*expr_p
);
7969 if (TYPE_PRECISION (TREE_TYPE (*expr_p
)) == 1)
7970 *expr_p
= build1_loc (input_location
, BIT_NOT_EXPR
,
7971 TREE_TYPE (*expr_p
),
7972 TREE_OPERAND (*expr_p
, 0));
7974 *expr_p
= build2_loc (input_location
, BIT_XOR_EXPR
,
7975 TREE_TYPE (*expr_p
),
7976 TREE_OPERAND (*expr_p
, 0),
7977 build_int_cst (TREE_TYPE (*expr_p
), 1));
7978 if (!useless_type_conversion_p (type
, TREE_TYPE (*expr_p
)))
7979 *expr_p
= fold_convert_loc (input_location
, type
, *expr_p
);
7985 ret
= gimplify_addr_expr (expr_p
, pre_p
, post_p
);
7990 tree cond
= TREE_OPERAND (*expr_p
, 0);
7991 tree kind
= TREE_OPERAND (*expr_p
, 1);
7992 tree type
= TREE_TYPE (cond
);
7993 if (!INTEGRAL_TYPE_P (type
))
7999 tree tmp
= create_tmp_var (type
);
8000 gimplify_arg (&cond
, pre_p
, EXPR_LOCATION (*expr_p
));
8002 = gimple_build_call_internal (IFN_ANNOTATE
, 2, cond
, kind
);
8003 gimple_call_set_lhs (call
, tmp
);
8004 gimplify_seq_add_stmt (pre_p
, call
);
8011 ret
= gimplify_va_arg_expr (expr_p
, pre_p
, post_p
);
8015 if (IS_EMPTY_STMT (*expr_p
))
8021 if (VOID_TYPE_P (TREE_TYPE (*expr_p
))
8022 || fallback
== fb_none
)
8024 /* Just strip a conversion to void (or in void context) and
8026 *expr_p
= TREE_OPERAND (*expr_p
, 0);
8031 ret
= gimplify_conversion (expr_p
);
8032 if (ret
== GS_ERROR
)
8034 if (*expr_p
!= save_expr
)
8038 case FIX_TRUNC_EXPR
:
8039 /* unary_expr: ... | '(' cast ')' val | ... */
8040 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8041 is_gimple_val
, fb_rvalue
);
8042 recalculate_side_effects (*expr_p
);
8047 bool volatilep
= TREE_THIS_VOLATILE (*expr_p
);
8048 bool notrap
= TREE_THIS_NOTRAP (*expr_p
);
8049 tree saved_ptr_type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 0));
8051 *expr_p
= fold_indirect_ref_loc (input_location
, *expr_p
);
8052 if (*expr_p
!= save_expr
)
8058 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8059 is_gimple_reg
, fb_rvalue
);
8060 if (ret
== GS_ERROR
)
8063 recalculate_side_effects (*expr_p
);
8064 *expr_p
= fold_build2_loc (input_location
, MEM_REF
,
8065 TREE_TYPE (*expr_p
),
8066 TREE_OPERAND (*expr_p
, 0),
8067 build_int_cst (saved_ptr_type
, 0));
8068 TREE_THIS_VOLATILE (*expr_p
) = volatilep
;
8069 TREE_THIS_NOTRAP (*expr_p
) = notrap
;
8074 /* We arrive here through the various re-gimplifcation paths. */
8076 /* First try re-folding the whole thing. */
8077 tmp
= fold_binary (MEM_REF
, TREE_TYPE (*expr_p
),
8078 TREE_OPERAND (*expr_p
, 0),
8079 TREE_OPERAND (*expr_p
, 1));
8083 recalculate_side_effects (*expr_p
);
8087 /* Avoid re-gimplifying the address operand if it is already
8088 in suitable form. Re-gimplifying would mark the address
8089 operand addressable. Always gimplify when not in SSA form
8090 as we still may have to gimplify decls with value-exprs. */
8091 if (!gimplify_ctxp
|| !gimplify_ctxp
->into_ssa
8092 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p
, 0)))
8094 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8095 is_gimple_mem_ref_addr
, fb_rvalue
);
8096 if (ret
== GS_ERROR
)
8099 recalculate_side_effects (*expr_p
);
8103 /* Constants need not be gimplified. */
8110 /* Drop the overflow flag on constants, we do not want
8111 that in the GIMPLE IL. */
8112 if (TREE_OVERFLOW_P (*expr_p
))
8113 *expr_p
= drop_tree_overflow (*expr_p
);
8118 /* If we require an lvalue, such as for ADDR_EXPR, retain the
8119 CONST_DECL node. Otherwise the decl is replaceable by its
8121 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
8122 if (fallback
& fb_lvalue
)
8126 *expr_p
= DECL_INITIAL (*expr_p
);
8132 ret
= gimplify_decl_expr (expr_p
, pre_p
);
8136 ret
= gimplify_bind_expr (expr_p
, pre_p
);
8140 ret
= gimplify_loop_expr (expr_p
, pre_p
);
8144 ret
= gimplify_switch_expr (expr_p
, pre_p
);
8148 ret
= gimplify_exit_expr (expr_p
);
8152 /* If the target is not LABEL, then it is a computed jump
8153 and the target needs to be gimplified. */
8154 if (TREE_CODE (GOTO_DESTINATION (*expr_p
)) != LABEL_DECL
)
8156 ret
= gimplify_expr (&GOTO_DESTINATION (*expr_p
), pre_p
,
8157 NULL
, is_gimple_val
, fb_rvalue
);
8158 if (ret
== GS_ERROR
)
8161 gimplify_seq_add_stmt (pre_p
,
8162 gimple_build_goto (GOTO_DESTINATION (*expr_p
)));
8167 gimplify_seq_add_stmt (pre_p
,
8168 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p
),
8169 PREDICT_EXPR_OUTCOME (*expr_p
)));
8175 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p
))
8176 == current_function_decl
);
8177 gimplify_seq_add_stmt (pre_p
,
8178 gimple_build_label (LABEL_EXPR_LABEL (*expr_p
)));
8181 case CASE_LABEL_EXPR
:
8182 ret
= gimplify_case_label_expr (expr_p
, pre_p
);
8186 ret
= gimplify_return_expr (*expr_p
, pre_p
);
8190 /* Don't reduce this in place; let gimplify_init_constructor work its
8191 magic. Buf if we're just elaborating this for side effects, just
8192 gimplify any element that has side-effects. */
8193 if (fallback
== fb_none
)
8195 unsigned HOST_WIDE_INT ix
;
8197 tree temp
= NULL_TREE
;
8198 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p
), ix
, val
)
8199 if (TREE_SIDE_EFFECTS (val
))
8200 append_to_statement_list (val
, &temp
);
8203 ret
= temp
? GS_OK
: GS_ALL_DONE
;
8205 /* C99 code may assign to an array in a constructed
8206 structure or union, and this has undefined behavior only
8207 on execution, so create a temporary if an lvalue is
8209 else if (fallback
== fb_lvalue
)
8211 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
8212 mark_addressable (*expr_p
);
8219 /* The following are special cases that are not handled by the
8220 original GIMPLE grammar. */
8222 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
8225 ret
= gimplify_save_expr (expr_p
, pre_p
, post_p
);
8229 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8230 post_p
, is_gimple_lvalue
, fb_either
);
8231 recalculate_side_effects (*expr_p
);
8234 case TARGET_MEM_REF
:
8236 enum gimplify_status r0
= GS_ALL_DONE
, r1
= GS_ALL_DONE
;
8238 if (TMR_BASE (*expr_p
))
8239 r0
= gimplify_expr (&TMR_BASE (*expr_p
), pre_p
,
8240 post_p
, is_gimple_mem_ref_addr
, fb_either
);
8241 if (TMR_INDEX (*expr_p
))
8242 r1
= gimplify_expr (&TMR_INDEX (*expr_p
), pre_p
,
8243 post_p
, is_gimple_val
, fb_rvalue
);
8244 if (TMR_INDEX2 (*expr_p
))
8245 r1
= gimplify_expr (&TMR_INDEX2 (*expr_p
), pre_p
,
8246 post_p
, is_gimple_val
, fb_rvalue
);
8247 /* TMR_STEP and TMR_OFFSET are always integer constants. */
8252 case NON_LVALUE_EXPR
:
8253 /* This should have been stripped above. */
8257 ret
= gimplify_asm_expr (expr_p
, pre_p
, post_p
);
8260 case TRY_FINALLY_EXPR
:
8261 case TRY_CATCH_EXPR
:
8263 gimple_seq eval
, cleanup
;
8266 /* Calls to destructors are generated automatically in FINALLY/CATCH
8267 block. They should have location as UNKNOWN_LOCATION. However,
8268 gimplify_call_expr will reset these call stmts to input_location
8269 if it finds stmt's location is unknown. To prevent resetting for
8270 destructors, we set the input_location to unknown.
8271 Note that this only affects the destructor calls in FINALLY/CATCH
8272 block, and will automatically reset to its original value by the
8273 end of gimplify_expr. */
8274 input_location
= UNKNOWN_LOCATION
;
8275 eval
= cleanup
= NULL
;
8276 gimplify_and_add (TREE_OPERAND (*expr_p
, 0), &eval
);
8277 gimplify_and_add (TREE_OPERAND (*expr_p
, 1), &cleanup
);
8278 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
8279 if (gimple_seq_empty_p (cleanup
))
8281 gimple_seq_add_seq (pre_p
, eval
);
8285 try_
= gimple_build_try (eval
, cleanup
,
8286 TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
8287 ? GIMPLE_TRY_FINALLY
8288 : GIMPLE_TRY_CATCH
);
8289 if (EXPR_HAS_LOCATION (save_expr
))
8290 gimple_set_location (try_
, EXPR_LOCATION (save_expr
));
8291 else if (LOCATION_LOCUS (saved_location
) != UNKNOWN_LOCATION
)
8292 gimple_set_location (try_
, saved_location
);
8293 if (TREE_CODE (*expr_p
) == TRY_CATCH_EXPR
)
8294 gimple_try_set_catch_is_cleanup (try_
,
8295 TRY_CATCH_IS_CLEANUP (*expr_p
));
8296 gimplify_seq_add_stmt (pre_p
, try_
);
8301 case CLEANUP_POINT_EXPR
:
8302 ret
= gimplify_cleanup_point_expr (expr_p
, pre_p
);
8306 ret
= gimplify_target_expr (expr_p
, pre_p
, post_p
);
8312 gimple_seq handler
= NULL
;
8313 gimplify_and_add (CATCH_BODY (*expr_p
), &handler
);
8314 c
= gimple_build_catch (CATCH_TYPES (*expr_p
), handler
);
8315 gimplify_seq_add_stmt (pre_p
, c
);
8320 case EH_FILTER_EXPR
:
8323 gimple_seq failure
= NULL
;
8325 gimplify_and_add (EH_FILTER_FAILURE (*expr_p
), &failure
);
8326 ehf
= gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p
), failure
);
8327 gimple_set_no_warning (ehf
, TREE_NO_WARNING (*expr_p
));
8328 gimplify_seq_add_stmt (pre_p
, ehf
);
8335 enum gimplify_status r0
, r1
;
8336 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
,
8337 post_p
, is_gimple_val
, fb_rvalue
);
8338 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
,
8339 post_p
, is_gimple_val
, fb_rvalue
);
8340 TREE_SIDE_EFFECTS (*expr_p
) = 0;
8346 /* We get here when taking the address of a label. We mark
8347 the label as "forced"; meaning it can never be removed and
8348 it is a potential target for any computed goto. */
8349 FORCED_LABEL (*expr_p
) = 1;
8353 case STATEMENT_LIST
:
8354 ret
= gimplify_statement_list (expr_p
, pre_p
);
8357 case WITH_SIZE_EXPR
:
8359 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8360 post_p
== &internal_post
? NULL
: post_p
,
8361 gimple_test_f
, fallback
);
8362 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
8363 is_gimple_val
, fb_rvalue
);
8370 ret
= gimplify_var_or_parm_decl (expr_p
);
8374 /* When within an OMP context, notice uses of variables. */
8375 if (gimplify_omp_ctxp
)
8376 omp_notice_variable (gimplify_omp_ctxp
, *expr_p
, true);
8381 /* Allow callbacks into the gimplifier during optimization. */
8386 gimplify_omp_parallel (expr_p
, pre_p
);
8391 gimplify_omp_task (expr_p
, pre_p
);
8399 case OMP_DISTRIBUTE
:
8401 ret
= gimplify_omp_for (expr_p
, pre_p
);
8405 gimplify_oacc_cache (expr_p
, pre_p
);
8409 case OACC_HOST_DATA
:
8411 sorry ("directive not yet implemented");
8416 if (OACC_KERNELS_COMBINED (*expr_p
))
8417 sorry ("directive not yet implemented");
8419 gimplify_omp_workshare (expr_p
, pre_p
);
8424 if (OACC_PARALLEL_COMBINED (*expr_p
))
8425 sorry ("directive not yet implemented");
8427 gimplify_omp_workshare (expr_p
, pre_p
);
8435 case OMP_TARGET_DATA
:
8437 gimplify_omp_workshare (expr_p
, pre_p
);
8441 case OACC_ENTER_DATA
:
8442 case OACC_EXIT_DATA
:
8444 case OMP_TARGET_UPDATE
:
8445 gimplify_omp_target_update (expr_p
, pre_p
);
8455 gimple_seq body
= NULL
;
8458 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
8459 switch (TREE_CODE (*expr_p
))
8462 g
= gimple_build_omp_section (body
);
8465 g
= gimple_build_omp_master (body
);
8469 gimple_seq cleanup
= NULL
;
8471 = builtin_decl_explicit (BUILT_IN_GOMP_TASKGROUP_END
);
8472 g
= gimple_build_call (fn
, 0);
8473 gimple_seq_add_stmt (&cleanup
, g
);
8474 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
8476 gimple_seq_add_stmt (&body
, g
);
8477 g
= gimple_build_omp_taskgroup (body
);
8481 g
= gimple_build_omp_ordered (body
);
8484 g
= gimple_build_omp_critical (body
,
8485 OMP_CRITICAL_NAME (*expr_p
));
8490 gimplify_seq_add_stmt (pre_p
, g
);
8496 case OMP_ATOMIC_READ
:
8497 case OMP_ATOMIC_CAPTURE_OLD
:
8498 case OMP_ATOMIC_CAPTURE_NEW
:
8499 ret
= gimplify_omp_atomic (expr_p
, pre_p
);
8502 case TRANSACTION_EXPR
:
8503 ret
= gimplify_transaction (expr_p
, pre_p
);
8506 case TRUTH_AND_EXPR
:
8508 case TRUTH_XOR_EXPR
:
8510 tree orig_type
= TREE_TYPE (*expr_p
);
8511 tree new_type
, xop0
, xop1
;
8512 *expr_p
= gimple_boolify (*expr_p
);
8513 new_type
= TREE_TYPE (*expr_p
);
8514 if (!useless_type_conversion_p (orig_type
, new_type
))
8516 *expr_p
= fold_convert_loc (input_location
, orig_type
, *expr_p
);
8521 /* Boolified binary truth expressions are semantically equivalent
8522 to bitwise binary expressions. Canonicalize them to the
8524 switch (TREE_CODE (*expr_p
))
8526 case TRUTH_AND_EXPR
:
8527 TREE_SET_CODE (*expr_p
, BIT_AND_EXPR
);
8530 TREE_SET_CODE (*expr_p
, BIT_IOR_EXPR
);
8532 case TRUTH_XOR_EXPR
:
8533 TREE_SET_CODE (*expr_p
, BIT_XOR_EXPR
);
8538 /* Now make sure that operands have compatible type to
8539 expression's new_type. */
8540 xop0
= TREE_OPERAND (*expr_p
, 0);
8541 xop1
= TREE_OPERAND (*expr_p
, 1);
8542 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop0
)))
8543 TREE_OPERAND (*expr_p
, 0) = fold_convert_loc (input_location
,
8546 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop1
)))
8547 TREE_OPERAND (*expr_p
, 1) = fold_convert_loc (input_location
,
8550 /* Continue classified as tcc_binary. */
8557 /* Classified as tcc_expression. */
8560 case POINTER_PLUS_EXPR
:
8562 enum gimplify_status r0
, r1
;
8563 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8564 post_p
, is_gimple_val
, fb_rvalue
);
8565 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
8566 post_p
, is_gimple_val
, fb_rvalue
);
8567 recalculate_side_effects (*expr_p
);
8572 case CILK_SYNC_STMT
:
8574 if (!fn_contains_cilk_spawn_p (cfun
))
8576 error_at (EXPR_LOCATION (*expr_p
),
8577 "expected %<_Cilk_spawn%> before %<_Cilk_sync%>");
8582 gimplify_cilk_sync (expr_p
, pre_p
);
8589 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p
)))
8591 case tcc_comparison
:
8592 /* Handle comparison of objects of non scalar mode aggregates
8593 with a call to memcmp. It would be nice to only have to do
8594 this for variable-sized objects, but then we'd have to allow
8595 the same nest of reference nodes we allow for MODIFY_EXPR and
8598 Compare scalar mode aggregates as scalar mode values. Using
8599 memcmp for them would be very inefficient at best, and is
8600 plain wrong if bitfields are involved. */
8602 tree type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 1));
8604 /* Vector comparisons need no boolification. */
8605 if (TREE_CODE (type
) == VECTOR_TYPE
)
8607 else if (!AGGREGATE_TYPE_P (type
))
8609 tree org_type
= TREE_TYPE (*expr_p
);
8610 *expr_p
= gimple_boolify (*expr_p
);
8611 if (!useless_type_conversion_p (org_type
,
8612 TREE_TYPE (*expr_p
)))
8614 *expr_p
= fold_convert_loc (input_location
,
8621 else if (TYPE_MODE (type
) != BLKmode
)
8622 ret
= gimplify_scalar_mode_aggregate_compare (expr_p
);
8624 ret
= gimplify_variable_sized_compare (expr_p
);
8629 /* If *EXPR_P does not need to be special-cased, handle it
8630 according to its class. */
8632 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8633 post_p
, is_gimple_val
, fb_rvalue
);
8639 enum gimplify_status r0
, r1
;
8641 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8642 post_p
, is_gimple_val
, fb_rvalue
);
8643 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
8644 post_p
, is_gimple_val
, fb_rvalue
);
8652 enum gimplify_status r0
, r1
, r2
;
8654 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8655 post_p
, is_gimple_val
, fb_rvalue
);
8656 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
8657 post_p
, is_gimple_val
, fb_rvalue
);
8658 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
8659 post_p
, is_gimple_val
, fb_rvalue
);
8661 ret
= MIN (MIN (r0
, r1
), r2
);
8665 case tcc_declaration
:
8668 goto dont_recalculate
;
8674 recalculate_side_effects (*expr_p
);
8680 gcc_assert (*expr_p
|| ret
!= GS_OK
);
8682 while (ret
== GS_OK
);
8684 /* If we encountered an error_mark somewhere nested inside, either
8685 stub out the statement or propagate the error back out. */
8686 if (ret
== GS_ERROR
)
8693 /* This was only valid as a return value from the langhook, which
8694 we handled. Make sure it doesn't escape from any other context. */
8695 gcc_assert (ret
!= GS_UNHANDLED
);
8697 if (fallback
== fb_none
&& *expr_p
&& !is_gimple_stmt (*expr_p
))
8699 /* We aren't looking for a value, and we don't have a valid
8700 statement. If it doesn't have side-effects, throw it away. */
8701 if (!TREE_SIDE_EFFECTS (*expr_p
))
8703 else if (!TREE_THIS_VOLATILE (*expr_p
))
8705 /* This is probably a _REF that contains something nested that
8706 has side effects. Recurse through the operands to find it. */
8707 enum tree_code code
= TREE_CODE (*expr_p
);
8714 case VIEW_CONVERT_EXPR
:
8715 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8716 gimple_test_f
, fallback
);
8720 case ARRAY_RANGE_REF
:
8721 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8722 gimple_test_f
, fallback
);
8723 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
8724 gimple_test_f
, fallback
);
8728 /* Anything else with side-effects must be converted to
8729 a valid statement before we get here. */
8735 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p
))
8736 && TYPE_MODE (TREE_TYPE (*expr_p
)) != BLKmode
)
8738 /* Historically, the compiler has treated a bare reference
8739 to a non-BLKmode volatile lvalue as forcing a load. */
8740 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p
));
8742 /* Normally, we do not want to create a temporary for a
8743 TREE_ADDRESSABLE type because such a type should not be
8744 copied by bitwise-assignment. However, we make an
8745 exception here, as all we are doing here is ensuring that
8746 we read the bytes that make up the type. We use
8747 create_tmp_var_raw because create_tmp_var will abort when
8748 given a TREE_ADDRESSABLE type. */
8749 tree tmp
= create_tmp_var_raw (type
, "vol");
8750 gimple_add_tmp_var (tmp
);
8751 gimplify_assign (tmp
, *expr_p
, pre_p
);
8755 /* We can't do anything useful with a volatile reference to
8756 an incomplete type, so just throw it away. Likewise for
8757 a BLKmode type, since any implicit inner load should
8758 already have been turned into an explicit one by the
8759 gimplification process. */
8763 /* If we are gimplifying at the statement level, we're done. Tack
8764 everything together and return. */
8765 if (fallback
== fb_none
|| is_statement
)
8767 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
8768 it out for GC to reclaim it. */
8769 *expr_p
= NULL_TREE
;
8771 if (!gimple_seq_empty_p (internal_pre
)
8772 || !gimple_seq_empty_p (internal_post
))
8774 gimplify_seq_add_seq (&internal_pre
, internal_post
);
8775 gimplify_seq_add_seq (pre_p
, internal_pre
);
8778 /* The result of gimplifying *EXPR_P is going to be the last few
8779 statements in *PRE_P and *POST_P. Add location information
8780 to all the statements that were added by the gimplification
8782 if (!gimple_seq_empty_p (*pre_p
))
8783 annotate_all_with_location_after (*pre_p
, pre_last_gsi
, input_location
);
8785 if (!gimple_seq_empty_p (*post_p
))
8786 annotate_all_with_location_after (*post_p
, post_last_gsi
,
8792 #ifdef ENABLE_GIMPLE_CHECKING
8795 enum tree_code code
= TREE_CODE (*expr_p
);
8796 /* These expressions should already be in gimple IR form. */
8797 gcc_assert (code
!= MODIFY_EXPR
8799 && code
!= BIND_EXPR
8800 && code
!= CATCH_EXPR
8801 && (code
!= COND_EXPR
|| gimplify_ctxp
->allow_rhs_cond_expr
)
8802 && code
!= EH_FILTER_EXPR
8803 && code
!= GOTO_EXPR
8804 && code
!= LABEL_EXPR
8805 && code
!= LOOP_EXPR
8806 && code
!= SWITCH_EXPR
8807 && code
!= TRY_FINALLY_EXPR
8808 && code
!= OACC_PARALLEL
8809 && code
!= OACC_KERNELS
8810 && code
!= OACC_DATA
8811 && code
!= OACC_HOST_DATA
8812 && code
!= OACC_DECLARE
8813 && code
!= OACC_UPDATE
8814 && code
!= OACC_ENTER_DATA
8815 && code
!= OACC_EXIT_DATA
8816 && code
!= OACC_CACHE
8817 && code
!= OMP_CRITICAL
8819 && code
!= OACC_LOOP
8820 && code
!= OMP_MASTER
8821 && code
!= OMP_TASKGROUP
8822 && code
!= OMP_ORDERED
8823 && code
!= OMP_PARALLEL
8824 && code
!= OMP_SECTIONS
8825 && code
!= OMP_SECTION
8826 && code
!= OMP_SINGLE
);
8830 /* Otherwise we're gimplifying a subexpression, so the resulting
8831 value is interesting. If it's a valid operand that matches
8832 GIMPLE_TEST_F, we're done. Unless we are handling some
8833 post-effects internally; if that's the case, we need to copy into
8834 a temporary before adding the post-effects to POST_P. */
8835 if (gimple_seq_empty_p (internal_post
) && (*gimple_test_f
) (*expr_p
))
8838 /* Otherwise, we need to create a new temporary for the gimplified
8841 /* We can't return an lvalue if we have an internal postqueue. The
8842 object the lvalue refers to would (probably) be modified by the
8843 postqueue; we need to copy the value out first, which means an
8845 if ((fallback
& fb_lvalue
)
8846 && gimple_seq_empty_p (internal_post
)
8847 && is_gimple_addressable (*expr_p
))
8849 /* An lvalue will do. Take the address of the expression, store it
8850 in a temporary, and replace the expression with an INDIRECT_REF of
8852 tmp
= build_fold_addr_expr_loc (input_location
, *expr_p
);
8853 gimplify_expr (&tmp
, pre_p
, post_p
, is_gimple_reg
, fb_rvalue
);
8854 *expr_p
= build_simple_mem_ref (tmp
);
8856 else if ((fallback
& fb_rvalue
) && is_gimple_reg_rhs_or_call (*expr_p
))
8858 /* An rvalue will do. Assign the gimplified expression into a
8859 new temporary TMP and replace the original expression with
8860 TMP. First, make sure that the expression has a type so that
8861 it can be assigned into a temporary. */
8862 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p
)));
8863 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
8867 #ifdef ENABLE_GIMPLE_CHECKING
8868 if (!(fallback
& fb_mayfail
))
8870 fprintf (stderr
, "gimplification failed:\n");
8871 print_generic_expr (stderr
, *expr_p
, 0);
8872 debug_tree (*expr_p
);
8873 internal_error ("gimplification failed");
8876 gcc_assert (fallback
& fb_mayfail
);
8878 /* If this is an asm statement, and the user asked for the
8879 impossible, don't die. Fail and let gimplify_asm_expr
8885 /* Make sure the temporary matches our predicate. */
8886 gcc_assert ((*gimple_test_f
) (*expr_p
));
8888 if (!gimple_seq_empty_p (internal_post
))
8890 annotate_all_with_location (internal_post
, input_location
);
8891 gimplify_seq_add_seq (pre_p
, internal_post
);
8895 input_location
= saved_location
;
8899 /* Look through TYPE for variable-sized objects and gimplify each such
8900 size that we find. Add to LIST_P any statements generated. */
8903 gimplify_type_sizes (tree type
, gimple_seq
*list_p
)
8907 if (type
== NULL
|| type
== error_mark_node
)
8910 /* We first do the main variant, then copy into any other variants. */
8911 type
= TYPE_MAIN_VARIANT (type
);
8913 /* Avoid infinite recursion. */
8914 if (TYPE_SIZES_GIMPLIFIED (type
))
8917 TYPE_SIZES_GIMPLIFIED (type
) = 1;
8919 switch (TREE_CODE (type
))
8925 case FIXED_POINT_TYPE
:
8926 gimplify_one_sizepos (&TYPE_MIN_VALUE (type
), list_p
);
8927 gimplify_one_sizepos (&TYPE_MAX_VALUE (type
), list_p
);
8929 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8931 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (type
);
8932 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (type
);
8937 /* These types may not have declarations, so handle them here. */
8938 gimplify_type_sizes (TREE_TYPE (type
), list_p
);
8939 gimplify_type_sizes (TYPE_DOMAIN (type
), list_p
);
8940 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
8941 with assigned stack slots, for -O1+ -g they should be tracked
8943 if (!(TYPE_NAME (type
)
8944 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
8945 && DECL_IGNORED_P (TYPE_NAME (type
)))
8946 && TYPE_DOMAIN (type
)
8947 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type
)))
8949 t
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
8950 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8951 DECL_IGNORED_P (t
) = 0;
8952 t
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
8953 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8954 DECL_IGNORED_P (t
) = 0;
8960 case QUAL_UNION_TYPE
:
8961 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
8962 if (TREE_CODE (field
) == FIELD_DECL
)
8964 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field
), list_p
);
8965 gimplify_one_sizepos (&DECL_SIZE (field
), list_p
);
8966 gimplify_one_sizepos (&DECL_SIZE_UNIT (field
), list_p
);
8967 gimplify_type_sizes (TREE_TYPE (field
), list_p
);
8972 case REFERENCE_TYPE
:
8973 /* We used to recurse on the pointed-to type here, which turned out to
8974 be incorrect because its definition might refer to variables not
8975 yet initialized at this point if a forward declaration is involved.
8977 It was actually useful for anonymous pointed-to types to ensure
8978 that the sizes evaluation dominates every possible later use of the
8979 values. Restricting to such types here would be safe since there
8980 is no possible forward declaration around, but would introduce an
8981 undesirable middle-end semantic to anonymity. We then defer to
8982 front-ends the responsibility of ensuring that the sizes are
8983 evaluated both early and late enough, e.g. by attaching artificial
8984 type declarations to the tree. */
8991 gimplify_one_sizepos (&TYPE_SIZE (type
), list_p
);
8992 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type
), list_p
);
8994 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8996 TYPE_SIZE (t
) = TYPE_SIZE (type
);
8997 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (type
);
8998 TYPE_SIZES_GIMPLIFIED (t
) = 1;
9002 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
9003 a size or position, has had all of its SAVE_EXPRs evaluated.
9004 We add any required statements to *STMT_P. */
9007 gimplify_one_sizepos (tree
*expr_p
, gimple_seq
*stmt_p
)
9009 tree expr
= *expr_p
;
9011 /* We don't do anything if the value isn't there, is constant, or contains
9012 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
9013 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
9014 will want to replace it with a new variable, but that will cause problems
9015 if this type is from outside the function. It's OK to have that here. */
9016 if (is_gimple_sizepos (expr
))
9019 *expr_p
= unshare_expr (expr
);
9021 gimplify_expr (expr_p
, stmt_p
, NULL
, is_gimple_val
, fb_rvalue
);
9024 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
9025 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
9026 is true, also gimplify the parameters. */
9029 gimplify_body (tree fndecl
, bool do_parms
)
9031 location_t saved_location
= input_location
;
9032 gimple_seq parm_stmts
, seq
;
9035 struct cgraph_node
*cgn
;
9037 timevar_push (TV_TREE_GIMPLIFY
);
9039 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
9041 default_rtl_profile ();
9043 gcc_assert (gimplify_ctxp
== NULL
);
9044 push_gimplify_context ();
9046 if (flag_openacc
|| flag_openmp
)
9048 gcc_assert (gimplify_omp_ctxp
== NULL
);
9049 if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (fndecl
)))
9050 gimplify_omp_ctxp
= new_omp_context (ORT_TARGET
);
9053 /* Unshare most shared trees in the body and in that of any nested functions.
9054 It would seem we don't have to do this for nested functions because
9055 they are supposed to be output and then the outer function gimplified
9056 first, but the g++ front end doesn't always do it that way. */
9057 unshare_body (fndecl
);
9058 unvisit_body (fndecl
);
9060 cgn
= cgraph_node::get (fndecl
);
9061 if (cgn
&& cgn
->origin
)
9062 nonlocal_vlas
= new hash_set
<tree
>;
9064 /* Make sure input_location isn't set to something weird. */
9065 input_location
= DECL_SOURCE_LOCATION (fndecl
);
9067 /* Resolve callee-copies. This has to be done before processing
9068 the body so that DECL_VALUE_EXPR gets processed correctly. */
9069 parm_stmts
= do_parms
? gimplify_parameters () : NULL
;
9071 /* Gimplify the function's body. */
9073 gimplify_stmt (&DECL_SAVED_TREE (fndecl
), &seq
);
9074 outer_stmt
= gimple_seq_first_stmt (seq
);
9077 outer_stmt
= gimple_build_nop ();
9078 gimplify_seq_add_stmt (&seq
, outer_stmt
);
9081 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
9082 not the case, wrap everything in a GIMPLE_BIND to make it so. */
9083 if (gimple_code (outer_stmt
) == GIMPLE_BIND
9084 && gimple_seq_first (seq
) == gimple_seq_last (seq
))
9085 outer_bind
= as_a
<gbind
*> (outer_stmt
);
9087 outer_bind
= gimple_build_bind (NULL_TREE
, seq
, NULL
);
9089 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
9091 /* If we had callee-copies statements, insert them at the beginning
9092 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
9093 if (!gimple_seq_empty_p (parm_stmts
))
9097 gimplify_seq_add_seq (&parm_stmts
, gimple_bind_body (outer_bind
));
9098 gimple_bind_set_body (outer_bind
, parm_stmts
);
9100 for (parm
= DECL_ARGUMENTS (current_function_decl
);
9101 parm
; parm
= DECL_CHAIN (parm
))
9102 if (DECL_HAS_VALUE_EXPR_P (parm
))
9104 DECL_HAS_VALUE_EXPR_P (parm
) = 0;
9105 DECL_IGNORED_P (parm
) = 0;
9111 if (nonlocal_vla_vars
)
9113 /* tree-nested.c may later on call declare_vars (..., true);
9114 which relies on BLOCK_VARS chain to be the tail of the
9115 gimple_bind_vars chain. Ensure we don't violate that
9117 if (gimple_bind_block (outer_bind
)
9118 == DECL_INITIAL (current_function_decl
))
9119 declare_vars (nonlocal_vla_vars
, outer_bind
, true);
9121 BLOCK_VARS (DECL_INITIAL (current_function_decl
))
9122 = chainon (BLOCK_VARS (DECL_INITIAL (current_function_decl
)),
9124 nonlocal_vla_vars
= NULL_TREE
;
9126 delete nonlocal_vlas
;
9127 nonlocal_vlas
= NULL
;
9130 if ((flag_openacc
|| flag_openmp
|| flag_openmp_simd
)
9131 && gimplify_omp_ctxp
)
9133 delete_omp_context (gimplify_omp_ctxp
);
9134 gimplify_omp_ctxp
= NULL
;
9137 pop_gimplify_context (outer_bind
);
9138 gcc_assert (gimplify_ctxp
== NULL
);
9140 #ifdef ENABLE_CHECKING
9142 verify_gimple_in_seq (gimple_bind_body (outer_bind
));
9145 timevar_pop (TV_TREE_GIMPLIFY
);
9146 input_location
= saved_location
;
9151 typedef char *char_p
; /* For DEF_VEC_P. */
9153 /* Return whether we should exclude FNDECL from instrumentation. */
9156 flag_instrument_functions_exclude_p (tree fndecl
)
9160 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_functions
;
9161 if (v
&& v
->length () > 0)
9167 name
= lang_hooks
.decl_printable_name (fndecl
, 0);
9168 FOR_EACH_VEC_ELT (*v
, i
, s
)
9169 if (strstr (name
, s
) != NULL
)
9173 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_files
;
9174 if (v
&& v
->length () > 0)
9180 name
= DECL_SOURCE_FILE (fndecl
);
9181 FOR_EACH_VEC_ELT (*v
, i
, s
)
9182 if (strstr (name
, s
) != NULL
)
9189 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
9190 node for the function we want to gimplify.
9192 Return the sequence of GIMPLE statements corresponding to the body
9196 gimplify_function_tree (tree fndecl
)
9202 gcc_assert (!gimple_body (fndecl
));
9204 if (DECL_STRUCT_FUNCTION (fndecl
))
9205 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
9207 push_struct_function (fndecl
);
9209 /* Tentatively set PROP_gimple_lva here, and reset it in gimplify_va_arg_expr
9211 cfun
->curr_properties
|= PROP_gimple_lva
;
9213 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
9215 /* Preliminarily mark non-addressed complex variables as eligible
9216 for promotion to gimple registers. We'll transform their uses
9218 if ((TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
9219 || TREE_CODE (TREE_TYPE (parm
)) == VECTOR_TYPE
)
9220 && !TREE_THIS_VOLATILE (parm
)
9221 && !needs_to_live_in_memory (parm
))
9222 DECL_GIMPLE_REG_P (parm
) = 1;
9225 ret
= DECL_RESULT (fndecl
);
9226 if ((TREE_CODE (TREE_TYPE (ret
)) == COMPLEX_TYPE
9227 || TREE_CODE (TREE_TYPE (ret
)) == VECTOR_TYPE
)
9228 && !needs_to_live_in_memory (ret
))
9229 DECL_GIMPLE_REG_P (ret
) = 1;
9231 bind
= gimplify_body (fndecl
, true);
9233 /* The tree body of the function is no longer needed, replace it
9234 with the new GIMPLE body. */
9236 gimple_seq_add_stmt (&seq
, bind
);
9237 gimple_set_body (fndecl
, seq
);
9239 /* If we're instrumenting function entry/exit, then prepend the call to
9240 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
9241 catch the exit hook. */
9242 /* ??? Add some way to ignore exceptions for this TFE. */
9243 if (flag_instrument_function_entry_exit
9244 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
)
9245 && !flag_instrument_functions_exclude_p (fndecl
))
9250 gimple_seq cleanup
= NULL
, body
= NULL
;
9254 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
9255 call
= gimple_build_call (x
, 1, integer_zero_node
);
9256 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
9257 gimple_call_set_lhs (call
, tmp_var
);
9258 gimplify_seq_add_stmt (&cleanup
, call
);
9259 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT
);
9260 call
= gimple_build_call (x
, 2,
9261 build_fold_addr_expr (current_function_decl
),
9263 gimplify_seq_add_stmt (&cleanup
, call
);
9264 tf
= gimple_build_try (seq
, cleanup
, GIMPLE_TRY_FINALLY
);
9266 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
9267 call
= gimple_build_call (x
, 1, integer_zero_node
);
9268 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
9269 gimple_call_set_lhs (call
, tmp_var
);
9270 gimplify_seq_add_stmt (&body
, call
);
9271 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER
);
9272 call
= gimple_build_call (x
, 2,
9273 build_fold_addr_expr (current_function_decl
),
9275 gimplify_seq_add_stmt (&body
, call
);
9276 gimplify_seq_add_stmt (&body
, tf
);
9277 new_bind
= gimple_build_bind (NULL
, body
, gimple_bind_block (bind
));
9278 /* Clear the block for BIND, since it is no longer directly inside
9279 the function, but within a try block. */
9280 gimple_bind_set_block (bind
, NULL
);
9282 /* Replace the current function body with the body
9283 wrapped in the try/finally TF. */
9285 gimple_seq_add_stmt (&seq
, new_bind
);
9286 gimple_set_body (fndecl
, seq
);
9290 if ((flag_sanitize
& SANITIZE_THREAD
) != 0
9291 && !lookup_attribute ("no_sanitize_thread", DECL_ATTRIBUTES (fndecl
)))
9293 gcall
*call
= gimple_build_call_internal (IFN_TSAN_FUNC_EXIT
, 0);
9294 gimple tf
= gimple_build_try (seq
, call
, GIMPLE_TRY_FINALLY
);
9295 gbind
*new_bind
= gimple_build_bind (NULL
, tf
, gimple_bind_block (bind
));
9296 /* Clear the block for BIND, since it is no longer directly inside
9297 the function, but within a try block. */
9298 gimple_bind_set_block (bind
, NULL
);
9299 /* Replace the current function body with the body
9300 wrapped in the try/finally TF. */
9302 gimple_seq_add_stmt (&seq
, new_bind
);
9303 gimple_set_body (fndecl
, seq
);
9306 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
9307 cfun
->curr_properties
|= PROP_gimple_any
;
9312 /* Return a dummy expression of type TYPE in order to keep going after an
9316 dummy_object (tree type
)
9318 tree t
= build_int_cst (build_pointer_type (type
), 0);
9319 return build2 (MEM_REF
, type
, t
, t
);
9322 /* Call the target expander for evaluating a va_arg call of VALIST
9326 gimplify_va_arg_internal (tree valist
, tree type
, location_t loc
,
9327 gimple_seq
*pre_p
, gimple_seq
*post_p
)
9329 tree have_va_type
= TREE_TYPE (valist
);
9330 tree cano_type
= targetm
.canonical_va_list_type (have_va_type
);
9332 if (cano_type
!= NULL_TREE
)
9333 have_va_type
= cano_type
;
9335 /* Make it easier for the backends by protecting the valist argument
9336 from multiple evaluations. */
9337 if (TREE_CODE (have_va_type
) == ARRAY_TYPE
)
9339 /* For this case, the backends will be expecting a pointer to
9340 TREE_TYPE (abi), but it's possible we've
9341 actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
9343 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
9345 tree p1
= build_pointer_type (TREE_TYPE (have_va_type
));
9346 valist
= fold_convert_loc (loc
, p1
,
9347 build_fold_addr_expr_loc (loc
, valist
));
9350 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
9353 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_min_lval
, fb_lvalue
);
9355 return targetm
.gimplify_va_arg_expr (valist
, type
, pre_p
, post_p
);
9358 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
9359 builtin function, but a very special sort of operator. */
9361 enum gimplify_status
9362 gimplify_va_arg_expr (tree
*expr_p
, gimple_seq
*pre_p
,
9363 gimple_seq
*post_p ATTRIBUTE_UNUSED
)
9365 tree promoted_type
, have_va_type
;
9366 tree valist
= TREE_OPERAND (*expr_p
, 0);
9367 tree type
= TREE_TYPE (*expr_p
);
9369 location_t loc
= EXPR_LOCATION (*expr_p
);
9371 /* Verify that valist is of the proper type. */
9372 have_va_type
= TREE_TYPE (valist
);
9373 if (have_va_type
== error_mark_node
)
9375 have_va_type
= targetm
.canonical_va_list_type (have_va_type
);
9377 if (have_va_type
== NULL_TREE
)
9379 error_at (loc
, "first argument to %<va_arg%> not of type %<va_list%>");
9383 /* Generate a diagnostic for requesting data of a type that cannot
9384 be passed through `...' due to type promotion at the call site. */
9385 if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
9388 static bool gave_help
;
9391 /* Unfortunately, this is merely undefined, rather than a constraint
9392 violation, so we cannot make this an error. If this call is never
9393 executed, the program is still strictly conforming. */
9394 warned
= warning_at (loc
, 0,
9395 "%qT is promoted to %qT when passed through %<...%>",
9396 type
, promoted_type
);
9397 if (!gave_help
&& warned
)
9400 inform (loc
, "(so you should pass %qT not %qT to %<va_arg%>)",
9401 promoted_type
, type
);
9404 /* We can, however, treat "undefined" any way we please.
9405 Call abort to encourage the user to fix the program. */
9407 inform (loc
, "if this code is reached, the program will abort");
9408 /* Before the abort, allow the evaluation of the va_list
9409 expression to exit or longjmp. */
9410 gimplify_and_add (valist
, pre_p
);
9411 t
= build_call_expr_loc (loc
,
9412 builtin_decl_implicit (BUILT_IN_TRAP
), 0);
9413 gimplify_and_add (t
, pre_p
);
9415 /* This is dead code, but go ahead and finish so that the
9416 mode of the result comes out right. */
9417 *expr_p
= dummy_object (type
);
9421 /* Transform a VA_ARG_EXPR into an VA_ARG internal function. */
9422 ap
= build_fold_addr_expr_loc (loc
, valist
);
9423 tag
= build_int_cst (build_pointer_type (type
), 0);
9424 *expr_p
= build_call_expr_internal_loc (loc
, IFN_VA_ARG
, type
, 2, ap
, tag
);
9426 /* Clear the tentatively set PROP_gimple_lva, to indicate that IFN_VA_ARG
9427 needs to be expanded. */
9428 cfun
->curr_properties
&= ~PROP_gimple_lva
;
9433 /* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
9435 DST/SRC are the destination and source respectively. You can pass
9436 ungimplified trees in DST or SRC, in which case they will be
9437 converted to a gimple operand if necessary.
9439 This function returns the newly created GIMPLE_ASSIGN tuple. */
9442 gimplify_assign (tree dst
, tree src
, gimple_seq
*seq_p
)
9444 tree t
= build2 (MODIFY_EXPR
, TREE_TYPE (dst
), dst
, src
);
9445 gimplify_and_add (t
, seq_p
);
9447 return gimple_seq_last_stmt (*seq_p
);
9451 gimplify_hasher::hash (const value_type
*p
)
9454 return iterative_hash_expr (t
, 0);
9458 gimplify_hasher::equal (const value_type
*p1
, const compare_type
*p2
)
9462 enum tree_code code
= TREE_CODE (t1
);
9464 if (TREE_CODE (t2
) != code
9465 || TREE_TYPE (t1
) != TREE_TYPE (t2
))
9468 if (!operand_equal_p (t1
, t2
, 0))
9471 #ifdef ENABLE_CHECKING
9472 /* Only allow them to compare equal if they also hash equal; otherwise
9473 results are nondeterminate, and we fail bootstrap comparison. */
9474 gcc_assert (hash (p1
) == hash (p2
));