1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002-2014 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 "hash-table.h"
35 #include "hard-reg-set.h"
38 #include "basic-block.h"
39 #include "tree-ssa-alias.h"
40 #include "internal-fn.h"
41 #include "gimple-fold.h"
43 #include "gimple-expr.h"
47 #include "gimple-iterator.h"
48 #include "stringpool.h"
51 #include "stor-layout.h"
53 #include "print-tree.h"
54 #include "tree-iterator.h"
55 #include "tree-inline.h"
56 #include "tree-pretty-print.h"
57 #include "langhooks.h"
59 #include "gimple-ssa.h"
61 #include "plugin-api.h"
65 #include "tree-ssanames.h"
67 #include "diagnostic-core.h"
69 #include "splay-tree.h"
71 #include "gimple-low.h"
74 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
75 #include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
78 enum gimplify_omp_var_data
84 GOVD_FIRSTPRIVATE
= 16,
85 GOVD_LASTPRIVATE
= 32,
89 GOVD_DEBUG_PRIVATE
= 512,
90 GOVD_PRIVATE_OUTER_REF
= 1024,
93 GOVD_MAP_TO_ONLY
= 8192,
94 GOVD_DATA_SHARE_CLASS
= (GOVD_SHARED
| GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
95 | GOVD_LASTPRIVATE
| GOVD_REDUCTION
| GOVD_LINEAR
105 ORT_COMBINED_PARALLEL
= 3,
109 ORT_TARGET_DATA
= 16,
113 /* Gimplify hashtable helper. */
115 struct gimplify_hasher
: typed_free_remove
<elt_t
>
117 typedef elt_t value_type
;
118 typedef elt_t compare_type
;
119 static inline hashval_t
hash (const value_type
*);
120 static inline bool equal (const value_type
*, const compare_type
*);
125 struct gimplify_ctx
*prev_context
;
127 vec
<gimple
> bind_expr_stack
;
129 gimple_seq conditional_cleanups
;
133 vec
<tree
> case_labels
;
134 /* The formal temporary table. Should this be persistent? */
135 hash_table
<gimplify_hasher
> *temp_htab
;
140 bool allow_rhs_cond_expr
;
141 bool in_cleanup_point_expr
;
144 struct gimplify_omp_ctx
146 struct gimplify_omp_ctx
*outer_context
;
147 splay_tree variables
;
148 hash_set
<tree
> *privatized_types
;
150 enum omp_clause_default_kind default_kind
;
151 enum omp_region_type region_type
;
156 static struct gimplify_ctx
*gimplify_ctxp
;
157 static struct gimplify_omp_ctx
*gimplify_omp_ctxp
;
159 /* Forward declaration. */
160 static enum gimplify_status
gimplify_compound_expr (tree
*, gimple_seq
*, bool);
162 /* Shorter alias name for the above function for use in gimplify.c
166 gimplify_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
168 gimple_seq_add_stmt_without_update (seq_p
, gs
);
171 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
172 NULL, a new sequence is allocated. This function is
173 similar to gimple_seq_add_seq, but does not scan the operands.
174 During gimplification, we need to manipulate statement sequences
175 before the def/use vectors have been constructed. */
178 gimplify_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
180 gimple_stmt_iterator si
;
185 si
= gsi_last (*dst_p
);
186 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
190 /* Pointer to a list of allocated gimplify_ctx structs to be used for pushing
191 and popping gimplify contexts. */
193 static struct gimplify_ctx
*ctx_pool
= NULL
;
195 /* Return a gimplify context struct from the pool. */
197 static inline struct gimplify_ctx
*
200 struct gimplify_ctx
* c
= ctx_pool
;
203 ctx_pool
= c
->prev_context
;
205 c
= XNEW (struct gimplify_ctx
);
207 memset (c
, '\0', sizeof (*c
));
211 /* Put gimplify context C back into the pool. */
214 ctx_free (struct gimplify_ctx
*c
)
216 c
->prev_context
= ctx_pool
;
220 /* Free allocated ctx stack memory. */
223 free_gimplify_stack (void)
225 struct gimplify_ctx
*c
;
227 while ((c
= ctx_pool
))
229 ctx_pool
= c
->prev_context
;
235 /* Set up a context for the gimplifier. */
238 push_gimplify_context (bool in_ssa
, bool rhs_cond_ok
)
240 struct gimplify_ctx
*c
= ctx_alloc ();
242 c
->prev_context
= gimplify_ctxp
;
244 gimplify_ctxp
->into_ssa
= in_ssa
;
245 gimplify_ctxp
->allow_rhs_cond_expr
= rhs_cond_ok
;
248 /* Tear down a context for the gimplifier. If BODY is non-null, then
249 put the temporaries into the outer BIND_EXPR. Otherwise, put them
252 BODY is not a sequence, but the first tuple in a sequence. */
255 pop_gimplify_context (gimple body
)
257 struct gimplify_ctx
*c
= gimplify_ctxp
;
260 && (!c
->bind_expr_stack
.exists ()
261 || c
->bind_expr_stack
.is_empty ()));
262 c
->bind_expr_stack
.release ();
263 gimplify_ctxp
= c
->prev_context
;
266 declare_vars (c
->temps
, body
, false);
268 record_vars (c
->temps
);
275 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
278 gimple_push_bind_expr (gimple gimple_bind
)
280 gimplify_ctxp
->bind_expr_stack
.reserve (8);
281 gimplify_ctxp
->bind_expr_stack
.safe_push (gimple_bind
);
284 /* Pop the first element off the stack of bindings. */
287 gimple_pop_bind_expr (void)
289 gimplify_ctxp
->bind_expr_stack
.pop ();
292 /* Return the first element of the stack of bindings. */
295 gimple_current_bind_expr (void)
297 return gimplify_ctxp
->bind_expr_stack
.last ();
300 /* Return the stack of bindings created during gimplification. */
303 gimple_bind_expr_stack (void)
305 return gimplify_ctxp
->bind_expr_stack
;
308 /* Return true iff there is a COND_EXPR between us and the innermost
309 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
312 gimple_conditional_context (void)
314 return gimplify_ctxp
->conditions
> 0;
317 /* Note that we've entered a COND_EXPR. */
320 gimple_push_condition (void)
322 #ifdef ENABLE_GIMPLE_CHECKING
323 if (gimplify_ctxp
->conditions
== 0)
324 gcc_assert (gimple_seq_empty_p (gimplify_ctxp
->conditional_cleanups
));
326 ++(gimplify_ctxp
->conditions
);
329 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
330 now, add any conditional cleanups we've seen to the prequeue. */
333 gimple_pop_condition (gimple_seq
*pre_p
)
335 int conds
= --(gimplify_ctxp
->conditions
);
337 gcc_assert (conds
>= 0);
340 gimplify_seq_add_seq (pre_p
, gimplify_ctxp
->conditional_cleanups
);
341 gimplify_ctxp
->conditional_cleanups
= NULL
;
345 /* A stable comparison routine for use with splay trees and DECLs. */
348 splay_tree_compare_decl_uid (splay_tree_key xa
, splay_tree_key xb
)
353 return DECL_UID (a
) - DECL_UID (b
);
356 /* Create a new omp construct that deals with variable remapping. */
358 static struct gimplify_omp_ctx
*
359 new_omp_context (enum omp_region_type region_type
)
361 struct gimplify_omp_ctx
*c
;
363 c
= XCNEW (struct gimplify_omp_ctx
);
364 c
->outer_context
= gimplify_omp_ctxp
;
365 c
->variables
= splay_tree_new (splay_tree_compare_decl_uid
, 0, 0);
366 c
->privatized_types
= new hash_set
<tree
>;
367 c
->location
= input_location
;
368 c
->region_type
= region_type
;
369 if ((region_type
& ORT_TASK
) == 0)
370 c
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
372 c
->default_kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
377 /* Destroy an omp construct that deals with variable remapping. */
380 delete_omp_context (struct gimplify_omp_ctx
*c
)
382 splay_tree_delete (c
->variables
);
383 delete c
->privatized_types
;
387 static void omp_add_variable (struct gimplify_omp_ctx
*, tree
, unsigned int);
388 static bool omp_notice_variable (struct gimplify_omp_ctx
*, tree
, bool);
390 /* Both gimplify the statement T and append it to *SEQ_P. This function
391 behaves exactly as gimplify_stmt, but you don't have to pass T as a
395 gimplify_and_add (tree t
, gimple_seq
*seq_p
)
397 gimplify_stmt (&t
, seq_p
);
400 /* Gimplify statement T into sequence *SEQ_P, and return the first
401 tuple in the sequence of generated tuples for this statement.
402 Return NULL if gimplifying T produced no tuples. */
405 gimplify_and_return_first (tree t
, gimple_seq
*seq_p
)
407 gimple_stmt_iterator last
= gsi_last (*seq_p
);
409 gimplify_and_add (t
, seq_p
);
411 if (!gsi_end_p (last
))
414 return gsi_stmt (last
);
417 return gimple_seq_first_stmt (*seq_p
);
420 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
421 LHS, or for a call argument. */
424 is_gimple_mem_rhs (tree t
)
426 /* If we're dealing with a renamable type, either source or dest must be
427 a renamed variable. */
428 if (is_gimple_reg_type (TREE_TYPE (t
)))
429 return is_gimple_val (t
);
431 return is_gimple_val (t
) || is_gimple_lvalue (t
);
434 /* Return true if T is a CALL_EXPR or an expression that can be
435 assigned to a temporary. Note that this predicate should only be
436 used during gimplification. See the rationale for this in
437 gimplify_modify_expr. */
440 is_gimple_reg_rhs_or_call (tree t
)
442 return (get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
443 || TREE_CODE (t
) == CALL_EXPR
);
446 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
447 this predicate should only be used during gimplification. See the
448 rationale for this in gimplify_modify_expr. */
451 is_gimple_mem_rhs_or_call (tree t
)
453 /* If we're dealing with a renamable type, either source or dest must be
454 a renamed variable. */
455 if (is_gimple_reg_type (TREE_TYPE (t
)))
456 return is_gimple_val (t
);
458 return (is_gimple_val (t
) || is_gimple_lvalue (t
)
459 || TREE_CODE (t
) == CALL_EXPR
);
462 /* Create a temporary with a name derived from VAL. Subroutine of
463 lookup_tmp_var; nobody else should call this function. */
466 create_tmp_from_val (tree val
)
468 /* Drop all qualifiers and address-space information from the value type. */
469 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (val
));
470 tree var
= create_tmp_var (type
, get_name (val
));
471 if (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
472 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
473 DECL_GIMPLE_REG_P (var
) = 1;
477 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
478 an existing expression temporary. */
481 lookup_tmp_var (tree val
, bool is_formal
)
485 /* If not optimizing, never really reuse a temporary. local-alloc
486 won't allocate any variable that is used in more than one basic
487 block, which means it will go into memory, causing much extra
488 work in reload and final and poorer code generation, outweighing
489 the extra memory allocation here. */
490 if (!optimize
|| !is_formal
|| TREE_SIDE_EFFECTS (val
))
491 ret
= create_tmp_from_val (val
);
498 if (!gimplify_ctxp
->temp_htab
)
499 gimplify_ctxp
->temp_htab
= new hash_table
<gimplify_hasher
> (1000);
500 slot
= gimplify_ctxp
->temp_htab
->find_slot (&elt
, INSERT
);
503 elt_p
= XNEW (elt_t
);
505 elt_p
->temp
= ret
= create_tmp_from_val (val
);
518 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
521 internal_get_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
526 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
527 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
528 gimplify_expr (&val
, pre_p
, post_p
, is_gimple_reg_rhs_or_call
,
531 if (gimplify_ctxp
->into_ssa
532 && is_gimple_reg_type (TREE_TYPE (val
)))
533 t
= make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val
)), NULL
);
535 t
= lookup_tmp_var (val
, is_formal
);
537 mod
= build2 (INIT_EXPR
, TREE_TYPE (t
), t
, unshare_expr (val
));
539 SET_EXPR_LOCATION (mod
, EXPR_LOC_OR_LOC (val
, input_location
));
541 /* gimplify_modify_expr might want to reduce this further. */
542 gimplify_and_add (mod
, pre_p
);
548 /* Return a formal temporary variable initialized with VAL. PRE_P is as
549 in gimplify_expr. Only use this function if:
551 1) The value of the unfactored expression represented by VAL will not
552 change between the initialization and use of the temporary, and
553 2) The temporary will not be otherwise modified.
555 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
556 and #2 means it is inappropriate for && temps.
558 For other cases, use get_initialized_tmp_var instead. */
561 get_formal_tmp_var (tree val
, gimple_seq
*pre_p
)
563 return internal_get_tmp_var (val
, pre_p
, NULL
, true);
566 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
567 are as in gimplify_expr. */
570 get_initialized_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
572 return internal_get_tmp_var (val
, pre_p
, post_p
, false);
575 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
576 generate debug info for them; otherwise don't. */
579 declare_vars (tree vars
, gimple scope
, bool debug_info
)
586 gcc_assert (gimple_code (scope
) == GIMPLE_BIND
);
588 temps
= nreverse (last
);
590 block
= gimple_bind_block (scope
);
591 gcc_assert (!block
|| TREE_CODE (block
) == BLOCK
);
592 if (!block
|| !debug_info
)
594 DECL_CHAIN (last
) = gimple_bind_vars (scope
);
595 gimple_bind_set_vars (scope
, temps
);
599 /* We need to attach the nodes both to the BIND_EXPR and to its
600 associated BLOCK for debugging purposes. The key point here
601 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
602 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
603 if (BLOCK_VARS (block
))
604 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), temps
);
607 gimple_bind_set_vars (scope
,
608 chainon (gimple_bind_vars (scope
), temps
));
609 BLOCK_VARS (block
) = temps
;
615 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
616 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
617 no such upper bound can be obtained. */
620 force_constant_size (tree var
)
622 /* The only attempt we make is by querying the maximum size of objects
623 of the variable's type. */
625 HOST_WIDE_INT max_size
;
627 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
629 max_size
= max_int_size_in_bytes (TREE_TYPE (var
));
631 gcc_assert (max_size
>= 0);
634 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var
)), max_size
);
636 = build_int_cst (TREE_TYPE (DECL_SIZE (var
)), max_size
* BITS_PER_UNIT
);
639 /* Push the temporary variable TMP into the current binding. */
642 gimple_add_tmp_var_fn (struct function
*fn
, tree tmp
)
644 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
646 /* Later processing assumes that the object size is constant, which might
647 not be true at this point. Force the use of a constant upper bound in
649 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (tmp
)))
650 force_constant_size (tmp
);
652 DECL_CONTEXT (tmp
) = fn
->decl
;
653 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
655 record_vars_into (tmp
, fn
->decl
);
658 /* Push the temporary variable TMP into the current binding. */
661 gimple_add_tmp_var (tree tmp
)
663 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
665 /* Later processing assumes that the object size is constant, which might
666 not be true at this point. Force the use of a constant upper bound in
668 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (tmp
)))
669 force_constant_size (tmp
);
671 DECL_CONTEXT (tmp
) = current_function_decl
;
672 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
676 DECL_CHAIN (tmp
) = gimplify_ctxp
->temps
;
677 gimplify_ctxp
->temps
= tmp
;
679 /* Mark temporaries local within the nearest enclosing parallel. */
680 if (gimplify_omp_ctxp
)
682 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
684 && (ctx
->region_type
== ORT_WORKSHARE
685 || ctx
->region_type
== ORT_SIMD
))
686 ctx
= ctx
->outer_context
;
688 omp_add_variable (ctx
, tmp
, GOVD_LOCAL
| GOVD_SEEN
);
697 /* This case is for nested functions. We need to expose the locals
699 body_seq
= gimple_body (current_function_decl
);
700 declare_vars (tmp
, gimple_seq_first_stmt (body_seq
), false);
706 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
707 nodes that are referenced more than once in GENERIC functions. This is
708 necessary because gimplification (translation into GIMPLE) is performed
709 by modifying tree nodes in-place, so gimplication of a shared node in a
710 first context could generate an invalid GIMPLE form in a second context.
712 This is achieved with a simple mark/copy/unmark algorithm that walks the
713 GENERIC representation top-down, marks nodes with TREE_VISITED the first
714 time it encounters them, duplicates them if they already have TREE_VISITED
715 set, and finally removes the TREE_VISITED marks it has set.
717 The algorithm works only at the function level, i.e. it generates a GENERIC
718 representation of a function with no nodes shared within the function when
719 passed a GENERIC function (except for nodes that are allowed to be shared).
721 At the global level, it is also necessary to unshare tree nodes that are
722 referenced in more than one function, for the same aforementioned reason.
723 This requires some cooperation from the front-end. There are 2 strategies:
725 1. Manual unsharing. The front-end needs to call unshare_expr on every
726 expression that might end up being shared across functions.
728 2. Deep unsharing. This is an extension of regular unsharing. Instead
729 of calling unshare_expr on expressions that might be shared across
730 functions, the front-end pre-marks them with TREE_VISITED. This will
731 ensure that they are unshared on the first reference within functions
732 when the regular unsharing algorithm runs. The counterpart is that
733 this algorithm must look deeper than for manual unsharing, which is
734 specified by LANG_HOOKS_DEEP_UNSHARING.
736 If there are only few specific cases of node sharing across functions, it is
737 probably easier for a front-end to unshare the expressions manually. On the
738 contrary, if the expressions generated at the global level are as widespread
739 as expressions generated within functions, deep unsharing is very likely the
742 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
743 These nodes model computations that must be done once. If we were to
744 unshare something like SAVE_EXPR(i++), the gimplification process would
745 create wrong code. However, if DATA is non-null, it must hold a pointer
746 set that is used to unshare the subtrees of these nodes. */
749 mostly_copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
752 enum tree_code code
= TREE_CODE (t
);
754 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
755 copy their subtrees if we can make sure to do it only once. */
756 if (code
== SAVE_EXPR
|| code
== TARGET_EXPR
|| code
== BIND_EXPR
)
758 if (data
&& !((hash_set
<tree
> *)data
)->add (t
))
764 /* Stop at types, decls, constants like copy_tree_r. */
765 else if (TREE_CODE_CLASS (code
) == tcc_type
766 || TREE_CODE_CLASS (code
) == tcc_declaration
767 || TREE_CODE_CLASS (code
) == tcc_constant
768 /* We can't do anything sensible with a BLOCK used as an
769 expression, but we also can't just die when we see it
770 because of non-expression uses. So we avert our eyes
771 and cross our fingers. Silly Java. */
775 /* Cope with the statement expression extension. */
776 else if (code
== STATEMENT_LIST
)
779 /* Leave the bulk of the work to copy_tree_r itself. */
781 copy_tree_r (tp
, walk_subtrees
, NULL
);
786 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
787 If *TP has been visited already, then *TP is deeply copied by calling
788 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
791 copy_if_shared_r (tree
*tp
, int *walk_subtrees
, void *data
)
794 enum tree_code code
= TREE_CODE (t
);
796 /* Skip types, decls, and constants. But we do want to look at their
797 types and the bounds of types. Mark them as visited so we properly
798 unmark their subtrees on the unmark pass. If we've already seen them,
799 don't look down further. */
800 if (TREE_CODE_CLASS (code
) == tcc_type
801 || TREE_CODE_CLASS (code
) == tcc_declaration
802 || TREE_CODE_CLASS (code
) == tcc_constant
)
804 if (TREE_VISITED (t
))
807 TREE_VISITED (t
) = 1;
810 /* If this node has been visited already, unshare it and don't look
812 else if (TREE_VISITED (t
))
814 walk_tree (tp
, mostly_copy_tree_r
, data
, NULL
);
818 /* Otherwise, mark the node as visited and keep looking. */
820 TREE_VISITED (t
) = 1;
825 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
826 copy_if_shared_r callback unmodified. */
829 copy_if_shared (tree
*tp
, void *data
)
831 walk_tree (tp
, copy_if_shared_r
, data
, NULL
);
834 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
835 any nested functions. */
838 unshare_body (tree fndecl
)
840 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
841 /* If the language requires deep unsharing, we need a pointer set to make
842 sure we don't repeatedly unshare subtrees of unshareable nodes. */
843 hash_set
<tree
> *visited
844 = lang_hooks
.deep_unsharing
? new hash_set
<tree
> : NULL
;
846 copy_if_shared (&DECL_SAVED_TREE (fndecl
), visited
);
847 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl
)), visited
);
848 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)), visited
);
853 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
854 unshare_body (cgn
->decl
);
857 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
858 Subtrees are walked until the first unvisited node is encountered. */
861 unmark_visited_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
865 /* If this node has been visited, unmark it and keep looking. */
866 if (TREE_VISITED (t
))
867 TREE_VISITED (t
) = 0;
869 /* Otherwise, don't look any deeper. */
876 /* Unmark the visited trees rooted at *TP. */
879 unmark_visited (tree
*tp
)
881 walk_tree (tp
, unmark_visited_r
, NULL
, NULL
);
884 /* Likewise, but mark all trees as not visited. */
887 unvisit_body (tree fndecl
)
889 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
891 unmark_visited (&DECL_SAVED_TREE (fndecl
));
892 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl
)));
893 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)));
896 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
897 unvisit_body (cgn
->decl
);
900 /* Unconditionally make an unshared copy of EXPR. This is used when using
901 stored expressions which span multiple functions, such as BINFO_VTABLE,
902 as the normal unsharing process can't tell that they're shared. */
905 unshare_expr (tree expr
)
907 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
911 /* Worker for unshare_expr_without_location. */
914 prune_expr_location (tree
*tp
, int *walk_subtrees
, void *)
917 SET_EXPR_LOCATION (*tp
, UNKNOWN_LOCATION
);
923 /* Similar to unshare_expr but also prune all expression locations
927 unshare_expr_without_location (tree expr
)
929 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
931 walk_tree (&expr
, prune_expr_location
, NULL
, NULL
);
935 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
936 contain statements and have a value. Assign its value to a temporary
937 and give it void_type_node. Return the temporary, or NULL_TREE if
938 WRAPPER was already void. */
941 voidify_wrapper_expr (tree wrapper
, tree temp
)
943 tree type
= TREE_TYPE (wrapper
);
944 if (type
&& !VOID_TYPE_P (type
))
948 /* Set p to point to the body of the wrapper. Loop until we find
949 something that isn't a wrapper. */
950 for (p
= &wrapper
; p
&& *p
; )
952 switch (TREE_CODE (*p
))
955 TREE_SIDE_EFFECTS (*p
) = 1;
956 TREE_TYPE (*p
) = void_type_node
;
957 /* For a BIND_EXPR, the body is operand 1. */
958 p
= &BIND_EXPR_BODY (*p
);
961 case CLEANUP_POINT_EXPR
:
962 case TRY_FINALLY_EXPR
:
964 TREE_SIDE_EFFECTS (*p
) = 1;
965 TREE_TYPE (*p
) = void_type_node
;
966 p
= &TREE_OPERAND (*p
, 0);
971 tree_stmt_iterator i
= tsi_last (*p
);
972 TREE_SIDE_EFFECTS (*p
) = 1;
973 TREE_TYPE (*p
) = void_type_node
;
974 p
= tsi_end_p (i
) ? NULL
: tsi_stmt_ptr (i
);
979 /* Advance to the last statement. Set all container types to
981 for (; TREE_CODE (*p
) == COMPOUND_EXPR
; p
= &TREE_OPERAND (*p
, 1))
983 TREE_SIDE_EFFECTS (*p
) = 1;
984 TREE_TYPE (*p
) = void_type_node
;
988 case TRANSACTION_EXPR
:
989 TREE_SIDE_EFFECTS (*p
) = 1;
990 TREE_TYPE (*p
) = void_type_node
;
991 p
= &TRANSACTION_EXPR_BODY (*p
);
995 /* Assume that any tree upon which voidify_wrapper_expr is
996 directly called is a wrapper, and that its body is op0. */
999 TREE_SIDE_EFFECTS (*p
) = 1;
1000 TREE_TYPE (*p
) = void_type_node
;
1001 p
= &TREE_OPERAND (*p
, 0);
1009 if (p
== NULL
|| IS_EMPTY_STMT (*p
))
1013 /* The wrapper is on the RHS of an assignment that we're pushing
1015 gcc_assert (TREE_CODE (temp
) == INIT_EXPR
1016 || TREE_CODE (temp
) == MODIFY_EXPR
);
1017 TREE_OPERAND (temp
, 1) = *p
;
1022 temp
= create_tmp_var (type
, "retval");
1023 *p
= build2 (INIT_EXPR
, type
, temp
, *p
);
1032 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1033 a temporary through which they communicate. */
1036 build_stack_save_restore (gimple
*save
, gimple
*restore
)
1040 *save
= gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE
), 0);
1041 tmp_var
= create_tmp_var (ptr_type_node
, "saved_stack");
1042 gimple_call_set_lhs (*save
, tmp_var
);
1045 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE
),
1049 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1051 static enum gimplify_status
1052 gimplify_bind_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1054 tree bind_expr
= *expr_p
;
1055 bool old_save_stack
= gimplify_ctxp
->save_stack
;
1058 gimple_seq body
, cleanup
;
1060 location_t start_locus
= 0, end_locus
= 0;
1062 tree temp
= voidify_wrapper_expr (bind_expr
, NULL
);
1064 /* Mark variables seen in this bind expr. */
1065 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1067 if (TREE_CODE (t
) == VAR_DECL
)
1069 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1071 /* Mark variable as local. */
1072 if (ctx
&& !DECL_EXTERNAL (t
)
1073 && (! DECL_SEEN_IN_BIND_EXPR_P (t
)
1074 || splay_tree_lookup (ctx
->variables
,
1075 (splay_tree_key
) t
) == NULL
))
1077 if (ctx
->region_type
== ORT_SIMD
1078 && TREE_ADDRESSABLE (t
)
1079 && !TREE_STATIC (t
))
1080 omp_add_variable (ctx
, t
, GOVD_PRIVATE
| GOVD_SEEN
);
1082 omp_add_variable (ctx
, t
, GOVD_LOCAL
| GOVD_SEEN
);
1085 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
1087 if (DECL_HARD_REGISTER (t
) && !is_global_var (t
) && cfun
)
1088 cfun
->has_local_explicit_reg_vars
= true;
1091 /* Preliminarily mark non-addressed complex variables as eligible
1092 for promotion to gimple registers. We'll transform their uses
1094 if ((TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
1095 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1096 && !TREE_THIS_VOLATILE (t
)
1097 && (TREE_CODE (t
) == VAR_DECL
&& !DECL_HARD_REGISTER (t
))
1098 && !needs_to_live_in_memory (t
))
1099 DECL_GIMPLE_REG_P (t
) = 1;
1102 gimple_bind
= gimple_build_bind (BIND_EXPR_VARS (bind_expr
), NULL
,
1103 BIND_EXPR_BLOCK (bind_expr
));
1104 gimple_push_bind_expr (gimple_bind
);
1106 gimplify_ctxp
->save_stack
= false;
1108 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1110 gimplify_stmt (&BIND_EXPR_BODY (bind_expr
), &body
);
1111 gimple_bind_set_body (gimple_bind
, body
);
1113 /* Source location wise, the cleanup code (stack_restore and clobbers)
1114 belongs to the end of the block, so propagate what we have. The
1115 stack_save operation belongs to the beginning of block, which we can
1116 infer from the bind_expr directly if the block has no explicit
1118 if (BIND_EXPR_BLOCK (bind_expr
))
1120 end_locus
= BLOCK_SOURCE_END_LOCATION (BIND_EXPR_BLOCK (bind_expr
));
1121 start_locus
= BLOCK_SOURCE_LOCATION (BIND_EXPR_BLOCK (bind_expr
));
1123 if (start_locus
== 0)
1124 start_locus
= EXPR_LOCATION (bind_expr
);
1128 if (gimplify_ctxp
->save_stack
)
1130 gimple stack_restore
;
1132 /* Save stack on entry and restore it on exit. Add a try_finally
1133 block to achieve this. */
1134 build_stack_save_restore (&stack_save
, &stack_restore
);
1136 gimple_set_location (stack_save
, start_locus
);
1137 gimple_set_location (stack_restore
, end_locus
);
1139 gimplify_seq_add_stmt (&cleanup
, stack_restore
);
1142 /* Add clobbers for all variables that go out of scope. */
1143 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1145 if (TREE_CODE (t
) == VAR_DECL
1146 && !is_global_var (t
)
1147 && DECL_CONTEXT (t
) == current_function_decl
1148 && !DECL_HARD_REGISTER (t
)
1149 && !TREE_THIS_VOLATILE (t
)
1150 && !DECL_HAS_VALUE_EXPR_P (t
)
1151 /* Only care for variables that have to be in memory. Others
1152 will be rewritten into SSA names, hence moved to the top-level. */
1153 && !is_gimple_reg (t
)
1154 && flag_stack_reuse
!= SR_NONE
)
1156 tree clobber
= build_constructor (TREE_TYPE (t
), NULL
);
1157 gimple clobber_stmt
;
1158 TREE_THIS_VOLATILE (clobber
) = 1;
1159 clobber_stmt
= gimple_build_assign (t
, clobber
);
1160 gimple_set_location (clobber_stmt
, end_locus
);
1161 gimplify_seq_add_stmt (&cleanup
, clobber_stmt
);
1168 gimple_seq new_body
;
1171 gs
= gimple_build_try (gimple_bind_body (gimple_bind
), cleanup
,
1172 GIMPLE_TRY_FINALLY
);
1175 gimplify_seq_add_stmt (&new_body
, stack_save
);
1176 gimplify_seq_add_stmt (&new_body
, gs
);
1177 gimple_bind_set_body (gimple_bind
, new_body
);
1180 gimplify_ctxp
->save_stack
= old_save_stack
;
1181 gimple_pop_bind_expr ();
1183 gimplify_seq_add_stmt (pre_p
, gimple_bind
);
1191 *expr_p
= NULL_TREE
;
1195 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1196 GIMPLE value, it is assigned to a new temporary and the statement is
1197 re-written to return the temporary.
1199 PRE_P points to the sequence where side effects that must happen before
1200 STMT should be stored. */
1202 static enum gimplify_status
1203 gimplify_return_expr (tree stmt
, gimple_seq
*pre_p
)
1206 tree ret_expr
= TREE_OPERAND (stmt
, 0);
1207 tree result_decl
, result
;
1209 if (ret_expr
== error_mark_node
)
1212 /* Implicit _Cilk_sync must be inserted right before any return statement
1213 if there is a _Cilk_spawn in the function. If the user has provided a
1214 _Cilk_sync, the optimizer should remove this duplicate one. */
1215 if (fn_contains_cilk_spawn_p (cfun
))
1217 tree impl_sync
= build0 (CILK_SYNC_STMT
, void_type_node
);
1218 gimplify_and_add (impl_sync
, pre_p
);
1222 || TREE_CODE (ret_expr
) == RESULT_DECL
1223 || ret_expr
== error_mark_node
)
1225 gimple ret
= gimple_build_return (ret_expr
);
1226 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1227 gimplify_seq_add_stmt (pre_p
, ret
);
1231 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1232 result_decl
= NULL_TREE
;
1235 result_decl
= TREE_OPERAND (ret_expr
, 0);
1237 /* See through a return by reference. */
1238 if (TREE_CODE (result_decl
) == INDIRECT_REF
)
1239 result_decl
= TREE_OPERAND (result_decl
, 0);
1241 gcc_assert ((TREE_CODE (ret_expr
) == MODIFY_EXPR
1242 || TREE_CODE (ret_expr
) == INIT_EXPR
)
1243 && TREE_CODE (result_decl
) == RESULT_DECL
);
1246 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1247 Recall that aggregate_value_p is FALSE for any aggregate type that is
1248 returned in registers. If we're returning values in registers, then
1249 we don't want to extend the lifetime of the RESULT_DECL, particularly
1250 across another call. In addition, for those aggregates for which
1251 hard_function_value generates a PARALLEL, we'll die during normal
1252 expansion of structure assignments; there's special code in expand_return
1253 to handle this case that does not exist in expand_expr. */
1256 else if (aggregate_value_p (result_decl
, TREE_TYPE (current_function_decl
)))
1258 if (TREE_CODE (DECL_SIZE (result_decl
)) != INTEGER_CST
)
1260 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl
)))
1261 gimplify_type_sizes (TREE_TYPE (result_decl
), pre_p
);
1262 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1263 should be effectively allocated by the caller, i.e. all calls to
1264 this function must be subject to the Return Slot Optimization. */
1265 gimplify_one_sizepos (&DECL_SIZE (result_decl
), pre_p
);
1266 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl
), pre_p
);
1268 result
= result_decl
;
1270 else if (gimplify_ctxp
->return_temp
)
1271 result
= gimplify_ctxp
->return_temp
;
1274 result
= create_tmp_reg (TREE_TYPE (result_decl
), NULL
);
1276 /* ??? With complex control flow (usually involving abnormal edges),
1277 we can wind up warning about an uninitialized value for this. Due
1278 to how this variable is constructed and initialized, this is never
1279 true. Give up and never warn. */
1280 TREE_NO_WARNING (result
) = 1;
1282 gimplify_ctxp
->return_temp
= result
;
1285 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1286 Then gimplify the whole thing. */
1287 if (result
!= result_decl
)
1288 TREE_OPERAND (ret_expr
, 0) = result
;
1290 gimplify_and_add (TREE_OPERAND (stmt
, 0), pre_p
);
1292 ret
= gimple_build_return (result
);
1293 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1294 gimplify_seq_add_stmt (pre_p
, ret
);
1299 /* Gimplify a variable-length array DECL. */
1302 gimplify_vla_decl (tree decl
, gimple_seq
*seq_p
)
1304 /* This is a variable-sized decl. Simplify its size and mark it
1305 for deferred expansion. */
1306 tree t
, addr
, ptr_type
;
1308 gimplify_one_sizepos (&DECL_SIZE (decl
), seq_p
);
1309 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl
), seq_p
);
1311 /* Don't mess with a DECL_VALUE_EXPR set by the front-end. */
1312 if (DECL_HAS_VALUE_EXPR_P (decl
))
1315 /* All occurrences of this decl in final gimplified code will be
1316 replaced by indirection. Setting DECL_VALUE_EXPR does two
1317 things: First, it lets the rest of the gimplifier know what
1318 replacement to use. Second, it lets the debug info know
1319 where to find the value. */
1320 ptr_type
= build_pointer_type (TREE_TYPE (decl
));
1321 addr
= create_tmp_var (ptr_type
, get_name (decl
));
1322 DECL_IGNORED_P (addr
) = 0;
1323 t
= build_fold_indirect_ref (addr
);
1324 TREE_THIS_NOTRAP (t
) = 1;
1325 SET_DECL_VALUE_EXPR (decl
, t
);
1326 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1328 t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
1329 t
= build_call_expr (t
, 2, DECL_SIZE_UNIT (decl
),
1330 size_int (DECL_ALIGN (decl
)));
1331 /* The call has been built for a variable-sized object. */
1332 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
1333 t
= fold_convert (ptr_type
, t
);
1334 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
1336 gimplify_and_add (t
, seq_p
);
1338 /* Indicate that we need to restore the stack level when the
1339 enclosing BIND_EXPR is exited. */
1340 gimplify_ctxp
->save_stack
= true;
1343 /* A helper function to be called via walk_tree. Mark all labels under *TP
1344 as being forced. To be called for DECL_INITIAL of static variables. */
1347 force_labels_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1351 if (TREE_CODE (*tp
) == LABEL_DECL
)
1352 FORCED_LABEL (*tp
) = 1;
1357 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1358 and initialization explicit. */
1360 static enum gimplify_status
1361 gimplify_decl_expr (tree
*stmt_p
, gimple_seq
*seq_p
)
1363 tree stmt
= *stmt_p
;
1364 tree decl
= DECL_EXPR_DECL (stmt
);
1366 *stmt_p
= NULL_TREE
;
1368 if (TREE_TYPE (decl
) == error_mark_node
)
1371 if ((TREE_CODE (decl
) == TYPE_DECL
1372 || TREE_CODE (decl
) == VAR_DECL
)
1373 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl
)))
1374 gimplify_type_sizes (TREE_TYPE (decl
), seq_p
);
1376 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1377 in case its size expressions contain problematic nodes like CALL_EXPR. */
1378 if (TREE_CODE (decl
) == TYPE_DECL
1379 && DECL_ORIGINAL_TYPE (decl
)
1380 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl
)))
1381 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl
), seq_p
);
1383 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1385 tree init
= DECL_INITIAL (decl
);
1387 if (TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1388 || (!TREE_STATIC (decl
)
1389 && flag_stack_check
== GENERIC_STACK_CHECK
1390 && compare_tree_int (DECL_SIZE_UNIT (decl
),
1391 STACK_CHECK_MAX_VAR_SIZE
) > 0))
1392 gimplify_vla_decl (decl
, seq_p
);
1394 /* Some front ends do not explicitly declare all anonymous
1395 artificial variables. We compensate here by declaring the
1396 variables, though it would be better if the front ends would
1397 explicitly declare them. */
1398 if (!DECL_SEEN_IN_BIND_EXPR_P (decl
)
1399 && DECL_ARTIFICIAL (decl
) && DECL_NAME (decl
) == NULL_TREE
)
1400 gimple_add_tmp_var (decl
);
1402 if (init
&& init
!= error_mark_node
)
1404 if (!TREE_STATIC (decl
))
1406 DECL_INITIAL (decl
) = NULL_TREE
;
1407 init
= build2 (INIT_EXPR
, void_type_node
, decl
, init
);
1408 gimplify_and_add (init
, seq_p
);
1412 /* We must still examine initializers for static variables
1413 as they may contain a label address. */
1414 walk_tree (&init
, force_labels_r
, NULL
, NULL
);
1421 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1422 and replacing the LOOP_EXPR with goto, but if the loop contains an
1423 EXIT_EXPR, we need to append a label for it to jump to. */
1425 static enum gimplify_status
1426 gimplify_loop_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1428 tree saved_label
= gimplify_ctxp
->exit_label
;
1429 tree start_label
= create_artificial_label (UNKNOWN_LOCATION
);
1431 gimplify_seq_add_stmt (pre_p
, gimple_build_label (start_label
));
1433 gimplify_ctxp
->exit_label
= NULL_TREE
;
1435 gimplify_and_add (LOOP_EXPR_BODY (*expr_p
), pre_p
);
1437 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (start_label
));
1439 if (gimplify_ctxp
->exit_label
)
1440 gimplify_seq_add_stmt (pre_p
,
1441 gimple_build_label (gimplify_ctxp
->exit_label
));
1443 gimplify_ctxp
->exit_label
= saved_label
;
1449 /* Gimplify a statement list onto a sequence. These may be created either
1450 by an enlightened front-end, or by shortcut_cond_expr. */
1452 static enum gimplify_status
1453 gimplify_statement_list (tree
*expr_p
, gimple_seq
*pre_p
)
1455 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
1457 tree_stmt_iterator i
= tsi_start (*expr_p
);
1459 while (!tsi_end_p (i
))
1461 gimplify_stmt (tsi_stmt_ptr (i
), pre_p
);
1475 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
1478 static enum gimplify_status
1479 gimplify_switch_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1481 tree switch_expr
= *expr_p
;
1482 gimple_seq switch_body_seq
= NULL
;
1483 enum gimplify_status ret
;
1484 tree index_type
= TREE_TYPE (switch_expr
);
1485 if (index_type
== NULL_TREE
)
1486 index_type
= TREE_TYPE (SWITCH_COND (switch_expr
));
1488 ret
= gimplify_expr (&SWITCH_COND (switch_expr
), pre_p
, NULL
, is_gimple_val
,
1490 if (ret
== GS_ERROR
|| ret
== GS_UNHANDLED
)
1493 if (SWITCH_BODY (switch_expr
))
1496 vec
<tree
> saved_labels
;
1497 tree default_case
= NULL_TREE
;
1498 gimple gimple_switch
;
1500 /* If someone can be bothered to fill in the labels, they can
1501 be bothered to null out the body too. */
1502 gcc_assert (!SWITCH_LABELS (switch_expr
));
1504 /* Save old labels, get new ones from body, then restore the old
1505 labels. Save all the things from the switch body to append after. */
1506 saved_labels
= gimplify_ctxp
->case_labels
;
1507 gimplify_ctxp
->case_labels
.create (8);
1509 gimplify_stmt (&SWITCH_BODY (switch_expr
), &switch_body_seq
);
1510 labels
= gimplify_ctxp
->case_labels
;
1511 gimplify_ctxp
->case_labels
= saved_labels
;
1513 preprocess_case_label_vec_for_gimple (labels
, index_type
,
1521 = build_case_label (NULL_TREE
, NULL_TREE
,
1522 create_artificial_label (UNKNOWN_LOCATION
));
1523 new_default
= gimple_build_label (CASE_LABEL (default_case
));
1524 gimplify_seq_add_stmt (&switch_body_seq
, new_default
);
1527 gimple_switch
= gimple_build_switch (SWITCH_COND (switch_expr
),
1528 default_case
, labels
);
1529 gimplify_seq_add_stmt (pre_p
, gimple_switch
);
1530 gimplify_seq_add_seq (pre_p
, switch_body_seq
);
1534 gcc_assert (SWITCH_LABELS (switch_expr
));
1539 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
1541 static enum gimplify_status
1542 gimplify_case_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1544 struct gimplify_ctx
*ctxp
;
1545 gimple gimple_label
;
1547 /* Invalid OpenMP programs can play Duff's Device type games with
1548 #pragma omp parallel. At least in the C front end, we don't
1549 detect such invalid branches until after gimplification. */
1550 for (ctxp
= gimplify_ctxp
; ; ctxp
= ctxp
->prev_context
)
1551 if (ctxp
->case_labels
.exists ())
1554 gimple_label
= gimple_build_label (CASE_LABEL (*expr_p
));
1555 ctxp
->case_labels
.safe_push (*expr_p
);
1556 gimplify_seq_add_stmt (pre_p
, gimple_label
);
1561 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1565 build_and_jump (tree
*label_p
)
1567 if (label_p
== NULL
)
1568 /* If there's nowhere to jump, just fall through. */
1571 if (*label_p
== NULL_TREE
)
1573 tree label
= create_artificial_label (UNKNOWN_LOCATION
);
1577 return build1 (GOTO_EXPR
, void_type_node
, *label_p
);
1580 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1581 This also involves building a label to jump to and communicating it to
1582 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1584 static enum gimplify_status
1585 gimplify_exit_expr (tree
*expr_p
)
1587 tree cond
= TREE_OPERAND (*expr_p
, 0);
1590 expr
= build_and_jump (&gimplify_ctxp
->exit_label
);
1591 expr
= build3 (COND_EXPR
, void_type_node
, cond
, expr
, NULL_TREE
);
1597 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1598 different from its canonical type, wrap the whole thing inside a
1599 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1602 The canonical type of a COMPONENT_REF is the type of the field being
1603 referenced--unless the field is a bit-field which can be read directly
1604 in a smaller mode, in which case the canonical type is the
1605 sign-appropriate type corresponding to that mode. */
1608 canonicalize_component_ref (tree
*expr_p
)
1610 tree expr
= *expr_p
;
1613 gcc_assert (TREE_CODE (expr
) == COMPONENT_REF
);
1615 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
1616 type
= TREE_TYPE (get_unwidened (expr
, NULL_TREE
));
1618 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
1620 /* One could argue that all the stuff below is not necessary for
1621 the non-bitfield case and declare it a FE error if type
1622 adjustment would be needed. */
1623 if (TREE_TYPE (expr
) != type
)
1625 #ifdef ENABLE_TYPES_CHECKING
1626 tree old_type
= TREE_TYPE (expr
);
1630 /* We need to preserve qualifiers and propagate them from
1632 type_quals
= TYPE_QUALS (type
)
1633 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1634 if (TYPE_QUALS (type
) != type_quals
)
1635 type
= build_qualified_type (TYPE_MAIN_VARIANT (type
), type_quals
);
1637 /* Set the type of the COMPONENT_REF to the underlying type. */
1638 TREE_TYPE (expr
) = type
;
1640 #ifdef ENABLE_TYPES_CHECKING
1641 /* It is now a FE error, if the conversion from the canonical
1642 type to the original expression type is not useless. */
1643 gcc_assert (useless_type_conversion_p (old_type
, type
));
1648 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1649 to foo, embed that change in the ADDR_EXPR by converting
1654 where L is the lower bound. For simplicity, only do this for constant
1656 The constraint is that the type of &array[L] is trivially convertible
1660 canonicalize_addr_expr (tree
*expr_p
)
1662 tree expr
= *expr_p
;
1663 tree addr_expr
= TREE_OPERAND (expr
, 0);
1664 tree datype
, ddatype
, pddatype
;
1666 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1667 if (!POINTER_TYPE_P (TREE_TYPE (expr
))
1668 || TREE_CODE (addr_expr
) != ADDR_EXPR
)
1671 /* The addr_expr type should be a pointer to an array. */
1672 datype
= TREE_TYPE (TREE_TYPE (addr_expr
));
1673 if (TREE_CODE (datype
) != ARRAY_TYPE
)
1676 /* The pointer to element type shall be trivially convertible to
1677 the expression pointer type. */
1678 ddatype
= TREE_TYPE (datype
);
1679 pddatype
= build_pointer_type (ddatype
);
1680 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)),
1684 /* The lower bound and element sizes must be constant. */
1685 if (!TYPE_SIZE_UNIT (ddatype
)
1686 || TREE_CODE (TYPE_SIZE_UNIT (ddatype
)) != INTEGER_CST
1687 || !TYPE_DOMAIN (datype
) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))
1688 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))) != INTEGER_CST
)
1691 /* All checks succeeded. Build a new node to merge the cast. */
1692 *expr_p
= build4 (ARRAY_REF
, ddatype
, TREE_OPERAND (addr_expr
, 0),
1693 TYPE_MIN_VALUE (TYPE_DOMAIN (datype
)),
1694 NULL_TREE
, NULL_TREE
);
1695 *expr_p
= build1 (ADDR_EXPR
, pddatype
, *expr_p
);
1697 /* We can have stripped a required restrict qualifier above. */
1698 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
1699 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
1702 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1703 underneath as appropriate. */
1705 static enum gimplify_status
1706 gimplify_conversion (tree
*expr_p
)
1708 location_t loc
= EXPR_LOCATION (*expr_p
);
1709 gcc_assert (CONVERT_EXPR_P (*expr_p
));
1711 /* Then strip away all but the outermost conversion. */
1712 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p
, 0));
1714 /* And remove the outermost conversion if it's useless. */
1715 if (tree_ssa_useless_type_conversion (*expr_p
))
1716 *expr_p
= TREE_OPERAND (*expr_p
, 0);
1718 /* If we still have a conversion at the toplevel,
1719 then canonicalize some constructs. */
1720 if (CONVERT_EXPR_P (*expr_p
))
1722 tree sub
= TREE_OPERAND (*expr_p
, 0);
1724 /* If a NOP conversion is changing the type of a COMPONENT_REF
1725 expression, then canonicalize its type now in order to expose more
1726 redundant conversions. */
1727 if (TREE_CODE (sub
) == COMPONENT_REF
)
1728 canonicalize_component_ref (&TREE_OPERAND (*expr_p
, 0));
1730 /* If a NOP conversion is changing a pointer to array of foo
1731 to a pointer to foo, embed that change in the ADDR_EXPR. */
1732 else if (TREE_CODE (sub
) == ADDR_EXPR
)
1733 canonicalize_addr_expr (expr_p
);
1736 /* If we have a conversion to a non-register type force the
1737 use of a VIEW_CONVERT_EXPR instead. */
1738 if (CONVERT_EXPR_P (*expr_p
) && !is_gimple_reg_type (TREE_TYPE (*expr_p
)))
1739 *expr_p
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (*expr_p
),
1740 TREE_OPERAND (*expr_p
, 0));
1742 /* Canonicalize CONVERT_EXPR to NOP_EXPR. */
1743 if (TREE_CODE (*expr_p
) == CONVERT_EXPR
)
1744 TREE_SET_CODE (*expr_p
, NOP_EXPR
);
1749 /* Nonlocal VLAs seen in the current function. */
1750 static hash_set
<tree
> *nonlocal_vlas
;
1752 /* The VAR_DECLs created for nonlocal VLAs for debug info purposes. */
1753 static tree nonlocal_vla_vars
;
1755 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
1756 DECL_VALUE_EXPR, and it's worth re-examining things. */
1758 static enum gimplify_status
1759 gimplify_var_or_parm_decl (tree
*expr_p
)
1761 tree decl
= *expr_p
;
1763 /* ??? If this is a local variable, and it has not been seen in any
1764 outer BIND_EXPR, then it's probably the result of a duplicate
1765 declaration, for which we've already issued an error. It would
1766 be really nice if the front end wouldn't leak these at all.
1767 Currently the only known culprit is C++ destructors, as seen
1768 in g++.old-deja/g++.jason/binding.C. */
1769 if (TREE_CODE (decl
) == VAR_DECL
1770 && !DECL_SEEN_IN_BIND_EXPR_P (decl
)
1771 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)
1772 && decl_function_context (decl
) == current_function_decl
)
1774 gcc_assert (seen_error ());
1778 /* When within an OpenMP context, notice uses of variables. */
1779 if (gimplify_omp_ctxp
&& omp_notice_variable (gimplify_omp_ctxp
, decl
, true))
1782 /* If the decl is an alias for another expression, substitute it now. */
1783 if (DECL_HAS_VALUE_EXPR_P (decl
))
1785 tree value_expr
= DECL_VALUE_EXPR (decl
);
1787 /* For referenced nonlocal VLAs add a decl for debugging purposes
1788 to the current function. */
1789 if (TREE_CODE (decl
) == VAR_DECL
1790 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1791 && nonlocal_vlas
!= NULL
1792 && TREE_CODE (value_expr
) == INDIRECT_REF
1793 && TREE_CODE (TREE_OPERAND (value_expr
, 0)) == VAR_DECL
1794 && decl_function_context (decl
) != current_function_decl
)
1796 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1798 && (ctx
->region_type
== ORT_WORKSHARE
1799 || ctx
->region_type
== ORT_SIMD
))
1800 ctx
= ctx
->outer_context
;
1801 if (!ctx
&& !nonlocal_vlas
->add (decl
))
1803 tree copy
= copy_node (decl
);
1805 lang_hooks
.dup_lang_specific_decl (copy
);
1806 SET_DECL_RTL (copy
, 0);
1807 TREE_USED (copy
) = 1;
1808 DECL_CHAIN (copy
) = nonlocal_vla_vars
;
1809 nonlocal_vla_vars
= copy
;
1810 SET_DECL_VALUE_EXPR (copy
, unshare_expr (value_expr
));
1811 DECL_HAS_VALUE_EXPR_P (copy
) = 1;
1815 *expr_p
= unshare_expr (value_expr
);
1822 /* Recalculate the value of the TREE_SIDE_EFFECTS flag for T. */
1825 recalculate_side_effects (tree t
)
1827 enum tree_code code
= TREE_CODE (t
);
1828 int len
= TREE_OPERAND_LENGTH (t
);
1831 switch (TREE_CODE_CLASS (code
))
1833 case tcc_expression
:
1839 case PREDECREMENT_EXPR
:
1840 case PREINCREMENT_EXPR
:
1841 case POSTDECREMENT_EXPR
:
1842 case POSTINCREMENT_EXPR
:
1843 /* All of these have side-effects, no matter what their
1852 case tcc_comparison
: /* a comparison expression */
1853 case tcc_unary
: /* a unary arithmetic expression */
1854 case tcc_binary
: /* a binary arithmetic expression */
1855 case tcc_reference
: /* a reference */
1856 case tcc_vl_exp
: /* a function call */
1857 TREE_SIDE_EFFECTS (t
) = TREE_THIS_VOLATILE (t
);
1858 for (i
= 0; i
< len
; ++i
)
1860 tree op
= TREE_OPERAND (t
, i
);
1861 if (op
&& TREE_SIDE_EFFECTS (op
))
1862 TREE_SIDE_EFFECTS (t
) = 1;
1867 /* No side-effects. */
1875 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1879 : min_lval '[' val ']'
1881 | compound_lval '[' val ']'
1882 | compound_lval '.' ID
1884 This is not part of the original SIMPLE definition, which separates
1885 array and member references, but it seems reasonable to handle them
1886 together. Also, this way we don't run into problems with union
1887 aliasing; gcc requires that for accesses through a union to alias, the
1888 union reference must be explicit, which was not always the case when we
1889 were splitting up array and member refs.
1891 PRE_P points to the sequence where side effects that must happen before
1892 *EXPR_P should be stored.
1894 POST_P points to the sequence where side effects that must happen after
1895 *EXPR_P should be stored. */
1897 static enum gimplify_status
1898 gimplify_compound_lval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
1899 fallback_t fallback
)
1902 enum gimplify_status ret
= GS_ALL_DONE
, tret
;
1904 location_t loc
= EXPR_LOCATION (*expr_p
);
1905 tree expr
= *expr_p
;
1907 /* Create a stack of the subexpressions so later we can walk them in
1908 order from inner to outer. */
1909 auto_vec
<tree
, 10> expr_stack
;
1911 /* We can handle anything that get_inner_reference can deal with. */
1912 for (p
= expr_p
; ; p
= &TREE_OPERAND (*p
, 0))
1915 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
1916 if (TREE_CODE (*p
) == INDIRECT_REF
)
1917 *p
= fold_indirect_ref_loc (loc
, *p
);
1919 if (handled_component_p (*p
))
1921 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
1922 additional COMPONENT_REFs. */
1923 else if ((TREE_CODE (*p
) == VAR_DECL
|| TREE_CODE (*p
) == PARM_DECL
)
1924 && gimplify_var_or_parm_decl (p
) == GS_OK
)
1929 expr_stack
.safe_push (*p
);
1932 gcc_assert (expr_stack
.length ());
1934 /* Now EXPR_STACK is a stack of pointers to all the refs we've
1935 walked through and P points to the innermost expression.
1937 Java requires that we elaborated nodes in source order. That
1938 means we must gimplify the inner expression followed by each of
1939 the indices, in order. But we can't gimplify the inner
1940 expression until we deal with any variable bounds, sizes, or
1941 positions in order to deal with PLACEHOLDER_EXPRs.
1943 So we do this in three steps. First we deal with the annotations
1944 for any variables in the components, then we gimplify the base,
1945 then we gimplify any indices, from left to right. */
1946 for (i
= expr_stack
.length () - 1; i
>= 0; i
--)
1948 tree t
= expr_stack
[i
];
1950 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
1952 /* Gimplify the low bound and element type size and put them into
1953 the ARRAY_REF. If these values are set, they have already been
1955 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
1957 tree low
= unshare_expr (array_ref_low_bound (t
));
1958 if (!is_gimple_min_invariant (low
))
1960 TREE_OPERAND (t
, 2) = low
;
1961 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
1962 post_p
, is_gimple_reg
,
1964 ret
= MIN (ret
, tret
);
1969 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
1970 is_gimple_reg
, fb_rvalue
);
1971 ret
= MIN (ret
, tret
);
1974 if (TREE_OPERAND (t
, 3) == NULL_TREE
)
1976 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0)));
1977 tree elmt_size
= unshare_expr (array_ref_element_size (t
));
1978 tree factor
= size_int (TYPE_ALIGN_UNIT (elmt_type
));
1980 /* Divide the element size by the alignment of the element
1983 = size_binop_loc (loc
, EXACT_DIV_EXPR
, elmt_size
, factor
);
1985 if (!is_gimple_min_invariant (elmt_size
))
1987 TREE_OPERAND (t
, 3) = elmt_size
;
1988 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
,
1989 post_p
, is_gimple_reg
,
1991 ret
= MIN (ret
, tret
);
1996 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
, post_p
,
1997 is_gimple_reg
, fb_rvalue
);
1998 ret
= MIN (ret
, tret
);
2001 else if (TREE_CODE (t
) == COMPONENT_REF
)
2003 /* Set the field offset into T and gimplify it. */
2004 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2006 tree offset
= unshare_expr (component_ref_field_offset (t
));
2007 tree field
= TREE_OPERAND (t
, 1);
2009 = size_int (DECL_OFFSET_ALIGN (field
) / BITS_PER_UNIT
);
2011 /* Divide the offset by its alignment. */
2012 offset
= size_binop_loc (loc
, EXACT_DIV_EXPR
, offset
, factor
);
2014 if (!is_gimple_min_invariant (offset
))
2016 TREE_OPERAND (t
, 2) = offset
;
2017 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2018 post_p
, is_gimple_reg
,
2020 ret
= MIN (ret
, tret
);
2025 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2026 is_gimple_reg
, fb_rvalue
);
2027 ret
= MIN (ret
, tret
);
2032 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2033 so as to match the min_lval predicate. Failure to do so may result
2034 in the creation of large aggregate temporaries. */
2035 tret
= gimplify_expr (p
, pre_p
, post_p
, is_gimple_min_lval
,
2036 fallback
| fb_lvalue
);
2037 ret
= MIN (ret
, tret
);
2039 /* And finally, the indices and operands of ARRAY_REF. During this
2040 loop we also remove any useless conversions. */
2041 for (; expr_stack
.length () > 0; )
2043 tree t
= expr_stack
.pop ();
2045 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2047 /* Gimplify the dimension. */
2048 if (!is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
2050 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2051 is_gimple_val
, fb_rvalue
);
2052 ret
= MIN (ret
, tret
);
2056 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t
, 0));
2058 /* The innermost expression P may have originally had
2059 TREE_SIDE_EFFECTS set which would have caused all the outer
2060 expressions in *EXPR_P leading to P to also have had
2061 TREE_SIDE_EFFECTS set. */
2062 recalculate_side_effects (t
);
2065 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2066 if ((fallback
& fb_rvalue
) && TREE_CODE (*expr_p
) == COMPONENT_REF
)
2068 canonicalize_component_ref (expr_p
);
2071 expr_stack
.release ();
2073 gcc_assert (*expr_p
== expr
|| ret
!= GS_ALL_DONE
);
2078 /* Gimplify the self modifying expression pointed to by EXPR_P
2081 PRE_P points to the list where side effects that must happen before
2082 *EXPR_P should be stored.
2084 POST_P points to the list where side effects that must happen after
2085 *EXPR_P should be stored.
2087 WANT_VALUE is nonzero iff we want to use the value of this expression
2088 in another expression.
2090 ARITH_TYPE is the type the computation should be performed in. */
2092 enum gimplify_status
2093 gimplify_self_mod_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2094 bool want_value
, tree arith_type
)
2096 enum tree_code code
;
2097 tree lhs
, lvalue
, rhs
, t1
;
2098 gimple_seq post
= NULL
, *orig_post_p
= post_p
;
2100 enum tree_code arith_code
;
2101 enum gimplify_status ret
;
2102 location_t loc
= EXPR_LOCATION (*expr_p
);
2104 code
= TREE_CODE (*expr_p
);
2106 gcc_assert (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
2107 || code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
);
2109 /* Prefix or postfix? */
2110 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
2111 /* Faster to treat as prefix if result is not used. */
2112 postfix
= want_value
;
2116 /* For postfix, make sure the inner expression's post side effects
2117 are executed after side effects from this expression. */
2121 /* Add or subtract? */
2122 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2123 arith_code
= PLUS_EXPR
;
2125 arith_code
= MINUS_EXPR
;
2127 /* Gimplify the LHS into a GIMPLE lvalue. */
2128 lvalue
= TREE_OPERAND (*expr_p
, 0);
2129 ret
= gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
2130 if (ret
== GS_ERROR
)
2133 /* Extract the operands to the arithmetic operation. */
2135 rhs
= TREE_OPERAND (*expr_p
, 1);
2137 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2138 that as the result value and in the postqueue operation. */
2141 ret
= gimplify_expr (&lhs
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
2142 if (ret
== GS_ERROR
)
2145 lhs
= get_initialized_tmp_var (lhs
, pre_p
, NULL
);
2148 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2149 if (POINTER_TYPE_P (TREE_TYPE (lhs
)))
2151 rhs
= convert_to_ptrofftype_loc (loc
, rhs
);
2152 if (arith_code
== MINUS_EXPR
)
2153 rhs
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
2154 t1
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (*expr_p
), lhs
, rhs
);
2157 t1
= fold_convert (TREE_TYPE (*expr_p
),
2158 fold_build2 (arith_code
, arith_type
,
2159 fold_convert (arith_type
, lhs
),
2160 fold_convert (arith_type
, rhs
)));
2164 gimplify_assign (lvalue
, t1
, pre_p
);
2165 gimplify_seq_add_seq (orig_post_p
, post
);
2171 *expr_p
= build2 (MODIFY_EXPR
, TREE_TYPE (lvalue
), lvalue
, t1
);
2176 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2179 maybe_with_size_expr (tree
*expr_p
)
2181 tree expr
= *expr_p
;
2182 tree type
= TREE_TYPE (expr
);
2185 /* If we've already wrapped this or the type is error_mark_node, we can't do
2187 if (TREE_CODE (expr
) == WITH_SIZE_EXPR
2188 || type
== error_mark_node
)
2191 /* If the size isn't known or is a constant, we have nothing to do. */
2192 size
= TYPE_SIZE_UNIT (type
);
2193 if (!size
|| TREE_CODE (size
) == INTEGER_CST
)
2196 /* Otherwise, make a WITH_SIZE_EXPR. */
2197 size
= unshare_expr (size
);
2198 size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (size
, expr
);
2199 *expr_p
= build2 (WITH_SIZE_EXPR
, type
, expr
, size
);
2202 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2203 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2206 enum gimplify_status
2207 gimplify_arg (tree
*arg_p
, gimple_seq
*pre_p
, location_t call_location
)
2209 bool (*test
) (tree
);
2212 /* In general, we allow lvalues for function arguments to avoid
2213 extra overhead of copying large aggregates out of even larger
2214 aggregates into temporaries only to copy the temporaries to
2215 the argument list. Make optimizers happy by pulling out to
2216 temporaries those types that fit in registers. */
2217 if (is_gimple_reg_type (TREE_TYPE (*arg_p
)))
2218 test
= is_gimple_val
, fb
= fb_rvalue
;
2221 test
= is_gimple_lvalue
, fb
= fb_either
;
2222 /* Also strip a TARGET_EXPR that would force an extra copy. */
2223 if (TREE_CODE (*arg_p
) == TARGET_EXPR
)
2225 tree init
= TARGET_EXPR_INITIAL (*arg_p
);
2227 && !VOID_TYPE_P (TREE_TYPE (init
)))
2232 /* If this is a variable sized type, we must remember the size. */
2233 maybe_with_size_expr (arg_p
);
2235 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2236 /* Make sure arguments have the same location as the function call
2238 protected_set_expr_location (*arg_p
, call_location
);
2240 /* There is a sequence point before a function call. Side effects in
2241 the argument list must occur before the actual call. So, when
2242 gimplifying arguments, force gimplify_expr to use an internal
2243 post queue which is then appended to the end of PRE_P. */
2244 return gimplify_expr (arg_p
, pre_p
, NULL
, test
, fb
);
2247 /* Don't fold STMT inside ORT_TARGET, because it can break code by adding decl
2248 references that weren't in the source. We'll do it during omplower pass
2252 maybe_fold_stmt (gimple_stmt_iterator
*gsi
)
2254 struct gimplify_omp_ctx
*ctx
;
2255 for (ctx
= gimplify_omp_ctxp
; ctx
; ctx
= ctx
->outer_context
)
2256 if (ctx
->region_type
== ORT_TARGET
)
2258 return fold_stmt (gsi
);
2261 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2262 WANT_VALUE is true if the result of the call is desired. */
2264 static enum gimplify_status
2265 gimplify_call_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
2267 tree fndecl
, parms
, p
, fnptrtype
;
2268 enum gimplify_status ret
;
2271 bool builtin_va_start_p
= false;
2272 location_t loc
= EXPR_LOCATION (*expr_p
);
2274 gcc_assert (TREE_CODE (*expr_p
) == CALL_EXPR
);
2276 /* For reliable diagnostics during inlining, it is necessary that
2277 every call_expr be annotated with file and line. */
2278 if (! EXPR_HAS_LOCATION (*expr_p
))
2279 SET_EXPR_LOCATION (*expr_p
, input_location
);
2281 /* Gimplify internal functions created in the FEs. */
2282 if (CALL_EXPR_FN (*expr_p
) == NULL_TREE
)
2287 nargs
= call_expr_nargs (*expr_p
);
2288 enum internal_fn ifn
= CALL_EXPR_IFN (*expr_p
);
2289 auto_vec
<tree
> vargs (nargs
);
2291 for (i
= 0; i
< nargs
; i
++)
2293 gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
2294 EXPR_LOCATION (*expr_p
));
2295 vargs
.quick_push (CALL_EXPR_ARG (*expr_p
, i
));
2297 gimple call
= gimple_build_call_internal_vec (ifn
, vargs
);
2298 gimplify_seq_add_stmt (pre_p
, call
);
2302 /* This may be a call to a builtin function.
2304 Builtin function calls may be transformed into different
2305 (and more efficient) builtin function calls under certain
2306 circumstances. Unfortunately, gimplification can muck things
2307 up enough that the builtin expanders are not aware that certain
2308 transformations are still valid.
2310 So we attempt transformation/gimplification of the call before
2311 we gimplify the CALL_EXPR. At this time we do not manage to
2312 transform all calls in the same manner as the expanders do, but
2313 we do transform most of them. */
2314 fndecl
= get_callee_fndecl (*expr_p
);
2316 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
2317 switch (DECL_FUNCTION_CODE (fndecl
))
2319 case BUILT_IN_VA_START
:
2321 builtin_va_start_p
= TRUE
;
2322 if (call_expr_nargs (*expr_p
) < 2)
2324 error ("too few arguments to function %<va_start%>");
2325 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2329 if (fold_builtin_next_arg (*expr_p
, true))
2331 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2338 *expr_p
= build_int_cst (TREE_TYPE (*expr_p
),
2339 LOCATION_LINE (EXPR_LOCATION (*expr_p
)));
2344 const char *locfile
= LOCATION_FILE (EXPR_LOCATION (*expr_p
));
2345 *expr_p
= build_string_literal (strlen (locfile
) + 1, locfile
);
2348 case BUILT_IN_FUNCTION
:
2350 const char *function
;
2351 function
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
2352 *expr_p
= build_string_literal (strlen (function
) + 1, function
);
2358 if (fndecl
&& DECL_BUILT_IN (fndecl
))
2360 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2361 if (new_tree
&& new_tree
!= *expr_p
)
2363 /* There was a transformation of this call which computes the
2364 same value, but in a more efficient way. Return and try
2371 /* Remember the original function pointer type. */
2372 fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*expr_p
));
2374 /* There is a sequence point before the call, so any side effects in
2375 the calling expression must occur before the actual call. Force
2376 gimplify_expr to use an internal post queue. */
2377 ret
= gimplify_expr (&CALL_EXPR_FN (*expr_p
), pre_p
, NULL
,
2378 is_gimple_call_addr
, fb_rvalue
);
2380 nargs
= call_expr_nargs (*expr_p
);
2382 /* Get argument types for verification. */
2383 fndecl
= get_callee_fndecl (*expr_p
);
2386 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2388 parms
= TYPE_ARG_TYPES (TREE_TYPE (fnptrtype
));
2390 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
2391 p
= DECL_ARGUMENTS (fndecl
);
2396 for (i
= 0; i
< nargs
&& p
; i
++, p
= TREE_CHAIN (p
))
2399 /* If the last argument is __builtin_va_arg_pack () and it is not
2400 passed as a named argument, decrease the number of CALL_EXPR
2401 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2404 && TREE_CODE (CALL_EXPR_ARG (*expr_p
, nargs
- 1)) == CALL_EXPR
)
2406 tree last_arg
= CALL_EXPR_ARG (*expr_p
, nargs
- 1);
2407 tree last_arg_fndecl
= get_callee_fndecl (last_arg
);
2410 && TREE_CODE (last_arg_fndecl
) == FUNCTION_DECL
2411 && DECL_BUILT_IN_CLASS (last_arg_fndecl
) == BUILT_IN_NORMAL
2412 && DECL_FUNCTION_CODE (last_arg_fndecl
) == BUILT_IN_VA_ARG_PACK
)
2414 tree call
= *expr_p
;
2417 *expr_p
= build_call_array_loc (loc
, TREE_TYPE (call
),
2418 CALL_EXPR_FN (call
),
2419 nargs
, CALL_EXPR_ARGP (call
));
2421 /* Copy all CALL_EXPR flags, location and block, except
2422 CALL_EXPR_VA_ARG_PACK flag. */
2423 CALL_EXPR_STATIC_CHAIN (*expr_p
) = CALL_EXPR_STATIC_CHAIN (call
);
2424 CALL_EXPR_TAILCALL (*expr_p
) = CALL_EXPR_TAILCALL (call
);
2425 CALL_EXPR_RETURN_SLOT_OPT (*expr_p
)
2426 = CALL_EXPR_RETURN_SLOT_OPT (call
);
2427 CALL_FROM_THUNK_P (*expr_p
) = CALL_FROM_THUNK_P (call
);
2428 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (call
));
2430 /* Set CALL_EXPR_VA_ARG_PACK. */
2431 CALL_EXPR_VA_ARG_PACK (*expr_p
) = 1;
2435 /* Finally, gimplify the function arguments. */
2438 for (i
= (PUSH_ARGS_REVERSED
? nargs
- 1 : 0);
2439 PUSH_ARGS_REVERSED
? i
>= 0 : i
< nargs
;
2440 PUSH_ARGS_REVERSED
? i
-- : i
++)
2442 enum gimplify_status t
;
2444 /* Avoid gimplifying the second argument to va_start, which needs to
2445 be the plain PARM_DECL. */
2446 if ((i
!= 1) || !builtin_va_start_p
)
2448 t
= gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
2449 EXPR_LOCATION (*expr_p
));
2457 /* Verify the function result. */
2458 if (want_value
&& fndecl
2459 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype
))))
2461 error_at (loc
, "using result of function returning %<void%>");
2465 /* Try this again in case gimplification exposed something. */
2466 if (ret
!= GS_ERROR
)
2468 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2470 if (new_tree
&& new_tree
!= *expr_p
)
2472 /* There was a transformation of this call which computes the
2473 same value, but in a more efficient way. Return and try
2481 *expr_p
= error_mark_node
;
2485 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2486 decl. This allows us to eliminate redundant or useless
2487 calls to "const" functions. */
2488 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
2490 int flags
= call_expr_flags (*expr_p
);
2491 if (flags
& (ECF_CONST
| ECF_PURE
)
2492 /* An infinite loop is considered a side effect. */
2493 && !(flags
& (ECF_LOOPING_CONST_OR_PURE
)))
2494 TREE_SIDE_EFFECTS (*expr_p
) = 0;
2497 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2498 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2499 form and delegate the creation of a GIMPLE_CALL to
2500 gimplify_modify_expr. This is always possible because when
2501 WANT_VALUE is true, the caller wants the result of this call into
2502 a temporary, which means that we will emit an INIT_EXPR in
2503 internal_get_tmp_var which will then be handled by
2504 gimplify_modify_expr. */
2507 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2508 have to do is replicate it as a GIMPLE_CALL tuple. */
2509 gimple_stmt_iterator gsi
;
2510 call
= gimple_build_call_from_tree (*expr_p
);
2511 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
2512 notice_special_calls (call
);
2513 gimplify_seq_add_stmt (pre_p
, call
);
2514 gsi
= gsi_last (*pre_p
);
2515 maybe_fold_stmt (&gsi
);
2516 *expr_p
= NULL_TREE
;
2519 /* Remember the original function type. */
2520 CALL_EXPR_FN (*expr_p
) = build1 (NOP_EXPR
, fnptrtype
,
2521 CALL_EXPR_FN (*expr_p
));
2526 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2527 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2529 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2530 condition is true or false, respectively. If null, we should generate
2531 our own to skip over the evaluation of this specific expression.
2533 LOCUS is the source location of the COND_EXPR.
2535 This function is the tree equivalent of do_jump.
2537 shortcut_cond_r should only be called by shortcut_cond_expr. */
2540 shortcut_cond_r (tree pred
, tree
*true_label_p
, tree
*false_label_p
,
2543 tree local_label
= NULL_TREE
;
2544 tree t
, expr
= NULL
;
2546 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2547 retain the shortcut semantics. Just insert the gotos here;
2548 shortcut_cond_expr will append the real blocks later. */
2549 if (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2551 location_t new_locus
;
2553 /* Turn if (a && b) into
2555 if (a); else goto no;
2556 if (b) goto yes; else goto no;
2559 if (false_label_p
== NULL
)
2560 false_label_p
= &local_label
;
2562 /* Keep the original source location on the first 'if'. */
2563 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), NULL
, false_label_p
, locus
);
2564 append_to_statement_list (t
, &expr
);
2566 /* Set the source location of the && on the second 'if'. */
2567 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2568 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2570 append_to_statement_list (t
, &expr
);
2572 else if (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2574 location_t new_locus
;
2576 /* Turn if (a || b) into
2579 if (b) goto yes; else goto no;
2582 if (true_label_p
== NULL
)
2583 true_label_p
= &local_label
;
2585 /* Keep the original source location on the first 'if'. */
2586 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), true_label_p
, NULL
, locus
);
2587 append_to_statement_list (t
, &expr
);
2589 /* Set the source location of the || on the second 'if'. */
2590 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2591 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2593 append_to_statement_list (t
, &expr
);
2595 else if (TREE_CODE (pred
) == COND_EXPR
2596 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 1)))
2597 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 2))))
2599 location_t new_locus
;
2601 /* As long as we're messing with gotos, turn if (a ? b : c) into
2603 if (b) goto yes; else goto no;
2605 if (c) goto yes; else goto no;
2607 Don't do this if one of the arms has void type, which can happen
2608 in C++ when the arm is throw. */
2610 /* Keep the original source location on the first 'if'. Set the source
2611 location of the ? on the second 'if'. */
2612 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2613 expr
= build3 (COND_EXPR
, void_type_node
, TREE_OPERAND (pred
, 0),
2614 shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
,
2615 false_label_p
, locus
),
2616 shortcut_cond_r (TREE_OPERAND (pred
, 2), true_label_p
,
2617 false_label_p
, new_locus
));
2621 expr
= build3 (COND_EXPR
, void_type_node
, pred
,
2622 build_and_jump (true_label_p
),
2623 build_and_jump (false_label_p
));
2624 SET_EXPR_LOCATION (expr
, locus
);
2629 t
= build1 (LABEL_EXPR
, void_type_node
, local_label
);
2630 append_to_statement_list (t
, &expr
);
2636 /* Given a conditional expression EXPR with short-circuit boolean
2637 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2638 predicate apart into the equivalent sequence of conditionals. */
2641 shortcut_cond_expr (tree expr
)
2643 tree pred
= TREE_OPERAND (expr
, 0);
2644 tree then_
= TREE_OPERAND (expr
, 1);
2645 tree else_
= TREE_OPERAND (expr
, 2);
2646 tree true_label
, false_label
, end_label
, t
;
2648 tree
*false_label_p
;
2649 bool emit_end
, emit_false
, jump_over_else
;
2650 bool then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2651 bool else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2653 /* First do simple transformations. */
2656 /* If there is no 'else', turn
2659 if (a) if (b) then c. */
2660 while (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2662 /* Keep the original source location on the first 'if'. */
2663 location_t locus
= EXPR_LOC_OR_LOC (expr
, input_location
);
2664 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2665 /* Set the source location of the && on the second 'if'. */
2666 if (EXPR_HAS_LOCATION (pred
))
2667 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2668 then_
= shortcut_cond_expr (expr
);
2669 then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2670 pred
= TREE_OPERAND (pred
, 0);
2671 expr
= build3 (COND_EXPR
, void_type_node
, pred
, then_
, NULL_TREE
);
2672 SET_EXPR_LOCATION (expr
, locus
);
2678 /* If there is no 'then', turn
2681 if (a); else if (b); else d. */
2682 while (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2684 /* Keep the original source location on the first 'if'. */
2685 location_t locus
= EXPR_LOC_OR_LOC (expr
, input_location
);
2686 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2687 /* Set the source location of the || on the second 'if'. */
2688 if (EXPR_HAS_LOCATION (pred
))
2689 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2690 else_
= shortcut_cond_expr (expr
);
2691 else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2692 pred
= TREE_OPERAND (pred
, 0);
2693 expr
= build3 (COND_EXPR
, void_type_node
, pred
, NULL_TREE
, else_
);
2694 SET_EXPR_LOCATION (expr
, locus
);
2698 /* If we're done, great. */
2699 if (TREE_CODE (pred
) != TRUTH_ANDIF_EXPR
2700 && TREE_CODE (pred
) != TRUTH_ORIF_EXPR
)
2703 /* Otherwise we need to mess with gotos. Change
2706 if (a); else goto no;
2709 and recursively gimplify the condition. */
2711 true_label
= false_label
= end_label
= NULL_TREE
;
2713 /* If our arms just jump somewhere, hijack those labels so we don't
2714 generate jumps to jumps. */
2717 && TREE_CODE (then_
) == GOTO_EXPR
2718 && TREE_CODE (GOTO_DESTINATION (then_
)) == LABEL_DECL
)
2720 true_label
= GOTO_DESTINATION (then_
);
2726 && TREE_CODE (else_
) == GOTO_EXPR
2727 && TREE_CODE (GOTO_DESTINATION (else_
)) == LABEL_DECL
)
2729 false_label
= GOTO_DESTINATION (else_
);
2734 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2736 true_label_p
= &true_label
;
2738 true_label_p
= NULL
;
2740 /* The 'else' branch also needs a label if it contains interesting code. */
2741 if (false_label
|| else_se
)
2742 false_label_p
= &false_label
;
2744 false_label_p
= NULL
;
2746 /* If there was nothing else in our arms, just forward the label(s). */
2747 if (!then_se
&& !else_se
)
2748 return shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2749 EXPR_LOC_OR_LOC (expr
, input_location
));
2751 /* If our last subexpression already has a terminal label, reuse it. */
2753 t
= expr_last (else_
);
2755 t
= expr_last (then_
);
2758 if (t
&& TREE_CODE (t
) == LABEL_EXPR
)
2759 end_label
= LABEL_EXPR_LABEL (t
);
2761 /* If we don't care about jumping to the 'else' branch, jump to the end
2762 if the condition is false. */
2764 false_label_p
= &end_label
;
2766 /* We only want to emit these labels if we aren't hijacking them. */
2767 emit_end
= (end_label
== NULL_TREE
);
2768 emit_false
= (false_label
== NULL_TREE
);
2770 /* We only emit the jump over the else clause if we have to--if the
2771 then clause may fall through. Otherwise we can wind up with a
2772 useless jump and a useless label at the end of gimplified code,
2773 which will cause us to think that this conditional as a whole
2774 falls through even if it doesn't. If we then inline a function
2775 which ends with such a condition, that can cause us to issue an
2776 inappropriate warning about control reaching the end of a
2777 non-void function. */
2778 jump_over_else
= block_may_fallthru (then_
);
2780 pred
= shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2781 EXPR_LOC_OR_LOC (expr
, input_location
));
2784 append_to_statement_list (pred
, &expr
);
2786 append_to_statement_list (then_
, &expr
);
2791 tree last
= expr_last (expr
);
2792 t
= build_and_jump (&end_label
);
2793 if (EXPR_HAS_LOCATION (last
))
2794 SET_EXPR_LOCATION (t
, EXPR_LOCATION (last
));
2795 append_to_statement_list (t
, &expr
);
2799 t
= build1 (LABEL_EXPR
, void_type_node
, false_label
);
2800 append_to_statement_list (t
, &expr
);
2802 append_to_statement_list (else_
, &expr
);
2804 if (emit_end
&& end_label
)
2806 t
= build1 (LABEL_EXPR
, void_type_node
, end_label
);
2807 append_to_statement_list (t
, &expr
);
2813 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2816 gimple_boolify (tree expr
)
2818 tree type
= TREE_TYPE (expr
);
2819 location_t loc
= EXPR_LOCATION (expr
);
2821 if (TREE_CODE (expr
) == NE_EXPR
2822 && TREE_CODE (TREE_OPERAND (expr
, 0)) == CALL_EXPR
2823 && integer_zerop (TREE_OPERAND (expr
, 1)))
2825 tree call
= TREE_OPERAND (expr
, 0);
2826 tree fn
= get_callee_fndecl (call
);
2828 /* For __builtin_expect ((long) (x), y) recurse into x as well
2829 if x is truth_value_p. */
2831 && DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2832 && DECL_FUNCTION_CODE (fn
) == BUILT_IN_EXPECT
2833 && call_expr_nargs (call
) == 2)
2835 tree arg
= CALL_EXPR_ARG (call
, 0);
2838 if (TREE_CODE (arg
) == NOP_EXPR
2839 && TREE_TYPE (arg
) == TREE_TYPE (call
))
2840 arg
= TREE_OPERAND (arg
, 0);
2841 if (truth_value_p (TREE_CODE (arg
)))
2843 arg
= gimple_boolify (arg
);
2844 CALL_EXPR_ARG (call
, 0)
2845 = fold_convert_loc (loc
, TREE_TYPE (call
), arg
);
2851 switch (TREE_CODE (expr
))
2853 case TRUTH_AND_EXPR
:
2855 case TRUTH_XOR_EXPR
:
2856 case TRUTH_ANDIF_EXPR
:
2857 case TRUTH_ORIF_EXPR
:
2858 /* Also boolify the arguments of truth exprs. */
2859 TREE_OPERAND (expr
, 1) = gimple_boolify (TREE_OPERAND (expr
, 1));
2862 case TRUTH_NOT_EXPR
:
2863 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
2865 /* These expressions always produce boolean results. */
2866 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
2867 TREE_TYPE (expr
) = boolean_type_node
;
2871 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (expr
, 1)))
2873 case annot_expr_ivdep_kind
:
2874 case annot_expr_no_vector_kind
:
2875 case annot_expr_vector_kind
:
2876 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
2877 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
2878 TREE_TYPE (expr
) = boolean_type_node
;
2885 if (COMPARISON_CLASS_P (expr
))
2887 /* There expressions always prduce boolean results. */
2888 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
2889 TREE_TYPE (expr
) = boolean_type_node
;
2892 /* Other expressions that get here must have boolean values, but
2893 might need to be converted to the appropriate mode. */
2894 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
2896 return fold_convert_loc (loc
, boolean_type_node
, expr
);
2900 /* Given a conditional expression *EXPR_P without side effects, gimplify
2901 its operands. New statements are inserted to PRE_P. */
2903 static enum gimplify_status
2904 gimplify_pure_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2906 tree expr
= *expr_p
, cond
;
2907 enum gimplify_status ret
, tret
;
2908 enum tree_code code
;
2910 cond
= gimple_boolify (COND_EXPR_COND (expr
));
2912 /* We need to handle && and || specially, as their gimplification
2913 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
2914 code
= TREE_CODE (cond
);
2915 if (code
== TRUTH_ANDIF_EXPR
)
2916 TREE_SET_CODE (cond
, TRUTH_AND_EXPR
);
2917 else if (code
== TRUTH_ORIF_EXPR
)
2918 TREE_SET_CODE (cond
, TRUTH_OR_EXPR
);
2919 ret
= gimplify_expr (&cond
, pre_p
, NULL
, is_gimple_condexpr
, fb_rvalue
);
2920 COND_EXPR_COND (*expr_p
) = cond
;
2922 tret
= gimplify_expr (&COND_EXPR_THEN (expr
), pre_p
, NULL
,
2923 is_gimple_val
, fb_rvalue
);
2924 ret
= MIN (ret
, tret
);
2925 tret
= gimplify_expr (&COND_EXPR_ELSE (expr
), pre_p
, NULL
,
2926 is_gimple_val
, fb_rvalue
);
2928 return MIN (ret
, tret
);
2931 /* Return true if evaluating EXPR could trap.
2932 EXPR is GENERIC, while tree_could_trap_p can be called
2936 generic_expr_could_trap_p (tree expr
)
2940 if (!expr
|| is_gimple_val (expr
))
2943 if (!EXPR_P (expr
) || tree_could_trap_p (expr
))
2946 n
= TREE_OPERAND_LENGTH (expr
);
2947 for (i
= 0; i
< n
; i
++)
2948 if (generic_expr_could_trap_p (TREE_OPERAND (expr
, i
)))
2954 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2963 The second form is used when *EXPR_P is of type void.
2965 PRE_P points to the list where side effects that must happen before
2966 *EXPR_P should be stored. */
2968 static enum gimplify_status
2969 gimplify_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
, fallback_t fallback
)
2971 tree expr
= *expr_p
;
2972 tree type
= TREE_TYPE (expr
);
2973 location_t loc
= EXPR_LOCATION (expr
);
2974 tree tmp
, arm1
, arm2
;
2975 enum gimplify_status ret
;
2976 tree label_true
, label_false
, label_cont
;
2977 bool have_then_clause_p
, have_else_clause_p
;
2979 enum tree_code pred_code
;
2980 gimple_seq seq
= NULL
;
2982 /* If this COND_EXPR has a value, copy the values into a temporary within
2984 if (!VOID_TYPE_P (type
))
2986 tree then_
= TREE_OPERAND (expr
, 1), else_
= TREE_OPERAND (expr
, 2);
2989 /* If either an rvalue is ok or we do not require an lvalue, create the
2990 temporary. But we cannot do that if the type is addressable. */
2991 if (((fallback
& fb_rvalue
) || !(fallback
& fb_lvalue
))
2992 && !TREE_ADDRESSABLE (type
))
2994 if (gimplify_ctxp
->allow_rhs_cond_expr
2995 /* If either branch has side effects or could trap, it can't be
2996 evaluated unconditionally. */
2997 && !TREE_SIDE_EFFECTS (then_
)
2998 && !generic_expr_could_trap_p (then_
)
2999 && !TREE_SIDE_EFFECTS (else_
)
3000 && !generic_expr_could_trap_p (else_
))
3001 return gimplify_pure_cond_expr (expr_p
, pre_p
);
3003 tmp
= create_tmp_var (type
, "iftmp");
3007 /* Otherwise, only create and copy references to the values. */
3010 type
= build_pointer_type (type
);
3012 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3013 then_
= build_fold_addr_expr_loc (loc
, then_
);
3015 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3016 else_
= build_fold_addr_expr_loc (loc
, else_
);
3019 = build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0), then_
, else_
);
3021 tmp
= create_tmp_var (type
, "iftmp");
3022 result
= build_simple_mem_ref_loc (loc
, tmp
);
3025 /* Build the new then clause, `tmp = then_;'. But don't build the
3026 assignment if the value is void; in C++ it can be if it's a throw. */
3027 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3028 TREE_OPERAND (expr
, 1) = build2 (MODIFY_EXPR
, type
, tmp
, then_
);
3030 /* Similarly, build the new else clause, `tmp = else_;'. */
3031 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3032 TREE_OPERAND (expr
, 2) = build2 (MODIFY_EXPR
, type
, tmp
, else_
);
3034 TREE_TYPE (expr
) = void_type_node
;
3035 recalculate_side_effects (expr
);
3037 /* Move the COND_EXPR to the prequeue. */
3038 gimplify_stmt (&expr
, pre_p
);
3044 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
3045 STRIP_TYPE_NOPS (TREE_OPERAND (expr
, 0));
3046 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == COMPOUND_EXPR
)
3047 gimplify_compound_expr (&TREE_OPERAND (expr
, 0), pre_p
, true);
3049 /* Make sure the condition has BOOLEAN_TYPE. */
3050 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3052 /* Break apart && and || conditions. */
3053 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ANDIF_EXPR
3054 || TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ORIF_EXPR
)
3056 expr
= shortcut_cond_expr (expr
);
3058 if (expr
!= *expr_p
)
3062 /* We can't rely on gimplify_expr to re-gimplify the expanded
3063 form properly, as cleanups might cause the target labels to be
3064 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3065 set up a conditional context. */
3066 gimple_push_condition ();
3067 gimplify_stmt (expr_p
, &seq
);
3068 gimple_pop_condition (pre_p
);
3069 gimple_seq_add_seq (pre_p
, seq
);
3075 /* Now do the normal gimplification. */
3077 /* Gimplify condition. */
3078 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, NULL
, is_gimple_condexpr
,
3080 if (ret
== GS_ERROR
)
3082 gcc_assert (TREE_OPERAND (expr
, 0) != NULL_TREE
);
3084 gimple_push_condition ();
3086 have_then_clause_p
= have_else_clause_p
= false;
3087 if (TREE_OPERAND (expr
, 1) != NULL
3088 && TREE_CODE (TREE_OPERAND (expr
, 1)) == GOTO_EXPR
3089 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 1))) == LABEL_DECL
3090 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 1)))
3091 == current_function_decl
)
3092 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3093 have different locations, otherwise we end up with incorrect
3094 location information on the branches. */
3096 || !EXPR_HAS_LOCATION (expr
)
3097 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 1))
3098 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 1))))
3100 label_true
= GOTO_DESTINATION (TREE_OPERAND (expr
, 1));
3101 have_then_clause_p
= true;
3104 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
3105 if (TREE_OPERAND (expr
, 2) != NULL
3106 && TREE_CODE (TREE_OPERAND (expr
, 2)) == GOTO_EXPR
3107 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 2))) == LABEL_DECL
3108 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 2)))
3109 == current_function_decl
)
3110 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3111 have different locations, otherwise we end up with incorrect
3112 location information on the branches. */
3114 || !EXPR_HAS_LOCATION (expr
)
3115 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 2))
3116 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 2))))
3118 label_false
= GOTO_DESTINATION (TREE_OPERAND (expr
, 2));
3119 have_else_clause_p
= true;
3122 label_false
= create_artificial_label (UNKNOWN_LOCATION
);
3124 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr
), &pred_code
, &arm1
,
3127 gimple_cond
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
,
3130 gimplify_seq_add_stmt (&seq
, gimple_cond
);
3131 label_cont
= NULL_TREE
;
3132 if (!have_then_clause_p
)
3134 /* For if (...) {} else { code; } put label_true after
3136 if (TREE_OPERAND (expr
, 1) == NULL_TREE
3137 && !have_else_clause_p
3138 && TREE_OPERAND (expr
, 2) != NULL_TREE
)
3139 label_cont
= label_true
;
3142 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_true
));
3143 have_then_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 1), &seq
);
3144 /* For if (...) { code; } else {} or
3145 if (...) { code; } else goto label; or
3146 if (...) { code; return; } else { ... }
3147 label_cont isn't needed. */
3148 if (!have_else_clause_p
3149 && TREE_OPERAND (expr
, 2) != NULL_TREE
3150 && gimple_seq_may_fallthru (seq
))
3153 label_cont
= create_artificial_label (UNKNOWN_LOCATION
);
3155 g
= gimple_build_goto (label_cont
);
3157 /* GIMPLE_COND's are very low level; they have embedded
3158 gotos. This particular embedded goto should not be marked
3159 with the location of the original COND_EXPR, as it would
3160 correspond to the COND_EXPR's condition, not the ELSE or the
3161 THEN arms. To avoid marking it with the wrong location, flag
3162 it as "no location". */
3163 gimple_set_do_not_emit_location (g
);
3165 gimplify_seq_add_stmt (&seq
, g
);
3169 if (!have_else_clause_p
)
3171 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_false
));
3172 have_else_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 2), &seq
);
3175 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_cont
));
3177 gimple_pop_condition (pre_p
);
3178 gimple_seq_add_seq (pre_p
, seq
);
3180 if (ret
== GS_ERROR
)
3182 else if (have_then_clause_p
|| have_else_clause_p
)
3186 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3187 expr
= TREE_OPERAND (expr
, 0);
3188 gimplify_stmt (&expr
, pre_p
);
3195 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3196 to be marked addressable.
3198 We cannot rely on such an expression being directly markable if a temporary
3199 has been created by the gimplification. In this case, we create another
3200 temporary and initialize it with a copy, which will become a store after we
3201 mark it addressable. This can happen if the front-end passed us something
3202 that it could not mark addressable yet, like a Fortran pass-by-reference
3203 parameter (int) floatvar. */
3206 prepare_gimple_addressable (tree
*expr_p
, gimple_seq
*seq_p
)
3208 while (handled_component_p (*expr_p
))
3209 expr_p
= &TREE_OPERAND (*expr_p
, 0);
3210 if (is_gimple_reg (*expr_p
))
3212 tree var
= get_initialized_tmp_var (*expr_p
, seq_p
, NULL
);
3213 DECL_GIMPLE_REG_P (var
) = 0;
3218 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3219 a call to __builtin_memcpy. */
3221 static enum gimplify_status
3222 gimplify_modify_expr_to_memcpy (tree
*expr_p
, tree size
, bool want_value
,
3225 tree t
, to
, to_ptr
, from
, from_ptr
;
3227 location_t loc
= EXPR_LOCATION (*expr_p
);
3229 to
= TREE_OPERAND (*expr_p
, 0);
3230 from
= TREE_OPERAND (*expr_p
, 1);
3232 /* Mark the RHS addressable. Beware that it may not be possible to do so
3233 directly if a temporary has been created by the gimplification. */
3234 prepare_gimple_addressable (&from
, seq_p
);
3236 mark_addressable (from
);
3237 from_ptr
= build_fold_addr_expr_loc (loc
, from
);
3238 gimplify_arg (&from_ptr
, seq_p
, loc
);
3240 mark_addressable (to
);
3241 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3242 gimplify_arg (&to_ptr
, seq_p
, loc
);
3244 t
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3246 gs
= gimple_build_call (t
, 3, to_ptr
, from_ptr
, size
);
3250 /* tmp = memcpy() */
3251 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3252 gimple_call_set_lhs (gs
, t
);
3253 gimplify_seq_add_stmt (seq_p
, gs
);
3255 *expr_p
= build_simple_mem_ref (t
);
3259 gimplify_seq_add_stmt (seq_p
, gs
);
3264 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3265 a call to __builtin_memset. In this case we know that the RHS is
3266 a CONSTRUCTOR with an empty element list. */
3268 static enum gimplify_status
3269 gimplify_modify_expr_to_memset (tree
*expr_p
, tree size
, bool want_value
,
3272 tree t
, from
, to
, to_ptr
;
3274 location_t loc
= EXPR_LOCATION (*expr_p
);
3276 /* Assert our assumptions, to abort instead of producing wrong code
3277 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3278 not be immediately exposed. */
3279 from
= TREE_OPERAND (*expr_p
, 1);
3280 if (TREE_CODE (from
) == WITH_SIZE_EXPR
)
3281 from
= TREE_OPERAND (from
, 0);
3283 gcc_assert (TREE_CODE (from
) == CONSTRUCTOR
3284 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from
)));
3287 to
= TREE_OPERAND (*expr_p
, 0);
3289 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3290 gimplify_arg (&to_ptr
, seq_p
, loc
);
3291 t
= builtin_decl_implicit (BUILT_IN_MEMSET
);
3293 gs
= gimple_build_call (t
, 3, to_ptr
, integer_zero_node
, size
);
3297 /* tmp = memset() */
3298 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3299 gimple_call_set_lhs (gs
, t
);
3300 gimplify_seq_add_stmt (seq_p
, gs
);
3302 *expr_p
= build1 (INDIRECT_REF
, TREE_TYPE (to
), t
);
3306 gimplify_seq_add_stmt (seq_p
, gs
);
3311 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3312 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3313 assignment. Return non-null if we detect a potential overlap. */
3315 struct gimplify_init_ctor_preeval_data
3317 /* The base decl of the lhs object. May be NULL, in which case we
3318 have to assume the lhs is indirect. */
3321 /* The alias set of the lhs object. */
3322 alias_set_type lhs_alias_set
;
3326 gimplify_init_ctor_preeval_1 (tree
*tp
, int *walk_subtrees
, void *xdata
)
3328 struct gimplify_init_ctor_preeval_data
*data
3329 = (struct gimplify_init_ctor_preeval_data
*) xdata
;
3332 /* If we find the base object, obviously we have overlap. */
3333 if (data
->lhs_base_decl
== t
)
3336 /* If the constructor component is indirect, determine if we have a
3337 potential overlap with the lhs. The only bits of information we
3338 have to go on at this point are addressability and alias sets. */
3339 if ((INDIRECT_REF_P (t
)
3340 || TREE_CODE (t
) == MEM_REF
)
3341 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3342 && alias_sets_conflict_p (data
->lhs_alias_set
, get_alias_set (t
)))
3345 /* If the constructor component is a call, determine if it can hide a
3346 potential overlap with the lhs through an INDIRECT_REF like above.
3347 ??? Ugh - this is completely broken. In fact this whole analysis
3348 doesn't look conservative. */
3349 if (TREE_CODE (t
) == CALL_EXPR
)
3351 tree type
, fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t
)));
3353 for (type
= TYPE_ARG_TYPES (fntype
); type
; type
= TREE_CHAIN (type
))
3354 if (POINTER_TYPE_P (TREE_VALUE (type
))
3355 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3356 && alias_sets_conflict_p (data
->lhs_alias_set
,
3358 (TREE_TYPE (TREE_VALUE (type
)))))
3362 if (IS_TYPE_OR_DECL_P (t
))
3367 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3368 force values that overlap with the lhs (as described by *DATA)
3369 into temporaries. */
3372 gimplify_init_ctor_preeval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3373 struct gimplify_init_ctor_preeval_data
*data
)
3375 enum gimplify_status one
;
3377 /* If the value is constant, then there's nothing to pre-evaluate. */
3378 if (TREE_CONSTANT (*expr_p
))
3380 /* Ensure it does not have side effects, it might contain a reference to
3381 the object we're initializing. */
3382 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p
));
3386 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3387 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p
)))
3390 /* Recurse for nested constructors. */
3391 if (TREE_CODE (*expr_p
) == CONSTRUCTOR
)
3393 unsigned HOST_WIDE_INT ix
;
3394 constructor_elt
*ce
;
3395 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (*expr_p
);
3397 FOR_EACH_VEC_SAFE_ELT (v
, ix
, ce
)
3398 gimplify_init_ctor_preeval (&ce
->value
, pre_p
, post_p
, data
);
3403 /* If this is a variable sized type, we must remember the size. */
3404 maybe_with_size_expr (expr_p
);
3406 /* Gimplify the constructor element to something appropriate for the rhs
3407 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3408 the gimplifier will consider this a store to memory. Doing this
3409 gimplification now means that we won't have to deal with complicated
3410 language-specific trees, nor trees like SAVE_EXPR that can induce
3411 exponential search behavior. */
3412 one
= gimplify_expr (expr_p
, pre_p
, post_p
, is_gimple_mem_rhs
, fb_rvalue
);
3413 if (one
== GS_ERROR
)
3419 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3420 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3421 always be true for all scalars, since is_gimple_mem_rhs insists on a
3422 temporary variable for them. */
3423 if (DECL_P (*expr_p
))
3426 /* If this is of variable size, we have no choice but to assume it doesn't
3427 overlap since we can't make a temporary for it. */
3428 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p
))) != INTEGER_CST
)
3431 /* Otherwise, we must search for overlap ... */
3432 if (!walk_tree (expr_p
, gimplify_init_ctor_preeval_1
, data
, NULL
))
3435 /* ... and if found, force the value into a temporary. */
3436 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
3439 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3440 a RANGE_EXPR in a CONSTRUCTOR for an array.
3444 object[var] = value;
3451 We increment var _after_ the loop exit check because we might otherwise
3452 fail if upper == TYPE_MAX_VALUE (type for upper).
3454 Note that we never have to deal with SAVE_EXPRs here, because this has
3455 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3457 static void gimplify_init_ctor_eval (tree
, vec
<constructor_elt
, va_gc
> *,
3458 gimple_seq
*, bool);
3461 gimplify_init_ctor_eval_range (tree object
, tree lower
, tree upper
,
3462 tree value
, tree array_elt_type
,
3463 gimple_seq
*pre_p
, bool cleared
)
3465 tree loop_entry_label
, loop_exit_label
, fall_thru_label
;
3466 tree var
, var_type
, cref
, tmp
;
3468 loop_entry_label
= create_artificial_label (UNKNOWN_LOCATION
);
3469 loop_exit_label
= create_artificial_label (UNKNOWN_LOCATION
);
3470 fall_thru_label
= create_artificial_label (UNKNOWN_LOCATION
);
3472 /* Create and initialize the index variable. */
3473 var_type
= TREE_TYPE (upper
);
3474 var
= create_tmp_var (var_type
, NULL
);
3475 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, lower
));
3477 /* Add the loop entry label. */
3478 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_entry_label
));
3480 /* Build the reference. */
3481 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3482 var
, NULL_TREE
, NULL_TREE
);
3484 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3485 the store. Otherwise just assign value to the reference. */
3487 if (TREE_CODE (value
) == CONSTRUCTOR
)
3488 /* NB we might have to call ourself recursively through
3489 gimplify_init_ctor_eval if the value is a constructor. */
3490 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3493 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (cref
, value
));
3495 /* We exit the loop when the index var is equal to the upper bound. */
3496 gimplify_seq_add_stmt (pre_p
,
3497 gimple_build_cond (EQ_EXPR
, var
, upper
,
3498 loop_exit_label
, fall_thru_label
));
3500 gimplify_seq_add_stmt (pre_p
, gimple_build_label (fall_thru_label
));
3502 /* Otherwise, increment the index var... */
3503 tmp
= build2 (PLUS_EXPR
, var_type
, var
,
3504 fold_convert (var_type
, integer_one_node
));
3505 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, tmp
));
3507 /* ...and jump back to the loop entry. */
3508 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (loop_entry_label
));
3510 /* Add the loop exit label. */
3511 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_exit_label
));
3514 /* Return true if FDECL is accessing a field that is zero sized. */
3517 zero_sized_field_decl (const_tree fdecl
)
3519 if (TREE_CODE (fdecl
) == FIELD_DECL
&& DECL_SIZE (fdecl
)
3520 && integer_zerop (DECL_SIZE (fdecl
)))
3525 /* Return true if TYPE is zero sized. */
3528 zero_sized_type (const_tree type
)
3530 if (AGGREGATE_TYPE_P (type
) && TYPE_SIZE (type
)
3531 && integer_zerop (TYPE_SIZE (type
)))
3536 /* A subroutine of gimplify_init_constructor. Generate individual
3537 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3538 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3539 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3543 gimplify_init_ctor_eval (tree object
, vec
<constructor_elt
, va_gc
> *elts
,
3544 gimple_seq
*pre_p
, bool cleared
)
3546 tree array_elt_type
= NULL
;
3547 unsigned HOST_WIDE_INT ix
;
3548 tree purpose
, value
;
3550 if (TREE_CODE (TREE_TYPE (object
)) == ARRAY_TYPE
)
3551 array_elt_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object
)));
3553 FOR_EACH_CONSTRUCTOR_ELT (elts
, ix
, purpose
, value
)
3557 /* NULL values are created above for gimplification errors. */
3561 if (cleared
&& initializer_zerop (value
))
3564 /* ??? Here's to hoping the front end fills in all of the indices,
3565 so we don't have to figure out what's missing ourselves. */
3566 gcc_assert (purpose
);
3568 /* Skip zero-sized fields, unless value has side-effects. This can
3569 happen with calls to functions returning a zero-sized type, which
3570 we shouldn't discard. As a number of downstream passes don't
3571 expect sets of zero-sized fields, we rely on the gimplification of
3572 the MODIFY_EXPR we make below to drop the assignment statement. */
3573 if (! TREE_SIDE_EFFECTS (value
) && zero_sized_field_decl (purpose
))
3576 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3578 if (TREE_CODE (purpose
) == RANGE_EXPR
)
3580 tree lower
= TREE_OPERAND (purpose
, 0);
3581 tree upper
= TREE_OPERAND (purpose
, 1);
3583 /* If the lower bound is equal to upper, just treat it as if
3584 upper was the index. */
3585 if (simple_cst_equal (lower
, upper
))
3589 gimplify_init_ctor_eval_range (object
, lower
, upper
, value
,
3590 array_elt_type
, pre_p
, cleared
);
3597 /* Do not use bitsizetype for ARRAY_REF indices. */
3598 if (TYPE_DOMAIN (TREE_TYPE (object
)))
3600 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object
))),
3602 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3603 purpose
, NULL_TREE
, NULL_TREE
);
3607 gcc_assert (TREE_CODE (purpose
) == FIELD_DECL
);
3608 cref
= build3 (COMPONENT_REF
, TREE_TYPE (purpose
),
3609 unshare_expr (object
), purpose
, NULL_TREE
);
3612 if (TREE_CODE (value
) == CONSTRUCTOR
3613 && TREE_CODE (TREE_TYPE (value
)) != VECTOR_TYPE
)
3614 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3618 tree init
= build2 (INIT_EXPR
, TREE_TYPE (cref
), cref
, value
);
3619 gimplify_and_add (init
, pre_p
);
3625 /* Return the appropriate RHS predicate for this LHS. */
3628 rhs_predicate_for (tree lhs
)
3630 if (is_gimple_reg (lhs
))
3631 return is_gimple_reg_rhs_or_call
;
3633 return is_gimple_mem_rhs_or_call
;
3636 /* Gimplify a C99 compound literal expression. This just means adding
3637 the DECL_EXPR before the current statement and using its anonymous
3640 static enum gimplify_status
3641 gimplify_compound_literal_expr (tree
*expr_p
, gimple_seq
*pre_p
,
3642 bool (*gimple_test_f
) (tree
),
3643 fallback_t fallback
)
3645 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p
);
3646 tree decl
= DECL_EXPR_DECL (decl_s
);
3647 tree init
= DECL_INITIAL (decl
);
3648 /* Mark the decl as addressable if the compound literal
3649 expression is addressable now, otherwise it is marked too late
3650 after we gimplify the initialization expression. */
3651 if (TREE_ADDRESSABLE (*expr_p
))
3652 TREE_ADDRESSABLE (decl
) = 1;
3653 /* Otherwise, if we don't need an lvalue and have a literal directly
3654 substitute it. Check if it matches the gimple predicate, as
3655 otherwise we'd generate a new temporary, and we can as well just
3656 use the decl we already have. */
3657 else if (!TREE_ADDRESSABLE (decl
)
3659 && (fallback
& fb_lvalue
) == 0
3660 && gimple_test_f (init
))
3666 /* Preliminarily mark non-addressed complex variables as eligible
3667 for promotion to gimple registers. We'll transform their uses
3669 if ((TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
3670 || TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
)
3671 && !TREE_THIS_VOLATILE (decl
)
3672 && !needs_to_live_in_memory (decl
))
3673 DECL_GIMPLE_REG_P (decl
) = 1;
3675 /* If the decl is not addressable, then it is being used in some
3676 expression or on the right hand side of a statement, and it can
3677 be put into a readonly data section. */
3678 if (!TREE_ADDRESSABLE (decl
) && (fallback
& fb_lvalue
) == 0)
3679 TREE_READONLY (decl
) = 1;
3681 /* This decl isn't mentioned in the enclosing block, so add it to the
3682 list of temps. FIXME it seems a bit of a kludge to say that
3683 anonymous artificial vars aren't pushed, but everything else is. */
3684 if (DECL_NAME (decl
) == NULL_TREE
&& !DECL_SEEN_IN_BIND_EXPR_P (decl
))
3685 gimple_add_tmp_var (decl
);
3687 gimplify_and_add (decl_s
, pre_p
);
3692 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3693 return a new CONSTRUCTOR if something changed. */
3696 optimize_compound_literals_in_ctor (tree orig_ctor
)
3698 tree ctor
= orig_ctor
;
3699 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
3700 unsigned int idx
, num
= vec_safe_length (elts
);
3702 for (idx
= 0; idx
< num
; idx
++)
3704 tree value
= (*elts
)[idx
].value
;
3705 tree newval
= value
;
3706 if (TREE_CODE (value
) == CONSTRUCTOR
)
3707 newval
= optimize_compound_literals_in_ctor (value
);
3708 else if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
3710 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (value
);
3711 tree decl
= DECL_EXPR_DECL (decl_s
);
3712 tree init
= DECL_INITIAL (decl
);
3714 if (!TREE_ADDRESSABLE (value
)
3715 && !TREE_ADDRESSABLE (decl
)
3717 && TREE_CODE (init
) == CONSTRUCTOR
)
3718 newval
= optimize_compound_literals_in_ctor (init
);
3720 if (newval
== value
)
3723 if (ctor
== orig_ctor
)
3725 ctor
= copy_node (orig_ctor
);
3726 CONSTRUCTOR_ELTS (ctor
) = vec_safe_copy (elts
);
3727 elts
= CONSTRUCTOR_ELTS (ctor
);
3729 (*elts
)[idx
].value
= newval
;
3734 /* A subroutine of gimplify_modify_expr. Break out elements of a
3735 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3737 Note that we still need to clear any elements that don't have explicit
3738 initializers, so if not all elements are initialized we keep the
3739 original MODIFY_EXPR, we just remove all of the constructor elements.
3741 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3742 GS_ERROR if we would have to create a temporary when gimplifying
3743 this constructor. Otherwise, return GS_OK.
3745 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3747 static enum gimplify_status
3748 gimplify_init_constructor (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3749 bool want_value
, bool notify_temp_creation
)
3751 tree object
, ctor
, type
;
3752 enum gimplify_status ret
;
3753 vec
<constructor_elt
, va_gc
> *elts
;
3755 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == CONSTRUCTOR
);
3757 if (!notify_temp_creation
)
3759 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
3760 is_gimple_lvalue
, fb_lvalue
);
3761 if (ret
== GS_ERROR
)
3765 object
= TREE_OPERAND (*expr_p
, 0);
3766 ctor
= TREE_OPERAND (*expr_p
, 1) =
3767 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p
, 1));
3768 type
= TREE_TYPE (ctor
);
3769 elts
= CONSTRUCTOR_ELTS (ctor
);
3772 switch (TREE_CODE (type
))
3776 case QUAL_UNION_TYPE
:
3779 struct gimplify_init_ctor_preeval_data preeval_data
;
3780 HOST_WIDE_INT num_ctor_elements
, num_nonzero_elements
;
3781 bool cleared
, complete_p
, valid_const_initializer
;
3783 /* Aggregate types must lower constructors to initialization of
3784 individual elements. The exception is that a CONSTRUCTOR node
3785 with no elements indicates zero-initialization of the whole. */
3786 if (vec_safe_is_empty (elts
))
3788 if (notify_temp_creation
)
3793 /* Fetch information about the constructor to direct later processing.
3794 We might want to make static versions of it in various cases, and
3795 can only do so if it known to be a valid constant initializer. */
3796 valid_const_initializer
3797 = categorize_ctor_elements (ctor
, &num_nonzero_elements
,
3798 &num_ctor_elements
, &complete_p
);
3800 /* If a const aggregate variable is being initialized, then it
3801 should never be a lose to promote the variable to be static. */
3802 if (valid_const_initializer
3803 && num_nonzero_elements
> 1
3804 && TREE_READONLY (object
)
3805 && TREE_CODE (object
) == VAR_DECL
3806 && (flag_merge_constants
>= 2 || !TREE_ADDRESSABLE (object
)))
3808 if (notify_temp_creation
)
3810 DECL_INITIAL (object
) = ctor
;
3811 TREE_STATIC (object
) = 1;
3812 if (!DECL_NAME (object
))
3813 DECL_NAME (object
) = create_tmp_var_name ("C");
3814 walk_tree (&DECL_INITIAL (object
), force_labels_r
, NULL
, NULL
);
3816 /* ??? C++ doesn't automatically append a .<number> to the
3817 assembler name, and even when it does, it looks at FE private
3818 data structures to figure out what that number should be,
3819 which are not set for this variable. I suppose this is
3820 important for local statics for inline functions, which aren't
3821 "local" in the object file sense. So in order to get a unique
3822 TU-local symbol, we must invoke the lhd version now. */
3823 lhd_set_decl_assembler_name (object
);
3825 *expr_p
= NULL_TREE
;
3829 /* If there are "lots" of initialized elements, even discounting
3830 those that are not address constants (and thus *must* be
3831 computed at runtime), then partition the constructor into
3832 constant and non-constant parts. Block copy the constant
3833 parts in, then generate code for the non-constant parts. */
3834 /* TODO. There's code in cp/typeck.c to do this. */
3836 if (int_size_in_bytes (TREE_TYPE (ctor
)) < 0)
3837 /* store_constructor will ignore the clearing of variable-sized
3838 objects. Initializers for such objects must explicitly set
3839 every field that needs to be set. */
3841 else if (!complete_p
&& !CONSTRUCTOR_NO_CLEARING (ctor
))
3842 /* If the constructor isn't complete, clear the whole object
3843 beforehand, unless CONSTRUCTOR_NO_CLEARING is set on it.
3845 ??? This ought not to be needed. For any element not present
3846 in the initializer, we should simply set them to zero. Except
3847 we'd need to *find* the elements that are not present, and that
3848 requires trickery to avoid quadratic compile-time behavior in
3849 large cases or excessive memory use in small cases. */
3851 else if (num_ctor_elements
- num_nonzero_elements
3852 > CLEAR_RATIO (optimize_function_for_speed_p (cfun
))
3853 && num_nonzero_elements
< num_ctor_elements
/ 4)
3854 /* If there are "lots" of zeros, it's more efficient to clear
3855 the memory and then set the nonzero elements. */
3860 /* If there are "lots" of initialized elements, and all of them
3861 are valid address constants, then the entire initializer can
3862 be dropped to memory, and then memcpy'd out. Don't do this
3863 for sparse arrays, though, as it's more efficient to follow
3864 the standard CONSTRUCTOR behavior of memset followed by
3865 individual element initialization. Also don't do this for small
3866 all-zero initializers (which aren't big enough to merit
3867 clearing), and don't try to make bitwise copies of
3868 TREE_ADDRESSABLE types.
3870 We cannot apply such transformation when compiling chkp static
3871 initializer because creation of initializer image in the memory
3872 will require static initialization of bounds for it. It should
3873 result in another gimplification of similar initializer and we
3874 may fall into infinite loop. */
3875 if (valid_const_initializer
3876 && !(cleared
|| num_nonzero_elements
== 0)
3877 && !TREE_ADDRESSABLE (type
)
3878 && (!current_function_decl
3879 || !lookup_attribute ("chkp ctor",
3880 DECL_ATTRIBUTES (current_function_decl
))))
3882 HOST_WIDE_INT size
= int_size_in_bytes (type
);
3885 /* ??? We can still get unbounded array types, at least
3886 from the C++ front end. This seems wrong, but attempt
3887 to work around it for now. */
3890 size
= int_size_in_bytes (TREE_TYPE (object
));
3892 TREE_TYPE (ctor
) = type
= TREE_TYPE (object
);
3895 /* Find the maximum alignment we can assume for the object. */
3896 /* ??? Make use of DECL_OFFSET_ALIGN. */
3897 if (DECL_P (object
))
3898 align
= DECL_ALIGN (object
);
3900 align
= TYPE_ALIGN (type
);
3902 /* Do a block move either if the size is so small as to make
3903 each individual move a sub-unit move on average, or if it
3904 is so large as to make individual moves inefficient. */
3906 && num_nonzero_elements
> 1
3907 && (size
< num_nonzero_elements
3908 || !can_move_by_pieces (size
, align
)))
3910 if (notify_temp_creation
)
3913 walk_tree (&ctor
, force_labels_r
, NULL
, NULL
);
3914 ctor
= tree_output_constant_def (ctor
);
3915 if (!useless_type_conversion_p (type
, TREE_TYPE (ctor
)))
3916 ctor
= build1 (VIEW_CONVERT_EXPR
, type
, ctor
);
3917 TREE_OPERAND (*expr_p
, 1) = ctor
;
3919 /* This is no longer an assignment of a CONSTRUCTOR, but
3920 we still may have processing to do on the LHS. So
3921 pretend we didn't do anything here to let that happen. */
3922 return GS_UNHANDLED
;
3926 /* If the target is volatile, we have non-zero elements and more than
3927 one field to assign, initialize the target from a temporary. */
3928 if (TREE_THIS_VOLATILE (object
)
3929 && !TREE_ADDRESSABLE (type
)
3930 && num_nonzero_elements
> 0
3931 && vec_safe_length (elts
) > 1)
3933 tree temp
= create_tmp_var (TYPE_MAIN_VARIANT (type
), NULL
);
3934 TREE_OPERAND (*expr_p
, 0) = temp
;
3935 *expr_p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*expr_p
),
3937 build2 (MODIFY_EXPR
, void_type_node
,
3942 if (notify_temp_creation
)
3945 /* If there are nonzero elements and if needed, pre-evaluate to capture
3946 elements overlapping with the lhs into temporaries. We must do this
3947 before clearing to fetch the values before they are zeroed-out. */
3948 if (num_nonzero_elements
> 0 && TREE_CODE (*expr_p
) != INIT_EXPR
)
3950 preeval_data
.lhs_base_decl
= get_base_address (object
);
3951 if (!DECL_P (preeval_data
.lhs_base_decl
))
3952 preeval_data
.lhs_base_decl
= NULL
;
3953 preeval_data
.lhs_alias_set
= get_alias_set (object
);
3955 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p
, 1),
3956 pre_p
, post_p
, &preeval_data
);
3961 /* Zap the CONSTRUCTOR element list, which simplifies this case.
3962 Note that we still have to gimplify, in order to handle the
3963 case of variable sized types. Avoid shared tree structures. */
3964 CONSTRUCTOR_ELTS (ctor
) = NULL
;
3965 TREE_SIDE_EFFECTS (ctor
) = 0;
3966 object
= unshare_expr (object
);
3967 gimplify_stmt (expr_p
, pre_p
);
3970 /* If we have not block cleared the object, or if there are nonzero
3971 elements in the constructor, add assignments to the individual
3972 scalar fields of the object. */
3973 if (!cleared
|| num_nonzero_elements
> 0)
3974 gimplify_init_ctor_eval (object
, elts
, pre_p
, cleared
);
3976 *expr_p
= NULL_TREE
;
3984 if (notify_temp_creation
)
3987 /* Extract the real and imaginary parts out of the ctor. */
3988 gcc_assert (elts
->length () == 2);
3989 r
= (*elts
)[0].value
;
3990 i
= (*elts
)[1].value
;
3991 if (r
== NULL
|| i
== NULL
)
3993 tree zero
= build_zero_cst (TREE_TYPE (type
));
4000 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
4001 represent creation of a complex value. */
4002 if (TREE_CONSTANT (r
) && TREE_CONSTANT (i
))
4004 ctor
= build_complex (type
, r
, i
);
4005 TREE_OPERAND (*expr_p
, 1) = ctor
;
4009 ctor
= build2 (COMPLEX_EXPR
, type
, r
, i
);
4010 TREE_OPERAND (*expr_p
, 1) = ctor
;
4011 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1),
4014 rhs_predicate_for (TREE_OPERAND (*expr_p
, 0)),
4022 unsigned HOST_WIDE_INT ix
;
4023 constructor_elt
*ce
;
4025 if (notify_temp_creation
)
4028 /* Go ahead and simplify constant constructors to VECTOR_CST. */
4029 if (TREE_CONSTANT (ctor
))
4031 bool constant_p
= true;
4034 /* Even when ctor is constant, it might contain non-*_CST
4035 elements, such as addresses or trapping values like
4036 1.0/0.0 - 1.0/0.0. Such expressions don't belong
4037 in VECTOR_CST nodes. */
4038 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
4039 if (!CONSTANT_CLASS_P (value
))
4047 TREE_OPERAND (*expr_p
, 1) = build_vector_from_ctor (type
, elts
);
4051 TREE_CONSTANT (ctor
) = 0;
4054 /* Vector types use CONSTRUCTOR all the way through gimple
4055 compilation as a general initializer. */
4056 FOR_EACH_VEC_SAFE_ELT (elts
, ix
, ce
)
4058 enum gimplify_status tret
;
4059 tret
= gimplify_expr (&ce
->value
, pre_p
, post_p
, is_gimple_val
,
4061 if (tret
== GS_ERROR
)
4064 if (!is_gimple_reg (TREE_OPERAND (*expr_p
, 0)))
4065 TREE_OPERAND (*expr_p
, 1) = get_formal_tmp_var (ctor
, pre_p
);
4070 /* So how did we get a CONSTRUCTOR for a scalar type? */
4074 if (ret
== GS_ERROR
)
4076 else if (want_value
)
4083 /* If we have gimplified both sides of the initializer but have
4084 not emitted an assignment, do so now. */
4087 tree lhs
= TREE_OPERAND (*expr_p
, 0);
4088 tree rhs
= TREE_OPERAND (*expr_p
, 1);
4089 gimple init
= gimple_build_assign (lhs
, rhs
);
4090 gimplify_seq_add_stmt (pre_p
, init
);
4098 /* Given a pointer value OP0, return a simplified version of an
4099 indirection through OP0, or NULL_TREE if no simplification is
4100 possible. This may only be applied to a rhs of an expression.
4101 Note that the resulting type may be different from the type pointed
4102 to in the sense that it is still compatible from the langhooks
4106 gimple_fold_indirect_ref_rhs (tree t
)
4108 return gimple_fold_indirect_ref (t
);
4111 /* Subroutine of gimplify_modify_expr to do simplifications of
4112 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4113 something changes. */
4115 static enum gimplify_status
4116 gimplify_modify_expr_rhs (tree
*expr_p
, tree
*from_p
, tree
*to_p
,
4117 gimple_seq
*pre_p
, gimple_seq
*post_p
,
4120 enum gimplify_status ret
= GS_UNHANDLED
;
4126 switch (TREE_CODE (*from_p
))
4129 /* If we're assigning from a read-only variable initialized with
4130 a constructor, do the direct assignment from the constructor,
4131 but only if neither source nor target are volatile since this
4132 latter assignment might end up being done on a per-field basis. */
4133 if (DECL_INITIAL (*from_p
)
4134 && TREE_READONLY (*from_p
)
4135 && !TREE_THIS_VOLATILE (*from_p
)
4136 && !TREE_THIS_VOLATILE (*to_p
)
4137 && TREE_CODE (DECL_INITIAL (*from_p
)) == CONSTRUCTOR
)
4139 tree old_from
= *from_p
;
4140 enum gimplify_status subret
;
4142 /* Move the constructor into the RHS. */
4143 *from_p
= unshare_expr (DECL_INITIAL (*from_p
));
4145 /* Let's see if gimplify_init_constructor will need to put
4147 subret
= gimplify_init_constructor (expr_p
, NULL
, NULL
,
4149 if (subret
== GS_ERROR
)
4151 /* If so, revert the change. */
4163 /* If we have code like
4167 where the type of "x" is a (possibly cv-qualified variant
4168 of "A"), treat the entire expression as identical to "x".
4169 This kind of code arises in C++ when an object is bound
4170 to a const reference, and if "x" is a TARGET_EXPR we want
4171 to take advantage of the optimization below. */
4172 bool volatile_p
= TREE_THIS_VOLATILE (*from_p
);
4173 tree t
= gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p
, 0));
4176 if (TREE_THIS_VOLATILE (t
) != volatile_p
)
4178 if (TREE_CODE_CLASS (TREE_CODE (t
)) == tcc_declaration
)
4179 t
= build_simple_mem_ref_loc (EXPR_LOCATION (*from_p
),
4180 build_fold_addr_expr (t
));
4181 if (REFERENCE_CLASS_P (t
))
4182 TREE_THIS_VOLATILE (t
) = volatile_p
;
4193 /* If we are initializing something from a TARGET_EXPR, strip the
4194 TARGET_EXPR and initialize it directly, if possible. This can't
4195 be done if the initializer is void, since that implies that the
4196 temporary is set in some non-trivial way.
4198 ??? What about code that pulls out the temp and uses it
4199 elsewhere? I think that such code never uses the TARGET_EXPR as
4200 an initializer. If I'm wrong, we'll die because the temp won't
4201 have any RTL. In that case, I guess we'll need to replace
4202 references somehow. */
4203 tree init
= TARGET_EXPR_INITIAL (*from_p
);
4206 && !VOID_TYPE_P (TREE_TYPE (init
)))
4216 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4218 gimplify_compound_expr (from_p
, pre_p
, true);
4224 /* If we already made some changes, let the front end have a
4225 crack at this before we break it down. */
4226 if (ret
!= GS_UNHANDLED
)
4228 /* If we're initializing from a CONSTRUCTOR, break this into
4229 individual MODIFY_EXPRs. */
4230 return gimplify_init_constructor (expr_p
, pre_p
, post_p
, want_value
,
4234 /* If we're assigning to a non-register type, push the assignment
4235 down into the branches. This is mandatory for ADDRESSABLE types,
4236 since we cannot generate temporaries for such, but it saves a
4237 copy in other cases as well. */
4238 if (!is_gimple_reg_type (TREE_TYPE (*from_p
)))
4240 /* This code should mirror the code in gimplify_cond_expr. */
4241 enum tree_code code
= TREE_CODE (*expr_p
);
4242 tree cond
= *from_p
;
4243 tree result
= *to_p
;
4245 ret
= gimplify_expr (&result
, pre_p
, post_p
,
4246 is_gimple_lvalue
, fb_lvalue
);
4247 if (ret
!= GS_ERROR
)
4250 if (TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
)
4251 TREE_OPERAND (cond
, 1)
4252 = build2 (code
, void_type_node
, result
,
4253 TREE_OPERAND (cond
, 1));
4254 if (TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
4255 TREE_OPERAND (cond
, 2)
4256 = build2 (code
, void_type_node
, unshare_expr (result
),
4257 TREE_OPERAND (cond
, 2));
4259 TREE_TYPE (cond
) = void_type_node
;
4260 recalculate_side_effects (cond
);
4264 gimplify_and_add (cond
, pre_p
);
4265 *expr_p
= unshare_expr (result
);
4274 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4275 return slot so that we don't generate a temporary. */
4276 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p
)
4277 && aggregate_value_p (*from_p
, *from_p
))
4281 if (!(rhs_predicate_for (*to_p
))(*from_p
))
4282 /* If we need a temporary, *to_p isn't accurate. */
4284 /* It's OK to use the return slot directly unless it's an NRV. */
4285 else if (TREE_CODE (*to_p
) == RESULT_DECL
4286 && DECL_NAME (*to_p
) == NULL_TREE
4287 && needs_to_live_in_memory (*to_p
))
4289 else if (is_gimple_reg_type (TREE_TYPE (*to_p
))
4290 || (DECL_P (*to_p
) && DECL_REGISTER (*to_p
)))
4291 /* Don't force regs into memory. */
4293 else if (TREE_CODE (*expr_p
) == INIT_EXPR
)
4294 /* It's OK to use the target directly if it's being
4297 else if (variably_modified_type_p (TREE_TYPE (*to_p
), NULL_TREE
))
4298 /* Always use the target and thus RSO for variable-sized types.
4299 GIMPLE cannot deal with a variable-sized assignment
4300 embedded in a call statement. */
4302 else if (TREE_CODE (*to_p
) != SSA_NAME
4303 && (!is_gimple_variable (*to_p
)
4304 || needs_to_live_in_memory (*to_p
)))
4305 /* Don't use the original target if it's already addressable;
4306 if its address escapes, and the called function uses the
4307 NRV optimization, a conforming program could see *to_p
4308 change before the called function returns; see c++/19317.
4309 When optimizing, the return_slot pass marks more functions
4310 as safe after we have escape info. */
4317 CALL_EXPR_RETURN_SLOT_OPT (*from_p
) = 1;
4318 mark_addressable (*to_p
);
4323 case WITH_SIZE_EXPR
:
4324 /* Likewise for calls that return an aggregate of non-constant size,
4325 since we would not be able to generate a temporary at all. */
4326 if (TREE_CODE (TREE_OPERAND (*from_p
, 0)) == CALL_EXPR
)
4328 *from_p
= TREE_OPERAND (*from_p
, 0);
4329 /* We don't change ret in this case because the
4330 WITH_SIZE_EXPR might have been added in
4331 gimplify_modify_expr, so returning GS_OK would lead to an
4337 /* If we're initializing from a container, push the initialization
4339 case CLEANUP_POINT_EXPR
:
4341 case STATEMENT_LIST
:
4343 tree wrap
= *from_p
;
4346 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_min_lval
,
4348 if (ret
!= GS_ERROR
)
4351 t
= voidify_wrapper_expr (wrap
, *expr_p
);
4352 gcc_assert (t
== *expr_p
);
4356 gimplify_and_add (wrap
, pre_p
);
4357 *expr_p
= unshare_expr (*to_p
);
4364 case COMPOUND_LITERAL_EXPR
:
4366 tree complit
= TREE_OPERAND (*expr_p
, 1);
4367 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (complit
);
4368 tree decl
= DECL_EXPR_DECL (decl_s
);
4369 tree init
= DECL_INITIAL (decl
);
4371 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4372 into struct T x = { 0, 1, 2 } if the address of the
4373 compound literal has never been taken. */
4374 if (!TREE_ADDRESSABLE (complit
)
4375 && !TREE_ADDRESSABLE (decl
)
4378 *expr_p
= copy_node (*expr_p
);
4379 TREE_OPERAND (*expr_p
, 1) = init
;
4394 /* Return true if T looks like a valid GIMPLE statement. */
4397 is_gimple_stmt (tree t
)
4399 const enum tree_code code
= TREE_CODE (t
);
4404 /* The only valid NOP_EXPR is the empty statement. */
4405 return IS_EMPTY_STMT (t
);
4409 /* These are only valid if they're void. */
4410 return TREE_TYPE (t
) == NULL
|| VOID_TYPE_P (TREE_TYPE (t
));
4416 case CASE_LABEL_EXPR
:
4417 case TRY_CATCH_EXPR
:
4418 case TRY_FINALLY_EXPR
:
4419 case EH_FILTER_EXPR
:
4422 case STATEMENT_LIST
:
4427 case OMP_DISTRIBUTE
:
4436 /* These are always void. */
4442 /* These are valid regardless of their type. */
4451 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4452 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4453 DECL_GIMPLE_REG_P set.
4455 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4456 other, unmodified part of the complex object just before the total store.
4457 As a consequence, if the object is still uninitialized, an undefined value
4458 will be loaded into a register, which may result in a spurious exception
4459 if the register is floating-point and the value happens to be a signaling
4460 NaN for example. Then the fully-fledged complex operations lowering pass
4461 followed by a DCE pass are necessary in order to fix things up. */
4463 static enum gimplify_status
4464 gimplify_modify_expr_complex_part (tree
*expr_p
, gimple_seq
*pre_p
,
4467 enum tree_code code
, ocode
;
4468 tree lhs
, rhs
, new_rhs
, other
, realpart
, imagpart
;
4470 lhs
= TREE_OPERAND (*expr_p
, 0);
4471 rhs
= TREE_OPERAND (*expr_p
, 1);
4472 code
= TREE_CODE (lhs
);
4473 lhs
= TREE_OPERAND (lhs
, 0);
4475 ocode
= code
== REALPART_EXPR
? IMAGPART_EXPR
: REALPART_EXPR
;
4476 other
= build1 (ocode
, TREE_TYPE (rhs
), lhs
);
4477 TREE_NO_WARNING (other
) = 1;
4478 other
= get_formal_tmp_var (other
, pre_p
);
4480 realpart
= code
== REALPART_EXPR
? rhs
: other
;
4481 imagpart
= code
== REALPART_EXPR
? other
: rhs
;
4483 if (TREE_CONSTANT (realpart
) && TREE_CONSTANT (imagpart
))
4484 new_rhs
= build_complex (TREE_TYPE (lhs
), realpart
, imagpart
);
4486 new_rhs
= build2 (COMPLEX_EXPR
, TREE_TYPE (lhs
), realpart
, imagpart
);
4488 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (lhs
, new_rhs
));
4489 *expr_p
= (want_value
) ? rhs
: NULL_TREE
;
4494 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4500 PRE_P points to the list where side effects that must happen before
4501 *EXPR_P should be stored.
4503 POST_P points to the list where side effects that must happen after
4504 *EXPR_P should be stored.
4506 WANT_VALUE is nonzero iff we want to use the value of this expression
4507 in another expression. */
4509 static enum gimplify_status
4510 gimplify_modify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4513 tree
*from_p
= &TREE_OPERAND (*expr_p
, 1);
4514 tree
*to_p
= &TREE_OPERAND (*expr_p
, 0);
4515 enum gimplify_status ret
= GS_UNHANDLED
;
4517 location_t loc
= EXPR_LOCATION (*expr_p
);
4518 gimple_stmt_iterator gsi
;
4520 gcc_assert (TREE_CODE (*expr_p
) == MODIFY_EXPR
4521 || TREE_CODE (*expr_p
) == INIT_EXPR
);
4523 /* Trying to simplify a clobber using normal logic doesn't work,
4524 so handle it here. */
4525 if (TREE_CLOBBER_P (*from_p
))
4527 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4528 if (ret
== GS_ERROR
)
4530 gcc_assert (!want_value
4531 && (TREE_CODE (*to_p
) == VAR_DECL
4532 || TREE_CODE (*to_p
) == MEM_REF
));
4533 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (*to_p
, *from_p
));
4538 /* Insert pointer conversions required by the middle-end that are not
4539 required by the frontend. This fixes middle-end type checking for
4540 for example gcc.dg/redecl-6.c. */
4541 if (POINTER_TYPE_P (TREE_TYPE (*to_p
)))
4543 STRIP_USELESS_TYPE_CONVERSION (*from_p
);
4544 if (!useless_type_conversion_p (TREE_TYPE (*to_p
), TREE_TYPE (*from_p
)))
4545 *from_p
= fold_convert_loc (loc
, TREE_TYPE (*to_p
), *from_p
);
4548 /* See if any simplifications can be done based on what the RHS is. */
4549 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4551 if (ret
!= GS_UNHANDLED
)
4554 /* For zero sized types only gimplify the left hand side and right hand
4555 side as statements and throw away the assignment. Do this after
4556 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4558 if (zero_sized_type (TREE_TYPE (*from_p
)) && !want_value
)
4560 gimplify_stmt (from_p
, pre_p
);
4561 gimplify_stmt (to_p
, pre_p
);
4562 *expr_p
= NULL_TREE
;
4566 /* If the value being copied is of variable width, compute the length
4567 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4568 before gimplifying any of the operands so that we can resolve any
4569 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4570 the size of the expression to be copied, not of the destination, so
4571 that is what we must do here. */
4572 maybe_with_size_expr (from_p
);
4574 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4575 if (ret
== GS_ERROR
)
4578 /* As a special case, we have to temporarily allow for assignments
4579 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4580 a toplevel statement, when gimplifying the GENERIC expression
4581 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4582 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4584 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4585 prevent gimplify_expr from trying to create a new temporary for
4586 foo's LHS, we tell it that it should only gimplify until it
4587 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4588 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4589 and all we need to do here is set 'a' to be its LHS. */
4590 ret
= gimplify_expr (from_p
, pre_p
, post_p
, rhs_predicate_for (*to_p
),
4592 if (ret
== GS_ERROR
)
4595 /* Now see if the above changed *from_p to something we handle specially. */
4596 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4598 if (ret
!= GS_UNHANDLED
)
4601 /* If we've got a variable sized assignment between two lvalues (i.e. does
4602 not involve a call), then we can make things a bit more straightforward
4603 by converting the assignment to memcpy or memset. */
4604 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
4606 tree from
= TREE_OPERAND (*from_p
, 0);
4607 tree size
= TREE_OPERAND (*from_p
, 1);
4609 if (TREE_CODE (from
) == CONSTRUCTOR
)
4610 return gimplify_modify_expr_to_memset (expr_p
, size
, want_value
, pre_p
);
4612 if (is_gimple_addressable (from
))
4615 return gimplify_modify_expr_to_memcpy (expr_p
, size
, want_value
,
4620 /* Transform partial stores to non-addressable complex variables into
4621 total stores. This allows us to use real instead of virtual operands
4622 for these variables, which improves optimization. */
4623 if ((TREE_CODE (*to_p
) == REALPART_EXPR
4624 || TREE_CODE (*to_p
) == IMAGPART_EXPR
)
4625 && is_gimple_reg (TREE_OPERAND (*to_p
, 0)))
4626 return gimplify_modify_expr_complex_part (expr_p
, pre_p
, want_value
);
4628 /* Try to alleviate the effects of the gimplification creating artificial
4629 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
4630 if (!gimplify_ctxp
->into_ssa
4631 && TREE_CODE (*from_p
) == VAR_DECL
4632 && DECL_IGNORED_P (*from_p
)
4634 && !DECL_IGNORED_P (*to_p
))
4636 if (!DECL_NAME (*from_p
) && DECL_NAME (*to_p
))
4638 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p
)));
4639 DECL_HAS_DEBUG_EXPR_P (*from_p
) = 1;
4640 SET_DECL_DEBUG_EXPR (*from_p
, *to_p
);
4643 if (want_value
&& TREE_THIS_VOLATILE (*to_p
))
4644 *from_p
= get_initialized_tmp_var (*from_p
, pre_p
, post_p
);
4646 if (TREE_CODE (*from_p
) == CALL_EXPR
)
4648 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4649 instead of a GIMPLE_ASSIGN. */
4650 if (CALL_EXPR_FN (*from_p
) == NULL_TREE
)
4652 /* Gimplify internal functions created in the FEs. */
4653 int nargs
= call_expr_nargs (*from_p
), i
;
4654 enum internal_fn ifn
= CALL_EXPR_IFN (*from_p
);
4655 auto_vec
<tree
> vargs (nargs
);
4657 for (i
= 0; i
< nargs
; i
++)
4659 gimplify_arg (&CALL_EXPR_ARG (*from_p
, i
), pre_p
,
4660 EXPR_LOCATION (*from_p
));
4661 vargs
.quick_push (CALL_EXPR_ARG (*from_p
, i
));
4663 assign
= gimple_build_call_internal_vec (ifn
, vargs
);
4664 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
4668 tree fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*from_p
));
4669 CALL_EXPR_FN (*from_p
) = TREE_OPERAND (CALL_EXPR_FN (*from_p
), 0);
4670 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p
));
4671 tree fndecl
= get_callee_fndecl (*from_p
);
4673 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
4674 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_EXPECT
4675 && call_expr_nargs (*from_p
) == 3)
4676 assign
= gimple_build_call_internal (IFN_BUILTIN_EXPECT
, 3,
4677 CALL_EXPR_ARG (*from_p
, 0),
4678 CALL_EXPR_ARG (*from_p
, 1),
4679 CALL_EXPR_ARG (*from_p
, 2));
4682 assign
= gimple_build_call_from_tree (*from_p
);
4683 gimple_call_set_fntype (assign
, TREE_TYPE (fnptrtype
));
4686 notice_special_calls (assign
);
4687 if (!gimple_call_noreturn_p (assign
))
4688 gimple_call_set_lhs (assign
, *to_p
);
4692 assign
= gimple_build_assign (*to_p
, *from_p
);
4693 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
4696 if (gimplify_ctxp
->into_ssa
&& is_gimple_reg (*to_p
))
4698 /* We should have got an SSA name from the start. */
4699 gcc_assert (TREE_CODE (*to_p
) == SSA_NAME
);
4702 gimplify_seq_add_stmt (pre_p
, assign
);
4703 gsi
= gsi_last (*pre_p
);
4704 maybe_fold_stmt (&gsi
);
4708 *expr_p
= TREE_THIS_VOLATILE (*to_p
) ? *from_p
: unshare_expr (*to_p
);
4717 /* Gimplify a comparison between two variable-sized objects. Do this
4718 with a call to BUILT_IN_MEMCMP. */
4720 static enum gimplify_status
4721 gimplify_variable_sized_compare (tree
*expr_p
)
4723 location_t loc
= EXPR_LOCATION (*expr_p
);
4724 tree op0
= TREE_OPERAND (*expr_p
, 0);
4725 tree op1
= TREE_OPERAND (*expr_p
, 1);
4726 tree t
, arg
, dest
, src
, expr
;
4728 arg
= TYPE_SIZE_UNIT (TREE_TYPE (op0
));
4729 arg
= unshare_expr (arg
);
4730 arg
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg
, op0
);
4731 src
= build_fold_addr_expr_loc (loc
, op1
);
4732 dest
= build_fold_addr_expr_loc (loc
, op0
);
4733 t
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
4734 t
= build_call_expr_loc (loc
, t
, 3, dest
, src
, arg
);
4737 = build2 (TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), t
, integer_zero_node
);
4738 SET_EXPR_LOCATION (expr
, loc
);
4744 /* Gimplify a comparison between two aggregate objects of integral scalar
4745 mode as a comparison between the bitwise equivalent scalar values. */
4747 static enum gimplify_status
4748 gimplify_scalar_mode_aggregate_compare (tree
*expr_p
)
4750 location_t loc
= EXPR_LOCATION (*expr_p
);
4751 tree op0
= TREE_OPERAND (*expr_p
, 0);
4752 tree op1
= TREE_OPERAND (*expr_p
, 1);
4754 tree type
= TREE_TYPE (op0
);
4755 tree scalar_type
= lang_hooks
.types
.type_for_mode (TYPE_MODE (type
), 1);
4757 op0
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op0
);
4758 op1
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op1
);
4761 = fold_build2_loc (loc
, TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), op0
, op1
);
4766 /* Gimplify an expression sequence. This function gimplifies each
4767 expression and rewrites the original expression with the last
4768 expression of the sequence in GIMPLE form.
4770 PRE_P points to the list where the side effects for all the
4771 expressions in the sequence will be emitted.
4773 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
4775 static enum gimplify_status
4776 gimplify_compound_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
4782 tree
*sub_p
= &TREE_OPERAND (t
, 0);
4784 if (TREE_CODE (*sub_p
) == COMPOUND_EXPR
)
4785 gimplify_compound_expr (sub_p
, pre_p
, false);
4787 gimplify_stmt (sub_p
, pre_p
);
4789 t
= TREE_OPERAND (t
, 1);
4791 while (TREE_CODE (t
) == COMPOUND_EXPR
);
4798 gimplify_stmt (expr_p
, pre_p
);
4803 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
4804 gimplify. After gimplification, EXPR_P will point to a new temporary
4805 that holds the original value of the SAVE_EXPR node.
4807 PRE_P points to the list where side effects that must happen before
4808 *EXPR_P should be stored. */
4810 static enum gimplify_status
4811 gimplify_save_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4813 enum gimplify_status ret
= GS_ALL_DONE
;
4816 gcc_assert (TREE_CODE (*expr_p
) == SAVE_EXPR
);
4817 val
= TREE_OPERAND (*expr_p
, 0);
4819 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
4820 if (!SAVE_EXPR_RESOLVED_P (*expr_p
))
4822 /* The operand may be a void-valued expression such as SAVE_EXPRs
4823 generated by the Java frontend for class initialization. It is
4824 being executed only for its side-effects. */
4825 if (TREE_TYPE (val
) == void_type_node
)
4827 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
4828 is_gimple_stmt
, fb_none
);
4832 val
= get_initialized_tmp_var (val
, pre_p
, post_p
);
4834 TREE_OPERAND (*expr_p
, 0) = val
;
4835 SAVE_EXPR_RESOLVED_P (*expr_p
) = 1;
4843 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
4850 PRE_P points to the list where side effects that must happen before
4851 *EXPR_P should be stored.
4853 POST_P points to the list where side effects that must happen after
4854 *EXPR_P should be stored. */
4856 static enum gimplify_status
4857 gimplify_addr_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4859 tree expr
= *expr_p
;
4860 tree op0
= TREE_OPERAND (expr
, 0);
4861 enum gimplify_status ret
;
4862 location_t loc
= EXPR_LOCATION (*expr_p
);
4864 switch (TREE_CODE (op0
))
4868 /* Check if we are dealing with an expression of the form '&*ptr'.
4869 While the front end folds away '&*ptr' into 'ptr', these
4870 expressions may be generated internally by the compiler (e.g.,
4871 builtins like __builtin_va_end). */
4872 /* Caution: the silent array decomposition semantics we allow for
4873 ADDR_EXPR means we can't always discard the pair. */
4874 /* Gimplification of the ADDR_EXPR operand may drop
4875 cv-qualification conversions, so make sure we add them if
4878 tree op00
= TREE_OPERAND (op0
, 0);
4879 tree t_expr
= TREE_TYPE (expr
);
4880 tree t_op00
= TREE_TYPE (op00
);
4882 if (!useless_type_conversion_p (t_expr
, t_op00
))
4883 op00
= fold_convert_loc (loc
, TREE_TYPE (expr
), op00
);
4889 case VIEW_CONVERT_EXPR
:
4890 /* Take the address of our operand and then convert it to the type of
4893 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
4894 all clear. The impact of this transformation is even less clear. */
4896 /* If the operand is a useless conversion, look through it. Doing so
4897 guarantees that the ADDR_EXPR and its operand will remain of the
4899 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0
, 0)))
4900 op0
= TREE_OPERAND (op0
, 0);
4902 *expr_p
= fold_convert_loc (loc
, TREE_TYPE (expr
),
4903 build_fold_addr_expr_loc (loc
,
4904 TREE_OPERAND (op0
, 0)));
4909 /* We use fb_either here because the C frontend sometimes takes
4910 the address of a call that returns a struct; see
4911 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
4912 the implied temporary explicit. */
4914 /* Make the operand addressable. */
4915 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, post_p
,
4916 is_gimple_addressable
, fb_either
);
4917 if (ret
== GS_ERROR
)
4920 /* Then mark it. Beware that it may not be possible to do so directly
4921 if a temporary has been created by the gimplification. */
4922 prepare_gimple_addressable (&TREE_OPERAND (expr
, 0), pre_p
);
4924 op0
= TREE_OPERAND (expr
, 0);
4926 /* For various reasons, the gimplification of the expression
4927 may have made a new INDIRECT_REF. */
4928 if (TREE_CODE (op0
) == INDIRECT_REF
)
4929 goto do_indirect_ref
;
4931 mark_addressable (TREE_OPERAND (expr
, 0));
4933 /* The FEs may end up building ADDR_EXPRs early on a decl with
4934 an incomplete type. Re-build ADDR_EXPRs in canonical form
4936 if (!types_compatible_p (TREE_TYPE (op0
), TREE_TYPE (TREE_TYPE (expr
))))
4937 *expr_p
= build_fold_addr_expr (op0
);
4939 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
4940 recompute_tree_invariant_for_addr_expr (*expr_p
);
4942 /* If we re-built the ADDR_EXPR add a conversion to the original type
4944 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
4945 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
4953 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
4954 value; output operands should be a gimple lvalue. */
4956 static enum gimplify_status
4957 gimplify_asm_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4961 const char **oconstraints
;
4964 const char *constraint
;
4965 bool allows_mem
, allows_reg
, is_inout
;
4966 enum gimplify_status ret
, tret
;
4968 vec
<tree
, va_gc
> *inputs
;
4969 vec
<tree
, va_gc
> *outputs
;
4970 vec
<tree
, va_gc
> *clobbers
;
4971 vec
<tree
, va_gc
> *labels
;
4975 noutputs
= list_length (ASM_OUTPUTS (expr
));
4976 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
4984 link_next
= NULL_TREE
;
4985 for (i
= 0, link
= ASM_OUTPUTS (expr
); link
; ++i
, link
= link_next
)
4988 size_t constraint_len
;
4990 link_next
= TREE_CHAIN (link
);
4994 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
4995 constraint_len
= strlen (constraint
);
4996 if (constraint_len
== 0)
4999 ok
= parse_output_constraint (&constraint
, i
, 0, 0,
5000 &allows_mem
, &allows_reg
, &is_inout
);
5007 if (!allows_reg
&& allows_mem
)
5008 mark_addressable (TREE_VALUE (link
));
5010 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5011 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
5012 fb_lvalue
| fb_mayfail
);
5013 if (tret
== GS_ERROR
)
5015 error ("invalid lvalue in asm output %d", i
);
5019 vec_safe_push (outputs
, link
);
5020 TREE_CHAIN (link
) = NULL_TREE
;
5024 /* An input/output operand. To give the optimizers more
5025 flexibility, split it into separate input and output
5030 /* Turn the in/out constraint into an output constraint. */
5031 char *p
= xstrdup (constraint
);
5033 TREE_VALUE (TREE_PURPOSE (link
)) = build_string (constraint_len
, p
);
5035 /* And add a matching input constraint. */
5038 sprintf (buf
, "%d", i
);
5040 /* If there are multiple alternatives in the constraint,
5041 handle each of them individually. Those that allow register
5042 will be replaced with operand number, the others will stay
5044 if (strchr (p
, ',') != NULL
)
5046 size_t len
= 0, buflen
= strlen (buf
);
5047 char *beg
, *end
, *str
, *dst
;
5051 end
= strchr (beg
, ',');
5053 end
= strchr (beg
, '\0');
5054 if ((size_t) (end
- beg
) < buflen
)
5057 len
+= end
- beg
+ 1;
5064 str
= (char *) alloca (len
);
5065 for (beg
= p
+ 1, dst
= str
;;)
5068 bool mem_p
, reg_p
, inout_p
;
5070 end
= strchr (beg
, ',');
5075 parse_output_constraint (&tem
, i
, 0, 0,
5076 &mem_p
, ®_p
, &inout_p
);
5081 memcpy (dst
, buf
, buflen
);
5090 memcpy (dst
, beg
, len
);
5099 input
= build_string (dst
- str
, str
);
5102 input
= build_string (strlen (buf
), buf
);
5105 input
= build_string (constraint_len
- 1, constraint
+ 1);
5109 input
= build_tree_list (build_tree_list (NULL_TREE
, input
),
5110 unshare_expr (TREE_VALUE (link
)));
5111 ASM_INPUTS (expr
) = chainon (ASM_INPUTS (expr
), input
);
5115 link_next
= NULL_TREE
;
5116 for (link
= ASM_INPUTS (expr
); link
; ++i
, link
= link_next
)
5118 link_next
= TREE_CHAIN (link
);
5119 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5120 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
5121 oconstraints
, &allows_mem
, &allows_reg
);
5123 /* If we can't make copies, we can only accept memory. */
5124 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link
))))
5130 error ("impossible constraint in %<asm%>");
5131 error ("non-memory input %d must stay in memory", i
);
5136 /* If the operand is a memory input, it should be an lvalue. */
5137 if (!allows_reg
&& allows_mem
)
5139 tree inputv
= TREE_VALUE (link
);
5140 STRIP_NOPS (inputv
);
5141 if (TREE_CODE (inputv
) == PREDECREMENT_EXPR
5142 || TREE_CODE (inputv
) == PREINCREMENT_EXPR
5143 || TREE_CODE (inputv
) == POSTDECREMENT_EXPR
5144 || TREE_CODE (inputv
) == POSTINCREMENT_EXPR
)
5145 TREE_VALUE (link
) = error_mark_node
;
5146 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5147 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
5148 mark_addressable (TREE_VALUE (link
));
5149 if (tret
== GS_ERROR
)
5151 if (EXPR_HAS_LOCATION (TREE_VALUE (link
)))
5152 input_location
= EXPR_LOCATION (TREE_VALUE (link
));
5153 error ("memory input %d is not directly addressable", i
);
5159 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5160 is_gimple_asm_val
, fb_rvalue
);
5161 if (tret
== GS_ERROR
)
5165 TREE_CHAIN (link
) = NULL_TREE
;
5166 vec_safe_push (inputs
, link
);
5169 link_next
= NULL_TREE
;
5170 for (link
= ASM_CLOBBERS (expr
); link
; ++i
, link
= link_next
)
5172 link_next
= TREE_CHAIN (link
);
5173 TREE_CHAIN (link
) = NULL_TREE
;
5174 vec_safe_push (clobbers
, link
);
5177 link_next
= NULL_TREE
;
5178 for (link
= ASM_LABELS (expr
); link
; ++i
, link
= link_next
)
5180 link_next
= TREE_CHAIN (link
);
5181 TREE_CHAIN (link
) = NULL_TREE
;
5182 vec_safe_push (labels
, link
);
5185 /* Do not add ASMs with errors to the gimple IL stream. */
5186 if (ret
!= GS_ERROR
)
5188 stmt
= gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr
)),
5189 inputs
, outputs
, clobbers
, labels
);
5191 gimple_asm_set_volatile (stmt
, ASM_VOLATILE_P (expr
));
5192 gimple_asm_set_input (stmt
, ASM_INPUT_P (expr
));
5194 gimplify_seq_add_stmt (pre_p
, stmt
);
5200 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
5201 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
5202 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
5203 return to this function.
5205 FIXME should we complexify the prequeue handling instead? Or use flags
5206 for all the cleanups and let the optimizer tighten them up? The current
5207 code seems pretty fragile; it will break on a cleanup within any
5208 non-conditional nesting. But any such nesting would be broken, anyway;
5209 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
5210 and continues out of it. We can do that at the RTL level, though, so
5211 having an optimizer to tighten up try/finally regions would be a Good
5214 static enum gimplify_status
5215 gimplify_cleanup_point_expr (tree
*expr_p
, gimple_seq
*pre_p
)
5217 gimple_stmt_iterator iter
;
5218 gimple_seq body_sequence
= NULL
;
5220 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
5222 /* We only care about the number of conditions between the innermost
5223 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5224 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5225 int old_conds
= gimplify_ctxp
->conditions
;
5226 gimple_seq old_cleanups
= gimplify_ctxp
->conditional_cleanups
;
5227 bool old_in_cleanup_point_expr
= gimplify_ctxp
->in_cleanup_point_expr
;
5228 gimplify_ctxp
->conditions
= 0;
5229 gimplify_ctxp
->conditional_cleanups
= NULL
;
5230 gimplify_ctxp
->in_cleanup_point_expr
= true;
5232 gimplify_stmt (&TREE_OPERAND (*expr_p
, 0), &body_sequence
);
5234 gimplify_ctxp
->conditions
= old_conds
;
5235 gimplify_ctxp
->conditional_cleanups
= old_cleanups
;
5236 gimplify_ctxp
->in_cleanup_point_expr
= old_in_cleanup_point_expr
;
5238 for (iter
= gsi_start (body_sequence
); !gsi_end_p (iter
); )
5240 gimple wce
= gsi_stmt (iter
);
5242 if (gimple_code (wce
) == GIMPLE_WITH_CLEANUP_EXPR
)
5244 if (gsi_one_before_end_p (iter
))
5246 /* Note that gsi_insert_seq_before and gsi_remove do not
5247 scan operands, unlike some other sequence mutators. */
5248 if (!gimple_wce_cleanup_eh_only (wce
))
5249 gsi_insert_seq_before_without_update (&iter
,
5250 gimple_wce_cleanup (wce
),
5252 gsi_remove (&iter
, true);
5257 gimple_statement_try
*gtry
;
5259 enum gimple_try_flags kind
;
5261 if (gimple_wce_cleanup_eh_only (wce
))
5262 kind
= GIMPLE_TRY_CATCH
;
5264 kind
= GIMPLE_TRY_FINALLY
;
5265 seq
= gsi_split_seq_after (iter
);
5267 gtry
= gimple_build_try (seq
, gimple_wce_cleanup (wce
), kind
);
5268 /* Do not use gsi_replace here, as it may scan operands.
5269 We want to do a simple structural modification only. */
5270 gsi_set_stmt (&iter
, gtry
);
5271 iter
= gsi_start (gtry
->eval
);
5278 gimplify_seq_add_seq (pre_p
, body_sequence
);
5291 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5292 is the cleanup action required. EH_ONLY is true if the cleanup should
5293 only be executed if an exception is thrown, not on normal exit. */
5296 gimple_push_cleanup (tree var
, tree cleanup
, bool eh_only
, gimple_seq
*pre_p
)
5299 gimple_seq cleanup_stmts
= NULL
;
5301 /* Errors can result in improperly nested cleanups. Which results in
5302 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5306 if (gimple_conditional_context ())
5308 /* If we're in a conditional context, this is more complex. We only
5309 want to run the cleanup if we actually ran the initialization that
5310 necessitates it, but we want to run it after the end of the
5311 conditional context. So we wrap the try/finally around the
5312 condition and use a flag to determine whether or not to actually
5313 run the destructor. Thus
5317 becomes (approximately)
5321 if (test) { A::A(temp); flag = 1; val = f(temp); }
5324 if (flag) A::~A(temp);
5328 tree flag
= create_tmp_var (boolean_type_node
, "cleanup");
5329 gimple ffalse
= gimple_build_assign (flag
, boolean_false_node
);
5330 gimple ftrue
= gimple_build_assign (flag
, boolean_true_node
);
5332 cleanup
= build3 (COND_EXPR
, void_type_node
, flag
, cleanup
, NULL
);
5333 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5334 wce
= gimple_build_wce (cleanup_stmts
);
5336 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, ffalse
);
5337 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
5338 gimplify_seq_add_stmt (pre_p
, ftrue
);
5340 /* Because of this manipulation, and the EH edges that jump
5341 threading cannot redirect, the temporary (VAR) will appear
5342 to be used uninitialized. Don't warn. */
5343 TREE_NO_WARNING (var
) = 1;
5347 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5348 wce
= gimple_build_wce (cleanup_stmts
);
5349 gimple_wce_set_cleanup_eh_only (wce
, eh_only
);
5350 gimplify_seq_add_stmt (pre_p
, wce
);
5354 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5356 static enum gimplify_status
5357 gimplify_target_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5359 tree targ
= *expr_p
;
5360 tree temp
= TARGET_EXPR_SLOT (targ
);
5361 tree init
= TARGET_EXPR_INITIAL (targ
);
5362 enum gimplify_status ret
;
5366 tree cleanup
= NULL_TREE
;
5368 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5369 to the temps list. Handle also variable length TARGET_EXPRs. */
5370 if (TREE_CODE (DECL_SIZE (temp
)) != INTEGER_CST
)
5372 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp
)))
5373 gimplify_type_sizes (TREE_TYPE (temp
), pre_p
);
5374 gimplify_vla_decl (temp
, pre_p
);
5377 gimple_add_tmp_var (temp
);
5379 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5380 expression is supposed to initialize the slot. */
5381 if (VOID_TYPE_P (TREE_TYPE (init
)))
5382 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5385 tree init_expr
= build2 (INIT_EXPR
, void_type_node
, temp
, init
);
5387 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5389 ggc_free (init_expr
);
5391 if (ret
== GS_ERROR
)
5393 /* PR c++/28266 Make sure this is expanded only once. */
5394 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5398 gimplify_and_add (init
, pre_p
);
5400 /* If needed, push the cleanup for the temp. */
5401 if (TARGET_EXPR_CLEANUP (targ
))
5403 if (CLEANUP_EH_ONLY (targ
))
5404 gimple_push_cleanup (temp
, TARGET_EXPR_CLEANUP (targ
),
5405 CLEANUP_EH_ONLY (targ
), pre_p
);
5407 cleanup
= TARGET_EXPR_CLEANUP (targ
);
5410 /* Add a clobber for the temporary going out of scope, like
5411 gimplify_bind_expr. */
5412 if (gimplify_ctxp
->in_cleanup_point_expr
5413 && needs_to_live_in_memory (temp
)
5414 && flag_stack_reuse
== SR_ALL
)
5416 tree clobber
= build_constructor (TREE_TYPE (temp
),
5418 TREE_THIS_VOLATILE (clobber
) = true;
5419 clobber
= build2 (MODIFY_EXPR
, TREE_TYPE (temp
), temp
, clobber
);
5421 cleanup
= build2 (COMPOUND_EXPR
, void_type_node
, cleanup
,
5428 gimple_push_cleanup (temp
, cleanup
, false, pre_p
);
5430 /* Only expand this once. */
5431 TREE_OPERAND (targ
, 3) = init
;
5432 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5435 /* We should have expanded this before. */
5436 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp
));
5442 /* Gimplification of expression trees. */
5444 /* Gimplify an expression which appears at statement context. The
5445 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5446 NULL, a new sequence is allocated.
5448 Return true if we actually added a statement to the queue. */
5451 gimplify_stmt (tree
*stmt_p
, gimple_seq
*seq_p
)
5453 gimple_seq_node last
;
5455 last
= gimple_seq_last (*seq_p
);
5456 gimplify_expr (stmt_p
, seq_p
, NULL
, is_gimple_stmt
, fb_none
);
5457 return last
!= gimple_seq_last (*seq_p
);
5460 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5461 to CTX. If entries already exist, force them to be some flavor of private.
5462 If there is no enclosing parallel, do nothing. */
5465 omp_firstprivatize_variable (struct gimplify_omp_ctx
*ctx
, tree decl
)
5469 if (decl
== NULL
|| !DECL_P (decl
))
5474 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5477 if (n
->value
& GOVD_SHARED
)
5478 n
->value
= GOVD_FIRSTPRIVATE
| (n
->value
& GOVD_SEEN
);
5479 else if (n
->value
& GOVD_MAP
)
5480 n
->value
|= GOVD_MAP_TO_ONLY
;
5484 else if (ctx
->region_type
== ORT_TARGET
)
5485 omp_add_variable (ctx
, decl
, GOVD_MAP
| GOVD_MAP_TO_ONLY
);
5486 else if (ctx
->region_type
!= ORT_WORKSHARE
5487 && ctx
->region_type
!= ORT_SIMD
5488 && ctx
->region_type
!= ORT_TARGET_DATA
)
5489 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
5491 ctx
= ctx
->outer_context
;
5496 /* Similarly for each of the type sizes of TYPE. */
5499 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx
*ctx
, tree type
)
5501 if (type
== NULL
|| type
== error_mark_node
)
5503 type
= TYPE_MAIN_VARIANT (type
);
5505 if (ctx
->privatized_types
->add (type
))
5508 switch (TREE_CODE (type
))
5514 case FIXED_POINT_TYPE
:
5515 omp_firstprivatize_variable (ctx
, TYPE_MIN_VALUE (type
));
5516 omp_firstprivatize_variable (ctx
, TYPE_MAX_VALUE (type
));
5520 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5521 omp_firstprivatize_type_sizes (ctx
, TYPE_DOMAIN (type
));
5526 case QUAL_UNION_TYPE
:
5529 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
5530 if (TREE_CODE (field
) == FIELD_DECL
)
5532 omp_firstprivatize_variable (ctx
, DECL_FIELD_OFFSET (field
));
5533 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (field
));
5539 case REFERENCE_TYPE
:
5540 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5547 omp_firstprivatize_variable (ctx
, TYPE_SIZE (type
));
5548 omp_firstprivatize_variable (ctx
, TYPE_SIZE_UNIT (type
));
5549 lang_hooks
.types
.omp_firstprivatize_type_sizes (ctx
, type
);
5552 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
5555 omp_add_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned int flags
)
5558 unsigned int nflags
;
5561 if (error_operand_p (decl
))
5564 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5565 there are constructors involved somewhere. */
5566 if (TREE_ADDRESSABLE (TREE_TYPE (decl
))
5567 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
5570 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5571 if (n
!= NULL
&& n
->value
!= GOVD_ALIGNED
)
5573 /* We shouldn't be re-adding the decl with the same data
5575 gcc_assert ((n
->value
& GOVD_DATA_SHARE_CLASS
& flags
) == 0);
5576 /* The only combination of data sharing classes we should see is
5577 FIRSTPRIVATE and LASTPRIVATE. */
5578 nflags
= n
->value
| flags
;
5579 gcc_assert ((nflags
& GOVD_DATA_SHARE_CLASS
)
5580 == (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
)
5581 || (flags
& GOVD_DATA_SHARE_CLASS
) == 0);
5586 /* When adding a variable-sized variable, we have to handle all sorts
5587 of additional bits of data: the pointer replacement variable, and
5588 the parameters of the type. */
5589 if (DECL_SIZE (decl
) && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5591 /* Add the pointer replacement variable as PRIVATE if the variable
5592 replacement is private, else FIRSTPRIVATE since we'll need the
5593 address of the original variable either for SHARED, or for the
5594 copy into or out of the context. */
5595 if (!(flags
& GOVD_LOCAL
))
5597 nflags
= flags
& GOVD_MAP
5598 ? GOVD_MAP
| GOVD_MAP_TO_ONLY
| GOVD_EXPLICIT
5599 : flags
& GOVD_PRIVATE
? GOVD_PRIVATE
: GOVD_FIRSTPRIVATE
;
5600 nflags
|= flags
& GOVD_SEEN
;
5601 t
= DECL_VALUE_EXPR (decl
);
5602 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5603 t
= TREE_OPERAND (t
, 0);
5604 gcc_assert (DECL_P (t
));
5605 omp_add_variable (ctx
, t
, nflags
);
5608 /* Add all of the variable and type parameters (which should have
5609 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5610 omp_firstprivatize_variable (ctx
, DECL_SIZE_UNIT (decl
));
5611 omp_firstprivatize_variable (ctx
, DECL_SIZE (decl
));
5612 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5614 /* The variable-sized variable itself is never SHARED, only some form
5615 of PRIVATE. The sharing would take place via the pointer variable
5616 which we remapped above. */
5617 if (flags
& GOVD_SHARED
)
5618 flags
= GOVD_PRIVATE
| GOVD_DEBUG_PRIVATE
5619 | (flags
& (GOVD_SEEN
| GOVD_EXPLICIT
));
5621 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5622 alloca statement we generate for the variable, so make sure it
5623 is available. This isn't automatically needed for the SHARED
5624 case, since we won't be allocating local storage then.
5625 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5626 in this case omp_notice_variable will be called later
5627 on when it is gimplified. */
5628 else if (! (flags
& (GOVD_LOCAL
| GOVD_MAP
))
5629 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl
))))
5630 omp_notice_variable (ctx
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)), true);
5632 else if ((flags
& (GOVD_MAP
| GOVD_LOCAL
)) == 0
5633 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
5635 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5637 /* Similar to the direct variable sized case above, we'll need the
5638 size of references being privatized. */
5639 if ((flags
& GOVD_SHARED
) == 0)
5641 t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
5642 if (TREE_CODE (t
) != INTEGER_CST
)
5643 omp_notice_variable (ctx
, t
, true);
5650 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, flags
);
5653 /* Notice a threadprivate variable DECL used in OpenMP context CTX.
5654 This just prints out diagnostics about threadprivate variable uses
5655 in untied tasks. If DECL2 is non-NULL, prevent this warning
5656 on that variable. */
5659 omp_notice_threadprivate_variable (struct gimplify_omp_ctx
*ctx
, tree decl
,
5663 struct gimplify_omp_ctx
*octx
;
5665 for (octx
= ctx
; octx
; octx
= octx
->outer_context
)
5666 if (octx
->region_type
== ORT_TARGET
)
5668 n
= splay_tree_lookup (octx
->variables
, (splay_tree_key
)decl
);
5671 error ("threadprivate variable %qE used in target region",
5673 error_at (octx
->location
, "enclosing target region");
5674 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl
, 0);
5677 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl2
, 0);
5680 if (ctx
->region_type
!= ORT_UNTIED_TASK
)
5682 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5685 error ("threadprivate variable %qE used in untied task",
5687 error_at (ctx
->location
, "enclosing task");
5688 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, 0);
5691 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl2
, 0);
5695 /* Record the fact that DECL was used within the OpenMP context CTX.
5696 IN_CODE is true when real code uses DECL, and false when we should
5697 merely emit default(none) errors. Return true if DECL is going to
5698 be remapped and thus DECL shouldn't be gimplified into its
5699 DECL_VALUE_EXPR (if any). */
5702 omp_notice_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, bool in_code
)
5705 unsigned flags
= in_code
? GOVD_SEEN
: 0;
5706 bool ret
= false, shared
;
5708 if (error_operand_p (decl
))
5711 /* Threadprivate variables are predetermined. */
5712 if (is_global_var (decl
))
5714 if (DECL_THREAD_LOCAL_P (decl
))
5715 return omp_notice_threadprivate_variable (ctx
, decl
, NULL_TREE
);
5717 if (DECL_HAS_VALUE_EXPR_P (decl
))
5719 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
5721 if (value
&& DECL_P (value
) && DECL_THREAD_LOCAL_P (value
))
5722 return omp_notice_threadprivate_variable (ctx
, decl
, value
);
5726 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5727 if (ctx
->region_type
== ORT_TARGET
)
5729 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, true);
5732 if (!lang_hooks
.types
.omp_mappable_type (TREE_TYPE (decl
)))
5734 error ("%qD referenced in target region does not have "
5735 "a mappable type", decl
);
5736 omp_add_variable (ctx
, decl
, GOVD_MAP
| GOVD_EXPLICIT
| flags
);
5739 omp_add_variable (ctx
, decl
, GOVD_MAP
| flags
);
5743 /* If nothing changed, there's nothing left to do. */
5744 if ((n
->value
& flags
) == flags
)
5753 enum omp_clause_default_kind default_kind
, kind
;
5754 struct gimplify_omp_ctx
*octx
;
5756 if (ctx
->region_type
== ORT_WORKSHARE
5757 || ctx
->region_type
== ORT_SIMD
5758 || ctx
->region_type
== ORT_TARGET_DATA
)
5761 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
5762 remapped firstprivate instead of shared. To some extent this is
5763 addressed in omp_firstprivatize_type_sizes, but not effectively. */
5764 default_kind
= ctx
->default_kind
;
5765 kind
= lang_hooks
.decls
.omp_predetermined_sharing (decl
);
5766 if (kind
!= OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
5767 default_kind
= kind
;
5769 switch (default_kind
)
5771 case OMP_CLAUSE_DEFAULT_NONE
:
5772 if ((ctx
->region_type
& ORT_PARALLEL
) != 0)
5774 error ("%qE not specified in enclosing parallel",
5775 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5776 error_at (ctx
->location
, "enclosing parallel");
5778 else if ((ctx
->region_type
& ORT_TASK
) != 0)
5780 error ("%qE not specified in enclosing task",
5781 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5782 error_at (ctx
->location
, "enclosing task");
5784 else if (ctx
->region_type
== ORT_TEAMS
)
5786 error ("%qE not specified in enclosing teams construct",
5787 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5788 error_at (ctx
->location
, "enclosing teams construct");
5793 case OMP_CLAUSE_DEFAULT_SHARED
:
5794 flags
|= GOVD_SHARED
;
5796 case OMP_CLAUSE_DEFAULT_PRIVATE
:
5797 flags
|= GOVD_PRIVATE
;
5799 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
5800 flags
|= GOVD_FIRSTPRIVATE
;
5802 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
5803 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
5804 gcc_assert ((ctx
->region_type
& ORT_TASK
) != 0);
5805 if (ctx
->outer_context
)
5806 omp_notice_variable (ctx
->outer_context
, decl
, in_code
);
5807 for (octx
= ctx
->outer_context
; octx
; octx
= octx
->outer_context
)
5811 if ((octx
->region_type
& (ORT_TARGET_DATA
| ORT_TARGET
)) != 0)
5813 n2
= splay_tree_lookup (octx
->variables
, (splay_tree_key
) decl
);
5814 if (n2
&& (n2
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
)
5816 flags
|= GOVD_FIRSTPRIVATE
;
5819 if ((octx
->region_type
& (ORT_PARALLEL
| ORT_TEAMS
)) != 0)
5822 if (flags
& GOVD_FIRSTPRIVATE
)
5825 && (TREE_CODE (decl
) == PARM_DECL
5826 || (!is_global_var (decl
)
5827 && DECL_CONTEXT (decl
) == current_function_decl
)))
5829 flags
|= GOVD_FIRSTPRIVATE
;
5832 flags
|= GOVD_SHARED
;
5838 if ((flags
& GOVD_PRIVATE
)
5839 && lang_hooks
.decls
.omp_private_outer_ref (decl
))
5840 flags
|= GOVD_PRIVATE_OUTER_REF
;
5842 omp_add_variable (ctx
, decl
, flags
);
5844 shared
= (flags
& GOVD_SHARED
) != 0;
5845 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
5849 if ((n
->value
& (GOVD_SEEN
| GOVD_LOCAL
)) == 0
5850 && (flags
& (GOVD_SEEN
| GOVD_LOCAL
)) == GOVD_SEEN
5852 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5855 tree t
= DECL_VALUE_EXPR (decl
);
5856 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5857 t
= TREE_OPERAND (t
, 0);
5858 gcc_assert (DECL_P (t
));
5859 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
5860 n2
->value
|= GOVD_SEEN
;
5863 shared
= ((flags
| n
->value
) & GOVD_SHARED
) != 0;
5864 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
5866 /* If nothing changed, there's nothing left to do. */
5867 if ((n
->value
& flags
) == flags
)
5873 /* If the variable is private in the current context, then we don't
5874 need to propagate anything to an outer context. */
5875 if ((flags
& GOVD_PRIVATE
) && !(flags
& GOVD_PRIVATE_OUTER_REF
))
5877 if (ctx
->outer_context
5878 && omp_notice_variable (ctx
->outer_context
, decl
, in_code
))
5883 /* Verify that DECL is private within CTX. If there's specific information
5884 to the contrary in the innermost scope, generate an error. */
5887 omp_is_private (struct gimplify_omp_ctx
*ctx
, tree decl
, int simd
)
5891 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5894 if (n
->value
& GOVD_SHARED
)
5896 if (ctx
== gimplify_omp_ctxp
)
5899 error ("iteration variable %qE is predetermined linear",
5902 error ("iteration variable %qE should be private",
5904 n
->value
= GOVD_PRIVATE
;
5910 else if ((n
->value
& GOVD_EXPLICIT
) != 0
5911 && (ctx
== gimplify_omp_ctxp
5912 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
5913 && gimplify_omp_ctxp
->outer_context
== ctx
)))
5915 if ((n
->value
& GOVD_FIRSTPRIVATE
) != 0)
5916 error ("iteration variable %qE should not be firstprivate",
5918 else if ((n
->value
& GOVD_REDUCTION
) != 0)
5919 error ("iteration variable %qE should not be reduction",
5921 else if (simd
== 1 && (n
->value
& GOVD_LASTPRIVATE
) != 0)
5922 error ("iteration variable %qE should not be lastprivate",
5924 else if (simd
&& (n
->value
& GOVD_PRIVATE
) != 0)
5925 error ("iteration variable %qE should not be private",
5927 else if (simd
== 2 && (n
->value
& GOVD_LINEAR
) != 0)
5928 error ("iteration variable %qE is predetermined linear",
5931 return (ctx
== gimplify_omp_ctxp
5932 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
5933 && gimplify_omp_ctxp
->outer_context
== ctx
));
5936 if (ctx
->region_type
!= ORT_WORKSHARE
5937 && ctx
->region_type
!= ORT_SIMD
)
5939 else if (ctx
->outer_context
)
5940 return omp_is_private (ctx
->outer_context
, decl
, simd
);
5944 /* Return true if DECL is private within a parallel region
5945 that binds to the current construct's context or in parallel
5946 region's REDUCTION clause. */
5949 omp_check_private (struct gimplify_omp_ctx
*ctx
, tree decl
, bool copyprivate
)
5955 ctx
= ctx
->outer_context
;
5957 return !(is_global_var (decl
)
5958 /* References might be private, but might be shared too,
5959 when checking for copyprivate, assume they might be
5960 private, otherwise assume they might be shared. */
5962 && lang_hooks
.decls
.omp_privatize_by_reference (decl
)));
5964 if ((ctx
->region_type
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0)
5967 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
5969 return (n
->value
& GOVD_SHARED
) == 0;
5971 while (ctx
->region_type
== ORT_WORKSHARE
5972 || ctx
->region_type
== ORT_SIMD
);
5976 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
5977 and previous omp contexts. */
5980 gimplify_scan_omp_clauses (tree
*list_p
, gimple_seq
*pre_p
,
5981 enum omp_region_type region_type
)
5983 struct gimplify_omp_ctx
*ctx
, *outer_ctx
;
5986 ctx
= new_omp_context (region_type
);
5987 outer_ctx
= ctx
->outer_context
;
5989 while ((c
= *list_p
) != NULL
)
5991 bool remove
= false;
5992 bool notice_outer
= true;
5993 const char *check_non_private
= NULL
;
5997 switch (OMP_CLAUSE_CODE (c
))
5999 case OMP_CLAUSE_PRIVATE
:
6000 flags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
6001 if (lang_hooks
.decls
.omp_private_outer_ref (OMP_CLAUSE_DECL (c
)))
6003 flags
|= GOVD_PRIVATE_OUTER_REF
;
6004 OMP_CLAUSE_PRIVATE_OUTER_REF (c
) = 1;
6007 notice_outer
= false;
6009 case OMP_CLAUSE_SHARED
:
6010 flags
= GOVD_SHARED
| GOVD_EXPLICIT
;
6012 case OMP_CLAUSE_FIRSTPRIVATE
:
6013 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
6014 check_non_private
= "firstprivate";
6016 case OMP_CLAUSE_LASTPRIVATE
:
6017 flags
= GOVD_LASTPRIVATE
| GOVD_SEEN
| GOVD_EXPLICIT
;
6018 check_non_private
= "lastprivate";
6020 case OMP_CLAUSE_REDUCTION
:
6021 flags
= GOVD_REDUCTION
| GOVD_SEEN
| GOVD_EXPLICIT
;
6022 check_non_private
= "reduction";
6024 case OMP_CLAUSE_LINEAR
:
6025 if (gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
), pre_p
, NULL
,
6026 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6031 flags
= GOVD_LINEAR
| GOVD_EXPLICIT
;
6034 case OMP_CLAUSE_MAP
:
6035 decl
= OMP_CLAUSE_DECL (c
);
6036 if (error_operand_p (decl
))
6041 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
6042 OMP_CLAUSE_SIZE (c
) = DECL_P (decl
) ? DECL_SIZE_UNIT (decl
)
6043 : TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6044 if (gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
6045 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6052 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
,
6053 NULL
, is_gimple_lvalue
, fb_lvalue
)
6061 flags
= GOVD_MAP
| GOVD_EXPLICIT
;
6064 case OMP_CLAUSE_DEPEND
:
6065 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == COMPOUND_EXPR
)
6067 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0), pre_p
,
6068 NULL
, is_gimple_val
, fb_rvalue
);
6069 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (OMP_CLAUSE_DECL (c
), 1);
6071 if (error_operand_p (OMP_CLAUSE_DECL (c
)))
6076 OMP_CLAUSE_DECL (c
) = build_fold_addr_expr (OMP_CLAUSE_DECL (c
));
6077 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
, NULL
,
6078 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6086 case OMP_CLAUSE_FROM
:
6087 decl
= OMP_CLAUSE_DECL (c
);
6088 if (error_operand_p (decl
))
6093 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
6094 OMP_CLAUSE_SIZE (c
) = DECL_P (decl
) ? DECL_SIZE_UNIT (decl
)
6095 : TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6096 if (gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
6097 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6104 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
,
6105 NULL
, is_gimple_lvalue
, fb_lvalue
)
6116 decl
= OMP_CLAUSE_DECL (c
);
6117 if (error_operand_p (decl
))
6122 omp_add_variable (ctx
, decl
, flags
);
6123 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
6124 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
6126 omp_add_variable (ctx
, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
),
6127 GOVD_LOCAL
| GOVD_SEEN
);
6128 gimplify_omp_ctxp
= ctx
;
6129 push_gimplify_context ();
6131 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
6132 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
6134 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c
),
6135 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
6136 pop_gimplify_context
6137 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
)));
6138 push_gimplify_context ();
6139 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c
),
6140 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
6141 pop_gimplify_context
6142 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
)));
6143 OMP_CLAUSE_REDUCTION_INIT (c
) = NULL_TREE
;
6144 OMP_CLAUSE_REDUCTION_MERGE (c
) = NULL_TREE
;
6146 gimplify_omp_ctxp
= outer_ctx
;
6148 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6149 && OMP_CLAUSE_LASTPRIVATE_STMT (c
))
6151 gimplify_omp_ctxp
= ctx
;
6152 push_gimplify_context ();
6153 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c
)) != BIND_EXPR
)
6155 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
6157 TREE_SIDE_EFFECTS (bind
) = 1;
6158 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LASTPRIVATE_STMT (c
);
6159 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = bind
;
6161 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c
),
6162 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6163 pop_gimplify_context
6164 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
)));
6165 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = NULL_TREE
;
6167 gimplify_omp_ctxp
= outer_ctx
;
6169 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
6170 && OMP_CLAUSE_LINEAR_STMT (c
))
6172 gimplify_omp_ctxp
= ctx
;
6173 push_gimplify_context ();
6174 if (TREE_CODE (OMP_CLAUSE_LINEAR_STMT (c
)) != BIND_EXPR
)
6176 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
6178 TREE_SIDE_EFFECTS (bind
) = 1;
6179 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LINEAR_STMT (c
);
6180 OMP_CLAUSE_LINEAR_STMT (c
) = bind
;
6182 gimplify_and_add (OMP_CLAUSE_LINEAR_STMT (c
),
6183 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
));
6184 pop_gimplify_context
6185 (gimple_seq_first_stmt (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
)));
6186 OMP_CLAUSE_LINEAR_STMT (c
) = NULL_TREE
;
6188 gimplify_omp_ctxp
= outer_ctx
;
6194 case OMP_CLAUSE_COPYIN
:
6195 case OMP_CLAUSE_COPYPRIVATE
:
6196 decl
= OMP_CLAUSE_DECL (c
);
6197 if (error_operand_p (decl
))
6202 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_COPYPRIVATE
6204 && !omp_check_private (ctx
, decl
, true))
6207 if (is_global_var (decl
))
6209 if (DECL_THREAD_LOCAL_P (decl
))
6211 else if (DECL_HAS_VALUE_EXPR_P (decl
))
6213 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
6217 && DECL_THREAD_LOCAL_P (value
))
6222 error_at (OMP_CLAUSE_LOCATION (c
),
6223 "copyprivate variable %qE is not threadprivate"
6224 " or private in outer context", DECL_NAME (decl
));
6228 omp_notice_variable (outer_ctx
, decl
, true);
6229 if (check_non_private
6230 && region_type
== ORT_WORKSHARE
6231 && omp_check_private (ctx
, decl
, false))
6233 error ("%s variable %qE is private in outer context",
6234 check_non_private
, DECL_NAME (decl
));
6239 case OMP_CLAUSE_FINAL
:
6241 OMP_CLAUSE_OPERAND (c
, 0)
6242 = gimple_boolify (OMP_CLAUSE_OPERAND (c
, 0));
6245 case OMP_CLAUSE_SCHEDULE
:
6246 case OMP_CLAUSE_NUM_THREADS
:
6247 case OMP_CLAUSE_NUM_TEAMS
:
6248 case OMP_CLAUSE_THREAD_LIMIT
:
6249 case OMP_CLAUSE_DIST_SCHEDULE
:
6250 case OMP_CLAUSE_DEVICE
:
6251 case OMP_CLAUSE__CILK_FOR_COUNT_
:
6252 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
6253 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6257 case OMP_CLAUSE_NOWAIT
:
6258 case OMP_CLAUSE_ORDERED
:
6259 case OMP_CLAUSE_UNTIED
:
6260 case OMP_CLAUSE_COLLAPSE
:
6261 case OMP_CLAUSE_MERGEABLE
:
6262 case OMP_CLAUSE_PROC_BIND
:
6263 case OMP_CLAUSE_SAFELEN
:
6266 case OMP_CLAUSE_ALIGNED
:
6267 decl
= OMP_CLAUSE_DECL (c
);
6268 if (error_operand_p (decl
))
6273 if (gimplify_expr (&OMP_CLAUSE_ALIGNED_ALIGNMENT (c
), pre_p
, NULL
,
6274 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6279 if (!is_global_var (decl
)
6280 && TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
6281 omp_add_variable (ctx
, decl
, GOVD_ALIGNED
);
6284 case OMP_CLAUSE_DEFAULT
:
6285 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
6293 *list_p
= OMP_CLAUSE_CHAIN (c
);
6295 list_p
= &OMP_CLAUSE_CHAIN (c
);
6298 gimplify_omp_ctxp
= ctx
;
6301 struct gimplify_adjust_omp_clauses_data
6307 /* For all variables that were not actually used within the context,
6308 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
6311 gimplify_adjust_omp_clauses_1 (splay_tree_node n
, void *data
)
6313 tree
*list_p
= ((struct gimplify_adjust_omp_clauses_data
*) data
)->list_p
;
6315 = ((struct gimplify_adjust_omp_clauses_data
*) data
)->pre_p
;
6316 tree decl
= (tree
) n
->key
;
6317 unsigned flags
= n
->value
;
6318 enum omp_clause_code code
;
6322 if (flags
& (GOVD_EXPLICIT
| GOVD_LOCAL
))
6324 if ((flags
& GOVD_SEEN
) == 0)
6326 if (flags
& GOVD_DEBUG_PRIVATE
)
6328 gcc_assert ((flags
& GOVD_DATA_SHARE_CLASS
) == GOVD_PRIVATE
);
6329 private_debug
= true;
6331 else if (flags
& GOVD_MAP
)
6332 private_debug
= false;
6335 = lang_hooks
.decls
.omp_private_debug_clause (decl
,
6336 !!(flags
& GOVD_SHARED
));
6338 code
= OMP_CLAUSE_PRIVATE
;
6339 else if (flags
& GOVD_MAP
)
6340 code
= OMP_CLAUSE_MAP
;
6341 else if (flags
& GOVD_SHARED
)
6343 if (is_global_var (decl
))
6345 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
6349 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6350 if (on
&& (on
->value
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
6351 | GOVD_PRIVATE
| GOVD_REDUCTION
6352 | GOVD_LINEAR
| GOVD_MAP
)) != 0)
6354 ctx
= ctx
->outer_context
;
6359 code
= OMP_CLAUSE_SHARED
;
6361 else if (flags
& GOVD_PRIVATE
)
6362 code
= OMP_CLAUSE_PRIVATE
;
6363 else if (flags
& GOVD_FIRSTPRIVATE
)
6364 code
= OMP_CLAUSE_FIRSTPRIVATE
;
6365 else if (flags
& GOVD_LASTPRIVATE
)
6366 code
= OMP_CLAUSE_LASTPRIVATE
;
6367 else if (flags
& GOVD_ALIGNED
)
6372 clause
= build_omp_clause (input_location
, code
);
6373 OMP_CLAUSE_DECL (clause
) = decl
;
6374 OMP_CLAUSE_CHAIN (clause
) = *list_p
;
6376 OMP_CLAUSE_PRIVATE_DEBUG (clause
) = 1;
6377 else if (code
== OMP_CLAUSE_PRIVATE
&& (flags
& GOVD_PRIVATE_OUTER_REF
))
6378 OMP_CLAUSE_PRIVATE_OUTER_REF (clause
) = 1;
6379 else if (code
== OMP_CLAUSE_MAP
)
6381 OMP_CLAUSE_MAP_KIND (clause
) = flags
& GOVD_MAP_TO_ONLY
6383 : OMP_CLAUSE_MAP_TOFROM
;
6384 if (DECL_SIZE (decl
)
6385 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6387 tree decl2
= DECL_VALUE_EXPR (decl
);
6388 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
6389 decl2
= TREE_OPERAND (decl2
, 0);
6390 gcc_assert (DECL_P (decl2
));
6391 tree mem
= build_simple_mem_ref (decl2
);
6392 OMP_CLAUSE_DECL (clause
) = mem
;
6393 OMP_CLAUSE_SIZE (clause
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6394 if (gimplify_omp_ctxp
->outer_context
)
6396 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
6397 omp_notice_variable (ctx
, decl2
, true);
6398 omp_notice_variable (ctx
, OMP_CLAUSE_SIZE (clause
), true);
6400 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
),
6402 OMP_CLAUSE_DECL (nc
) = decl
;
6403 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
6404 OMP_CLAUSE_MAP_KIND (nc
) = OMP_CLAUSE_MAP_POINTER
;
6405 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (clause
);
6406 OMP_CLAUSE_CHAIN (clause
) = nc
;
6409 OMP_CLAUSE_SIZE (clause
) = DECL_SIZE_UNIT (decl
);
6411 if (code
== OMP_CLAUSE_FIRSTPRIVATE
&& (flags
& GOVD_LASTPRIVATE
) != 0)
6413 tree nc
= build_omp_clause (input_location
, OMP_CLAUSE_LASTPRIVATE
);
6414 OMP_CLAUSE_DECL (nc
) = decl
;
6415 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (nc
) = 1;
6416 OMP_CLAUSE_CHAIN (nc
) = *list_p
;
6417 OMP_CLAUSE_CHAIN (clause
) = nc
;
6418 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6419 gimplify_omp_ctxp
= ctx
->outer_context
;
6420 lang_hooks
.decls
.omp_finish_clause (nc
, pre_p
);
6421 gimplify_omp_ctxp
= ctx
;
6424 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6425 gimplify_omp_ctxp
= ctx
->outer_context
;
6426 lang_hooks
.decls
.omp_finish_clause (clause
, pre_p
);
6427 gimplify_omp_ctxp
= ctx
;
6432 gimplify_adjust_omp_clauses (gimple_seq
*pre_p
, tree
*list_p
)
6434 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6437 while ((c
= *list_p
) != NULL
)
6440 bool remove
= false;
6442 switch (OMP_CLAUSE_CODE (c
))
6444 case OMP_CLAUSE_PRIVATE
:
6445 case OMP_CLAUSE_SHARED
:
6446 case OMP_CLAUSE_FIRSTPRIVATE
:
6447 case OMP_CLAUSE_LINEAR
:
6448 decl
= OMP_CLAUSE_DECL (c
);
6449 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6450 remove
= !(n
->value
& GOVD_SEEN
);
6453 bool shared
= OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
;
6454 if ((n
->value
& GOVD_DEBUG_PRIVATE
)
6455 || lang_hooks
.decls
.omp_private_debug_clause (decl
, shared
))
6457 gcc_assert ((n
->value
& GOVD_DEBUG_PRIVATE
) == 0
6458 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
6460 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_PRIVATE
);
6461 OMP_CLAUSE_PRIVATE_DEBUG (c
) = 1;
6463 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
6464 && ctx
->outer_context
6465 && !(OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
6466 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)))
6468 if (ctx
->outer_context
->combined_loop
6469 && !OMP_CLAUSE_LINEAR_NO_COPYIN (c
))
6471 n
= splay_tree_lookup (ctx
->outer_context
->variables
,
6472 (splay_tree_key
) decl
);
6474 || (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
6476 int flags
= GOVD_FIRSTPRIVATE
;
6477 /* #pragma omp distribute does not allow
6478 lastprivate clause. */
6479 if (!ctx
->outer_context
->distribute
)
6480 flags
|= GOVD_LASTPRIVATE
;
6482 omp_add_variable (ctx
->outer_context
, decl
,
6485 n
->value
|= flags
| GOVD_SEEN
;
6488 else if (!is_global_var (decl
))
6489 omp_notice_variable (ctx
->outer_context
, decl
, true);
6494 case OMP_CLAUSE_LASTPRIVATE
:
6495 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
6496 accurately reflect the presence of a FIRSTPRIVATE clause. */
6497 decl
= OMP_CLAUSE_DECL (c
);
6498 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6499 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
6500 = (n
->value
& GOVD_FIRSTPRIVATE
) != 0;
6503 case OMP_CLAUSE_ALIGNED
:
6504 decl
= OMP_CLAUSE_DECL (c
);
6505 if (!is_global_var (decl
))
6507 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6508 remove
= n
== NULL
|| !(n
->value
& GOVD_SEEN
);
6509 if (!remove
&& TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
6511 struct gimplify_omp_ctx
*octx
;
6513 && (n
->value
& (GOVD_DATA_SHARE_CLASS
6514 & ~GOVD_FIRSTPRIVATE
)))
6517 for (octx
= ctx
->outer_context
; octx
;
6518 octx
= octx
->outer_context
)
6520 n
= splay_tree_lookup (octx
->variables
,
6521 (splay_tree_key
) decl
);
6524 if (n
->value
& GOVD_LOCAL
)
6526 /* We have to avoid assigning a shared variable
6527 to itself when trying to add
6528 __builtin_assume_aligned. */
6529 if (n
->value
& GOVD_SHARED
)
6537 else if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
6539 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6540 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
6545 case OMP_CLAUSE_MAP
:
6546 decl
= OMP_CLAUSE_DECL (c
);
6549 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6550 if (ctx
->region_type
== ORT_TARGET
&& !(n
->value
& GOVD_SEEN
))
6552 else if (DECL_SIZE (decl
)
6553 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
6554 && OMP_CLAUSE_MAP_KIND (c
) != OMP_CLAUSE_MAP_POINTER
)
6556 tree decl2
= DECL_VALUE_EXPR (decl
);
6557 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
6558 decl2
= TREE_OPERAND (decl2
, 0);
6559 gcc_assert (DECL_P (decl2
));
6560 tree mem
= build_simple_mem_ref (decl2
);
6561 OMP_CLAUSE_DECL (c
) = mem
;
6562 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6563 if (ctx
->outer_context
)
6565 omp_notice_variable (ctx
->outer_context
, decl2
, true);
6566 omp_notice_variable (ctx
->outer_context
,
6567 OMP_CLAUSE_SIZE (c
), true);
6569 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
6571 OMP_CLAUSE_DECL (nc
) = decl
;
6572 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
6573 OMP_CLAUSE_MAP_KIND (nc
) = OMP_CLAUSE_MAP_POINTER
;
6574 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (c
);
6575 OMP_CLAUSE_CHAIN (c
) = nc
;
6578 else if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
6579 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
6583 case OMP_CLAUSE_FROM
:
6584 decl
= OMP_CLAUSE_DECL (c
);
6587 if (DECL_SIZE (decl
)
6588 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6590 tree decl2
= DECL_VALUE_EXPR (decl
);
6591 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
6592 decl2
= TREE_OPERAND (decl2
, 0);
6593 gcc_assert (DECL_P (decl2
));
6594 tree mem
= build_simple_mem_ref (decl2
);
6595 OMP_CLAUSE_DECL (c
) = mem
;
6596 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6597 if (ctx
->outer_context
)
6599 omp_notice_variable (ctx
->outer_context
, decl2
, true);
6600 omp_notice_variable (ctx
->outer_context
,
6601 OMP_CLAUSE_SIZE (c
), true);
6604 else if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
6605 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
6608 case OMP_CLAUSE_REDUCTION
:
6609 case OMP_CLAUSE_COPYIN
:
6610 case OMP_CLAUSE_COPYPRIVATE
:
6612 case OMP_CLAUSE_NUM_THREADS
:
6613 case OMP_CLAUSE_NUM_TEAMS
:
6614 case OMP_CLAUSE_THREAD_LIMIT
:
6615 case OMP_CLAUSE_DIST_SCHEDULE
:
6616 case OMP_CLAUSE_DEVICE
:
6617 case OMP_CLAUSE_SCHEDULE
:
6618 case OMP_CLAUSE_NOWAIT
:
6619 case OMP_CLAUSE_ORDERED
:
6620 case OMP_CLAUSE_DEFAULT
:
6621 case OMP_CLAUSE_UNTIED
:
6622 case OMP_CLAUSE_COLLAPSE
:
6623 case OMP_CLAUSE_FINAL
:
6624 case OMP_CLAUSE_MERGEABLE
:
6625 case OMP_CLAUSE_PROC_BIND
:
6626 case OMP_CLAUSE_SAFELEN
:
6627 case OMP_CLAUSE_DEPEND
:
6628 case OMP_CLAUSE__CILK_FOR_COUNT_
:
6636 *list_p
= OMP_CLAUSE_CHAIN (c
);
6638 list_p
= &OMP_CLAUSE_CHAIN (c
);
6641 /* Add in any implicit data sharing. */
6642 struct gimplify_adjust_omp_clauses_data data
;
6643 data
.list_p
= list_p
;
6645 splay_tree_foreach (ctx
->variables
, gimplify_adjust_omp_clauses_1
, &data
);
6647 gimplify_omp_ctxp
= ctx
->outer_context
;
6648 delete_omp_context (ctx
);
6651 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
6652 gimplification of the body, as well as scanning the body for used
6653 variables. We need to do this scan now, because variable-sized
6654 decls will be decomposed during gimplification. */
6657 gimplify_omp_parallel (tree
*expr_p
, gimple_seq
*pre_p
)
6659 tree expr
= *expr_p
;
6661 gimple_seq body
= NULL
;
6663 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
), pre_p
,
6664 OMP_PARALLEL_COMBINED (expr
)
6665 ? ORT_COMBINED_PARALLEL
6668 push_gimplify_context ();
6670 g
= gimplify_and_return_first (OMP_PARALLEL_BODY (expr
), &body
);
6671 if (gimple_code (g
) == GIMPLE_BIND
)
6672 pop_gimplify_context (g
);
6674 pop_gimplify_context (NULL
);
6676 gimplify_adjust_omp_clauses (pre_p
, &OMP_PARALLEL_CLAUSES (expr
));
6678 g
= gimple_build_omp_parallel (body
,
6679 OMP_PARALLEL_CLAUSES (expr
),
6680 NULL_TREE
, NULL_TREE
);
6681 if (OMP_PARALLEL_COMBINED (expr
))
6682 gimple_omp_set_subcode (g
, GF_OMP_PARALLEL_COMBINED
);
6683 gimplify_seq_add_stmt (pre_p
, g
);
6684 *expr_p
= NULL_TREE
;
6687 /* Gimplify the contents of an OMP_TASK statement. This involves
6688 gimplification of the body, as well as scanning the body for used
6689 variables. We need to do this scan now, because variable-sized
6690 decls will be decomposed during gimplification. */
6693 gimplify_omp_task (tree
*expr_p
, gimple_seq
*pre_p
)
6695 tree expr
= *expr_p
;
6697 gimple_seq body
= NULL
;
6699 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr
), pre_p
,
6700 find_omp_clause (OMP_TASK_CLAUSES (expr
),
6702 ? ORT_UNTIED_TASK
: ORT_TASK
);
6704 push_gimplify_context ();
6706 g
= gimplify_and_return_first (OMP_TASK_BODY (expr
), &body
);
6707 if (gimple_code (g
) == GIMPLE_BIND
)
6708 pop_gimplify_context (g
);
6710 pop_gimplify_context (NULL
);
6712 gimplify_adjust_omp_clauses (pre_p
, &OMP_TASK_CLAUSES (expr
));
6714 g
= gimple_build_omp_task (body
,
6715 OMP_TASK_CLAUSES (expr
),
6716 NULL_TREE
, NULL_TREE
,
6717 NULL_TREE
, NULL_TREE
, NULL_TREE
);
6718 gimplify_seq_add_stmt (pre_p
, g
);
6719 *expr_p
= NULL_TREE
;
6722 /* Helper function of gimplify_omp_for, find OMP_FOR resp. OMP_SIMD
6723 with non-NULL OMP_FOR_INIT. */
6726 find_combined_omp_for (tree
*tp
, int *walk_subtrees
, void *)
6729 switch (TREE_CODE (*tp
))
6735 if (OMP_FOR_INIT (*tp
) != NULL_TREE
)
6739 case STATEMENT_LIST
:
6749 /* Gimplify the gross structure of an OMP_FOR statement. */
6751 static enum gimplify_status
6752 gimplify_omp_for (tree
*expr_p
, gimple_seq
*pre_p
)
6754 tree for_stmt
, orig_for_stmt
, decl
, var
, t
;
6755 enum gimplify_status ret
= GS_ALL_DONE
;
6756 enum gimplify_status tret
;
6758 gimple_seq for_body
, for_pre_body
;
6761 bitmap has_decl_expr
= NULL
;
6763 orig_for_stmt
= for_stmt
= *expr_p
;
6765 simd
= (TREE_CODE (for_stmt
) == OMP_SIMD
6766 || TREE_CODE (for_stmt
) == CILK_SIMD
);
6767 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
), pre_p
,
6768 simd
? ORT_SIMD
: ORT_WORKSHARE
);
6769 if (TREE_CODE (for_stmt
) == OMP_DISTRIBUTE
)
6770 gimplify_omp_ctxp
->distribute
= true;
6772 /* Handle OMP_FOR_INIT. */
6773 for_pre_body
= NULL
;
6774 if (simd
&& OMP_FOR_PRE_BODY (for_stmt
))
6776 has_decl_expr
= BITMAP_ALLOC (NULL
);
6777 if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == DECL_EXPR
6778 && TREE_CODE (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt
)))
6781 t
= OMP_FOR_PRE_BODY (for_stmt
);
6782 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
6784 else if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == STATEMENT_LIST
)
6786 tree_stmt_iterator si
;
6787 for (si
= tsi_start (OMP_FOR_PRE_BODY (for_stmt
)); !tsi_end_p (si
);
6791 if (TREE_CODE (t
) == DECL_EXPR
6792 && TREE_CODE (DECL_EXPR_DECL (t
)) == VAR_DECL
)
6793 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
6797 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
6798 OMP_FOR_PRE_BODY (for_stmt
) = NULL_TREE
;
6800 if (OMP_FOR_INIT (for_stmt
) == NULL_TREE
)
6802 for_stmt
= walk_tree (&OMP_FOR_BODY (for_stmt
), find_combined_omp_for
,
6804 gcc_assert (for_stmt
!= NULL_TREE
);
6805 gimplify_omp_ctxp
->combined_loop
= true;
6809 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6810 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt
)));
6811 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6812 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt
)));
6813 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6815 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6816 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6817 decl
= TREE_OPERAND (t
, 0);
6818 gcc_assert (DECL_P (decl
));
6819 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl
))
6820 || POINTER_TYPE_P (TREE_TYPE (decl
)));
6822 /* Make sure the iteration variable is private. */
6824 tree c2
= NULL_TREE
;
6825 if (orig_for_stmt
!= for_stmt
)
6826 /* Do this only on innermost construct for combined ones. */;
6829 splay_tree_node n
= splay_tree_lookup (gimplify_omp_ctxp
->variables
,
6830 (splay_tree_key
)decl
);
6831 omp_is_private (gimplify_omp_ctxp
, decl
,
6832 1 + (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6834 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
6835 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
6836 else if (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
6838 c
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
6839 OMP_CLAUSE_LINEAR_NO_COPYIN (c
) = 1;
6841 && bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)))
6842 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
6843 OMP_CLAUSE_DECL (c
) = decl
;
6844 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
6845 OMP_FOR_CLAUSES (for_stmt
) = c
;
6846 omp_add_variable (gimplify_omp_ctxp
, decl
,
6847 GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
);
6853 || !bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)));
6855 && gimplify_omp_ctxp
->outer_context
6856 && gimplify_omp_ctxp
->outer_context
->region_type
6858 && gimplify_omp_ctxp
->outer_context
->combined_loop
6859 && !gimplify_omp_ctxp
->outer_context
->distribute
)
6861 struct gimplify_omp_ctx
*outer
6862 = gimplify_omp_ctxp
->outer_context
;
6863 n
= splay_tree_lookup (outer
->variables
,
6864 (splay_tree_key
) decl
);
6866 && (n
->value
& GOVD_DATA_SHARE_CLASS
) == GOVD_LOCAL
)
6867 lastprivate
= false;
6868 else if (omp_check_private (outer
, decl
, false))
6869 error ("lastprivate variable %qE is private in outer "
6870 "context", DECL_NAME (decl
));
6873 omp_add_variable (outer
, decl
,
6874 GOVD_LASTPRIVATE
| GOVD_SEEN
);
6875 if (outer
->outer_context
)
6876 omp_notice_variable (outer
->outer_context
, decl
, true);
6879 c
= build_omp_clause (input_location
,
6880 lastprivate
? OMP_CLAUSE_LASTPRIVATE
6881 : OMP_CLAUSE_PRIVATE
);
6882 OMP_CLAUSE_DECL (c
) = decl
;
6883 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
6884 OMP_FOR_CLAUSES (for_stmt
) = c
;
6885 omp_add_variable (gimplify_omp_ctxp
, decl
,
6886 (lastprivate
? GOVD_LASTPRIVATE
: GOVD_PRIVATE
)
6887 | GOVD_EXPLICIT
| GOVD_SEEN
);
6891 else if (omp_is_private (gimplify_omp_ctxp
, decl
, 0))
6892 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
6894 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_PRIVATE
| GOVD_SEEN
);
6896 /* If DECL is not a gimple register, create a temporary variable to act
6897 as an iteration counter. This is valid, since DECL cannot be
6898 modified in the body of the loop. Similarly for any iteration vars
6899 in simd with collapse > 1 where the iterator vars must be
6901 if (orig_for_stmt
!= for_stmt
)
6903 else if (!is_gimple_reg (decl
)
6904 || (simd
&& TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1))
6906 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
6907 TREE_OPERAND (t
, 0) = var
;
6909 gimplify_seq_add_stmt (&for_body
, gimple_build_assign (decl
, var
));
6911 if (simd
&& TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
6913 c2
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
6914 OMP_CLAUSE_LINEAR_NO_COPYIN (c2
) = 1;
6915 OMP_CLAUSE_LINEAR_NO_COPYOUT (c2
) = 1;
6916 OMP_CLAUSE_DECL (c2
) = var
;
6917 OMP_CLAUSE_CHAIN (c2
) = OMP_FOR_CLAUSES (for_stmt
);
6918 OMP_FOR_CLAUSES (for_stmt
) = c2
;
6919 omp_add_variable (gimplify_omp_ctxp
, var
,
6920 GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
);
6928 omp_add_variable (gimplify_omp_ctxp
, var
,
6929 GOVD_PRIVATE
| GOVD_SEEN
);
6934 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6935 is_gimple_val
, fb_rvalue
);
6936 ret
= MIN (ret
, tret
);
6937 if (ret
== GS_ERROR
)
6940 /* Handle OMP_FOR_COND. */
6941 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
6942 gcc_assert (COMPARISON_CLASS_P (t
));
6943 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6945 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6946 is_gimple_val
, fb_rvalue
);
6947 ret
= MIN (ret
, tret
);
6949 /* Handle OMP_FOR_INCR. */
6950 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6951 switch (TREE_CODE (t
))
6953 case PREINCREMENT_EXPR
:
6954 case POSTINCREMENT_EXPR
:
6956 tree decl
= TREE_OPERAND (t
, 0);
6957 /* c_omp_for_incr_canonicalize_ptr() should have been
6958 called to massage things appropriately. */
6959 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl
)));
6961 if (orig_for_stmt
!= for_stmt
)
6963 t
= build_int_cst (TREE_TYPE (decl
), 1);
6965 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
6966 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6967 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6968 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6972 case PREDECREMENT_EXPR
:
6973 case POSTDECREMENT_EXPR
:
6974 /* c_omp_for_incr_canonicalize_ptr() should have been
6975 called to massage things appropriately. */
6976 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl
)));
6977 if (orig_for_stmt
!= for_stmt
)
6979 t
= build_int_cst (TREE_TYPE (decl
), -1);
6981 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
6982 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6983 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6984 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6988 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6989 TREE_OPERAND (t
, 0) = var
;
6991 t
= TREE_OPERAND (t
, 1);
6992 switch (TREE_CODE (t
))
6995 if (TREE_OPERAND (t
, 1) == decl
)
6997 TREE_OPERAND (t
, 1) = TREE_OPERAND (t
, 0);
6998 TREE_OPERAND (t
, 0) = var
;
7004 case POINTER_PLUS_EXPR
:
7005 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
7006 TREE_OPERAND (t
, 0) = var
;
7012 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
7013 is_gimple_val
, fb_rvalue
);
7014 ret
= MIN (ret
, tret
);
7017 tree step
= TREE_OPERAND (t
, 1);
7018 tree stept
= TREE_TYPE (decl
);
7019 if (POINTER_TYPE_P (stept
))
7021 step
= fold_convert (stept
, step
);
7022 if (TREE_CODE (t
) == MINUS_EXPR
)
7023 step
= fold_build1 (NEGATE_EXPR
, stept
, step
);
7024 OMP_CLAUSE_LINEAR_STEP (c
) = step
;
7025 if (step
!= TREE_OPERAND (t
, 1))
7027 tret
= gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
),
7028 &for_pre_body
, NULL
,
7029 is_gimple_val
, fb_rvalue
);
7030 ret
= MIN (ret
, tret
);
7042 OMP_CLAUSE_LINEAR_STEP (c2
) = OMP_CLAUSE_LINEAR_STEP (c
);
7045 if ((var
!= decl
|| TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1)
7046 && orig_for_stmt
== for_stmt
)
7048 for (c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
7049 if (((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
7050 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) == NULL
)
7051 || (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
7052 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)
7053 && OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
) == NULL
))
7054 && OMP_CLAUSE_DECL (c
) == decl
)
7056 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7057 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
7058 gcc_assert (TREE_OPERAND (t
, 0) == var
);
7059 t
= TREE_OPERAND (t
, 1);
7060 gcc_assert (TREE_CODE (t
) == PLUS_EXPR
7061 || TREE_CODE (t
) == MINUS_EXPR
7062 || TREE_CODE (t
) == POINTER_PLUS_EXPR
);
7063 gcc_assert (TREE_OPERAND (t
, 0) == var
);
7064 t
= build2 (TREE_CODE (t
), TREE_TYPE (decl
), decl
,
7065 TREE_OPERAND (t
, 1));
7067 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
7068 seq
= &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
);
7070 seq
= &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
);
7071 gimplify_assign (decl
, t
, seq
);
7076 BITMAP_FREE (has_decl_expr
);
7078 gimplify_and_add (OMP_FOR_BODY (orig_for_stmt
), &for_body
);
7080 if (orig_for_stmt
!= for_stmt
)
7081 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
7083 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
7084 decl
= TREE_OPERAND (t
, 0);
7085 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
7086 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
7087 TREE_OPERAND (t
, 0) = var
;
7088 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7089 TREE_OPERAND (t
, 1) = copy_node (TREE_OPERAND (t
, 1));
7090 TREE_OPERAND (TREE_OPERAND (t
, 1), 0) = var
;
7093 gimplify_adjust_omp_clauses (pre_p
, &OMP_FOR_CLAUSES (orig_for_stmt
));
7096 switch (TREE_CODE (orig_for_stmt
))
7098 case OMP_FOR
: kind
= GF_OMP_FOR_KIND_FOR
; break;
7099 case OMP_SIMD
: kind
= GF_OMP_FOR_KIND_SIMD
; break;
7100 case CILK_SIMD
: kind
= GF_OMP_FOR_KIND_CILKSIMD
; break;
7101 case CILK_FOR
: kind
= GF_OMP_FOR_KIND_CILKFOR
; break;
7102 case OMP_DISTRIBUTE
: kind
= GF_OMP_FOR_KIND_DISTRIBUTE
; break;
7106 gfor
= gimple_build_omp_for (for_body
, kind
, OMP_FOR_CLAUSES (orig_for_stmt
),
7107 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)),
7109 if (orig_for_stmt
!= for_stmt
)
7110 gimple_omp_for_set_combined_p (gfor
, true);
7111 if (gimplify_omp_ctxp
7112 && (gimplify_omp_ctxp
->combined_loop
7113 || (gimplify_omp_ctxp
->region_type
== ORT_COMBINED_PARALLEL
7114 && gimplify_omp_ctxp
->outer_context
7115 && gimplify_omp_ctxp
->outer_context
->combined_loop
)))
7117 gimple_omp_for_set_combined_into_p (gfor
, true);
7118 if (gimplify_omp_ctxp
->combined_loop
)
7119 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_SIMD
);
7121 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_FOR
);
7124 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
7126 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
7127 gimple_omp_for_set_index (gfor
, i
, TREE_OPERAND (t
, 0));
7128 gimple_omp_for_set_initial (gfor
, i
, TREE_OPERAND (t
, 1));
7129 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
7130 gimple_omp_for_set_cond (gfor
, i
, TREE_CODE (t
));
7131 gimple_omp_for_set_final (gfor
, i
, TREE_OPERAND (t
, 1));
7132 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7133 gimple_omp_for_set_incr (gfor
, i
, TREE_OPERAND (t
, 1));
7136 gimplify_seq_add_stmt (pre_p
, gfor
);
7137 if (ret
!= GS_ALL_DONE
)
7139 *expr_p
= NULL_TREE
;
7143 /* Gimplify the gross structure of other OpenMP constructs.
7144 In particular, OMP_SECTIONS, OMP_SINGLE, OMP_TARGET, OMP_TARGET_DATA
7148 gimplify_omp_workshare (tree
*expr_p
, gimple_seq
*pre_p
)
7150 tree expr
= *expr_p
;
7152 gimple_seq body
= NULL
;
7153 enum omp_region_type ort
= ORT_WORKSHARE
;
7155 switch (TREE_CODE (expr
))
7163 case OMP_TARGET_DATA
:
7164 ort
= ORT_TARGET_DATA
;
7172 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr
), pre_p
, ort
);
7173 if (ort
== ORT_TARGET
|| ort
== ORT_TARGET_DATA
)
7175 push_gimplify_context ();
7176 gimple g
= gimplify_and_return_first (OMP_BODY (expr
), &body
);
7177 if (gimple_code (g
) == GIMPLE_BIND
)
7178 pop_gimplify_context (g
);
7180 pop_gimplify_context (NULL
);
7181 if (ort
== ORT_TARGET_DATA
)
7183 gimple_seq cleanup
= NULL
;
7184 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TARGET_END_DATA
);
7185 g
= gimple_build_call (fn
, 0);
7186 gimple_seq_add_stmt (&cleanup
, g
);
7187 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
7189 gimple_seq_add_stmt (&body
, g
);
7193 gimplify_and_add (OMP_BODY (expr
), &body
);
7194 gimplify_adjust_omp_clauses (pre_p
, &OMP_CLAUSES (expr
));
7196 switch (TREE_CODE (expr
))
7199 stmt
= gimple_build_omp_sections (body
, OMP_CLAUSES (expr
));
7202 stmt
= gimple_build_omp_single (body
, OMP_CLAUSES (expr
));
7205 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_REGION
,
7206 OMP_CLAUSES (expr
));
7208 case OMP_TARGET_DATA
:
7209 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_DATA
,
7210 OMP_CLAUSES (expr
));
7213 stmt
= gimple_build_omp_teams (body
, OMP_CLAUSES (expr
));
7219 gimplify_seq_add_stmt (pre_p
, stmt
);
7220 *expr_p
= NULL_TREE
;
7223 /* Gimplify the gross structure of OpenMP target update construct. */
7226 gimplify_omp_target_update (tree
*expr_p
, gimple_seq
*pre_p
)
7228 tree expr
= *expr_p
;
7231 gimplify_scan_omp_clauses (&OMP_TARGET_UPDATE_CLAUSES (expr
), pre_p
,
7233 gimplify_adjust_omp_clauses (pre_p
, &OMP_TARGET_UPDATE_CLAUSES (expr
));
7234 stmt
= gimple_build_omp_target (NULL
, GF_OMP_TARGET_KIND_UPDATE
,
7235 OMP_TARGET_UPDATE_CLAUSES (expr
));
7237 gimplify_seq_add_stmt (pre_p
, stmt
);
7238 *expr_p
= NULL_TREE
;
7241 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
7242 stabilized the lhs of the atomic operation as *ADDR. Return true if
7243 EXPR is this stabilized form. */
7246 goa_lhs_expr_p (tree expr
, tree addr
)
7248 /* Also include casts to other type variants. The C front end is fond
7249 of adding these for e.g. volatile variables. This is like
7250 STRIP_TYPE_NOPS but includes the main variant lookup. */
7251 STRIP_USELESS_TYPE_CONVERSION (expr
);
7253 if (TREE_CODE (expr
) == INDIRECT_REF
)
7255 expr
= TREE_OPERAND (expr
, 0);
7257 && (CONVERT_EXPR_P (expr
)
7258 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
7259 && TREE_CODE (expr
) == TREE_CODE (addr
)
7260 && types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (addr
)))
7262 expr
= TREE_OPERAND (expr
, 0);
7263 addr
= TREE_OPERAND (addr
, 0);
7267 return (TREE_CODE (addr
) == ADDR_EXPR
7268 && TREE_CODE (expr
) == ADDR_EXPR
7269 && TREE_OPERAND (addr
, 0) == TREE_OPERAND (expr
, 0));
7271 if (TREE_CODE (addr
) == ADDR_EXPR
&& expr
== TREE_OPERAND (addr
, 0))
7276 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
7277 expression does not involve the lhs, evaluate it into a temporary.
7278 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
7279 or -1 if an error was encountered. */
7282 goa_stabilize_expr (tree
*expr_p
, gimple_seq
*pre_p
, tree lhs_addr
,
7285 tree expr
= *expr_p
;
7288 if (goa_lhs_expr_p (expr
, lhs_addr
))
7293 if (is_gimple_val (expr
))
7297 switch (TREE_CODE_CLASS (TREE_CODE (expr
)))
7300 case tcc_comparison
:
7301 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
, lhs_addr
,
7304 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
, lhs_addr
,
7307 case tcc_expression
:
7308 switch (TREE_CODE (expr
))
7310 case TRUTH_ANDIF_EXPR
:
7311 case TRUTH_ORIF_EXPR
:
7312 case TRUTH_AND_EXPR
:
7314 case TRUTH_XOR_EXPR
:
7315 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
,
7317 case TRUTH_NOT_EXPR
:
7318 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
7322 /* Break out any preevaluations from cp_build_modify_expr. */
7323 for (; TREE_CODE (expr
) == COMPOUND_EXPR
;
7324 expr
= TREE_OPERAND (expr
, 1))
7325 gimplify_stmt (&TREE_OPERAND (expr
, 0), pre_p
);
7327 return goa_stabilize_expr (expr_p
, pre_p
, lhs_addr
, lhs_var
);
7338 enum gimplify_status gs
;
7339 gs
= gimplify_expr (expr_p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
7340 if (gs
!= GS_ALL_DONE
)
7347 /* Gimplify an OMP_ATOMIC statement. */
7349 static enum gimplify_status
7350 gimplify_omp_atomic (tree
*expr_p
, gimple_seq
*pre_p
)
7352 tree addr
= TREE_OPERAND (*expr_p
, 0);
7353 tree rhs
= TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
7354 ? NULL
: TREE_OPERAND (*expr_p
, 1);
7355 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
7357 gimple loadstmt
, storestmt
;
7359 tmp_load
= create_tmp_reg (type
, NULL
);
7360 if (rhs
&& goa_stabilize_expr (&rhs
, pre_p
, addr
, tmp_load
) < 0)
7363 if (gimplify_expr (&addr
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7367 loadstmt
= gimple_build_omp_atomic_load (tmp_load
, addr
);
7368 gimplify_seq_add_stmt (pre_p
, loadstmt
);
7369 if (rhs
&& gimplify_expr (&rhs
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7373 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
)
7375 storestmt
= gimple_build_omp_atomic_store (rhs
);
7376 gimplify_seq_add_stmt (pre_p
, storestmt
);
7377 if (OMP_ATOMIC_SEQ_CST (*expr_p
))
7379 gimple_omp_atomic_set_seq_cst (loadstmt
);
7380 gimple_omp_atomic_set_seq_cst (storestmt
);
7382 switch (TREE_CODE (*expr_p
))
7384 case OMP_ATOMIC_READ
:
7385 case OMP_ATOMIC_CAPTURE_OLD
:
7387 gimple_omp_atomic_set_need_value (loadstmt
);
7389 case OMP_ATOMIC_CAPTURE_NEW
:
7391 gimple_omp_atomic_set_need_value (storestmt
);
7401 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
7402 body, and adding some EH bits. */
7404 static enum gimplify_status
7405 gimplify_transaction (tree
*expr_p
, gimple_seq
*pre_p
)
7407 tree expr
= *expr_p
, temp
, tbody
= TRANSACTION_EXPR_BODY (expr
);
7409 gimple_seq body
= NULL
;
7412 /* Wrap the transaction body in a BIND_EXPR so we have a context
7413 where to put decls for OpenMP. */
7414 if (TREE_CODE (tbody
) != BIND_EXPR
)
7416 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, tbody
, NULL
);
7417 TREE_SIDE_EFFECTS (bind
) = 1;
7418 SET_EXPR_LOCATION (bind
, EXPR_LOCATION (tbody
));
7419 TRANSACTION_EXPR_BODY (expr
) = bind
;
7422 push_gimplify_context ();
7423 temp
= voidify_wrapper_expr (*expr_p
, NULL
);
7425 g
= gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr
), &body
);
7426 pop_gimplify_context (g
);
7428 g
= gimple_build_transaction (body
, NULL
);
7429 if (TRANSACTION_EXPR_OUTER (expr
))
7430 subcode
= GTMA_IS_OUTER
;
7431 else if (TRANSACTION_EXPR_RELAXED (expr
))
7432 subcode
= GTMA_IS_RELAXED
;
7433 gimple_transaction_set_subcode (g
, subcode
);
7435 gimplify_seq_add_stmt (pre_p
, g
);
7443 *expr_p
= NULL_TREE
;
7447 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
7448 expression produces a value to be used as an operand inside a GIMPLE
7449 statement, the value will be stored back in *EXPR_P. This value will
7450 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
7451 an SSA_NAME. The corresponding sequence of GIMPLE statements is
7452 emitted in PRE_P and POST_P.
7454 Additionally, this process may overwrite parts of the input
7455 expression during gimplification. Ideally, it should be
7456 possible to do non-destructive gimplification.
7458 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
7459 the expression needs to evaluate to a value to be used as
7460 an operand in a GIMPLE statement, this value will be stored in
7461 *EXPR_P on exit. This happens when the caller specifies one
7462 of fb_lvalue or fb_rvalue fallback flags.
7464 PRE_P will contain the sequence of GIMPLE statements corresponding
7465 to the evaluation of EXPR and all the side-effects that must
7466 be executed before the main expression. On exit, the last
7467 statement of PRE_P is the core statement being gimplified. For
7468 instance, when gimplifying 'if (++a)' the last statement in
7469 PRE_P will be 'if (t.1)' where t.1 is the result of
7470 pre-incrementing 'a'.
7472 POST_P will contain the sequence of GIMPLE statements corresponding
7473 to the evaluation of all the side-effects that must be executed
7474 after the main expression. If this is NULL, the post
7475 side-effects are stored at the end of PRE_P.
7477 The reason why the output is split in two is to handle post
7478 side-effects explicitly. In some cases, an expression may have
7479 inner and outer post side-effects which need to be emitted in
7480 an order different from the one given by the recursive
7481 traversal. For instance, for the expression (*p--)++ the post
7482 side-effects of '--' must actually occur *after* the post
7483 side-effects of '++'. However, gimplification will first visit
7484 the inner expression, so if a separate POST sequence was not
7485 used, the resulting sequence would be:
7492 However, the post-decrement operation in line #2 must not be
7493 evaluated until after the store to *p at line #4, so the
7494 correct sequence should be:
7501 So, by specifying a separate post queue, it is possible
7502 to emit the post side-effects in the correct order.
7503 If POST_P is NULL, an internal queue will be used. Before
7504 returning to the caller, the sequence POST_P is appended to
7505 the main output sequence PRE_P.
7507 GIMPLE_TEST_F points to a function that takes a tree T and
7508 returns nonzero if T is in the GIMPLE form requested by the
7509 caller. The GIMPLE predicates are in gimple.c.
7511 FALLBACK tells the function what sort of a temporary we want if
7512 gimplification cannot produce an expression that complies with
7515 fb_none means that no temporary should be generated
7516 fb_rvalue means that an rvalue is OK to generate
7517 fb_lvalue means that an lvalue is OK to generate
7518 fb_either means that either is OK, but an lvalue is preferable.
7519 fb_mayfail means that gimplification may fail (in which case
7520 GS_ERROR will be returned)
7522 The return value is either GS_ERROR or GS_ALL_DONE, since this
7523 function iterates until EXPR is completely gimplified or an error
7526 enum gimplify_status
7527 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
7528 bool (*gimple_test_f
) (tree
), fallback_t fallback
)
7531 gimple_seq internal_pre
= NULL
;
7532 gimple_seq internal_post
= NULL
;
7535 location_t saved_location
;
7536 enum gimplify_status ret
;
7537 gimple_stmt_iterator pre_last_gsi
, post_last_gsi
;
7539 save_expr
= *expr_p
;
7540 if (save_expr
== NULL_TREE
)
7543 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
7544 is_statement
= gimple_test_f
== is_gimple_stmt
;
7548 /* Consistency checks. */
7549 if (gimple_test_f
== is_gimple_reg
)
7550 gcc_assert (fallback
& (fb_rvalue
| fb_lvalue
));
7551 else if (gimple_test_f
== is_gimple_val
7552 || gimple_test_f
== is_gimple_call_addr
7553 || gimple_test_f
== is_gimple_condexpr
7554 || gimple_test_f
== is_gimple_mem_rhs
7555 || gimple_test_f
== is_gimple_mem_rhs_or_call
7556 || gimple_test_f
== is_gimple_reg_rhs
7557 || gimple_test_f
== is_gimple_reg_rhs_or_call
7558 || gimple_test_f
== is_gimple_asm_val
7559 || gimple_test_f
== is_gimple_mem_ref_addr
)
7560 gcc_assert (fallback
& fb_rvalue
);
7561 else if (gimple_test_f
== is_gimple_min_lval
7562 || gimple_test_f
== is_gimple_lvalue
)
7563 gcc_assert (fallback
& fb_lvalue
);
7564 else if (gimple_test_f
== is_gimple_addressable
)
7565 gcc_assert (fallback
& fb_either
);
7566 else if (gimple_test_f
== is_gimple_stmt
)
7567 gcc_assert (fallback
== fb_none
);
7570 /* We should have recognized the GIMPLE_TEST_F predicate to
7571 know what kind of fallback to use in case a temporary is
7572 needed to hold the value or address of *EXPR_P. */
7576 /* We used to check the predicate here and return immediately if it
7577 succeeds. This is wrong; the design is for gimplification to be
7578 idempotent, and for the predicates to only test for valid forms, not
7579 whether they are fully simplified. */
7581 pre_p
= &internal_pre
;
7584 post_p
= &internal_post
;
7586 /* Remember the last statements added to PRE_P and POST_P. Every
7587 new statement added by the gimplification helpers needs to be
7588 annotated with location information. To centralize the
7589 responsibility, we remember the last statement that had been
7590 added to both queues before gimplifying *EXPR_P. If
7591 gimplification produces new statements in PRE_P and POST_P, those
7592 statements will be annotated with the same location information
7594 pre_last_gsi
= gsi_last (*pre_p
);
7595 post_last_gsi
= gsi_last (*post_p
);
7597 saved_location
= input_location
;
7598 if (save_expr
!= error_mark_node
7599 && EXPR_HAS_LOCATION (*expr_p
))
7600 input_location
= EXPR_LOCATION (*expr_p
);
7602 /* Loop over the specific gimplifiers until the toplevel node
7603 remains the same. */
7606 /* Strip away as many useless type conversions as possible
7608 STRIP_USELESS_TYPE_CONVERSION (*expr_p
);
7610 /* Remember the expr. */
7611 save_expr
= *expr_p
;
7613 /* Die, die, die, my darling. */
7614 if (save_expr
== error_mark_node
7615 || (TREE_TYPE (save_expr
)
7616 && TREE_TYPE (save_expr
) == error_mark_node
))
7622 /* Do any language-specific gimplification. */
7623 ret
= ((enum gimplify_status
)
7624 lang_hooks
.gimplify_expr (expr_p
, pre_p
, post_p
));
7627 if (*expr_p
== NULL_TREE
)
7629 if (*expr_p
!= save_expr
)
7632 else if (ret
!= GS_UNHANDLED
)
7635 /* Make sure that all the cases set 'ret' appropriately. */
7637 switch (TREE_CODE (*expr_p
))
7639 /* First deal with the special cases. */
7641 case POSTINCREMENT_EXPR
:
7642 case POSTDECREMENT_EXPR
:
7643 case PREINCREMENT_EXPR
:
7644 case PREDECREMENT_EXPR
:
7645 ret
= gimplify_self_mod_expr (expr_p
, pre_p
, post_p
,
7646 fallback
!= fb_none
,
7647 TREE_TYPE (*expr_p
));
7650 case VIEW_CONVERT_EXPR
:
7651 if (is_gimple_reg_type (TREE_TYPE (*expr_p
))
7652 && is_gimple_reg_type (TREE_TYPE (TREE_OPERAND (*expr_p
, 0))))
7654 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7655 post_p
, is_gimple_val
, fb_rvalue
);
7656 recalculate_side_effects (*expr_p
);
7662 case ARRAY_RANGE_REF
:
7666 ret
= gimplify_compound_lval (expr_p
, pre_p
, post_p
,
7667 fallback
? fallback
: fb_rvalue
);
7671 ret
= gimplify_cond_expr (expr_p
, pre_p
, fallback
);
7673 /* C99 code may assign to an array in a structure value of a
7674 conditional expression, and this has undefined behavior
7675 only on execution, so create a temporary if an lvalue is
7677 if (fallback
== fb_lvalue
)
7679 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7680 mark_addressable (*expr_p
);
7686 ret
= gimplify_call_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7688 /* C99 code may assign to an array in a structure returned
7689 from a function, and this has undefined behavior only on
7690 execution, so create a temporary if an lvalue is
7692 if (fallback
== fb_lvalue
)
7694 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7695 mark_addressable (*expr_p
);
7704 ret
= gimplify_compound_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7707 case COMPOUND_LITERAL_EXPR
:
7708 ret
= gimplify_compound_literal_expr (expr_p
, pre_p
,
7709 gimple_test_f
, fallback
);
7714 ret
= gimplify_modify_expr (expr_p
, pre_p
, post_p
,
7715 fallback
!= fb_none
);
7718 case TRUTH_ANDIF_EXPR
:
7719 case TRUTH_ORIF_EXPR
:
7721 /* Preserve the original type of the expression and the
7722 source location of the outer expression. */
7723 tree org_type
= TREE_TYPE (*expr_p
);
7724 *expr_p
= gimple_boolify (*expr_p
);
7725 *expr_p
= build3_loc (input_location
, COND_EXPR
,
7729 org_type
, boolean_true_node
),
7732 org_type
, boolean_false_node
));
7737 case TRUTH_NOT_EXPR
:
7739 tree type
= TREE_TYPE (*expr_p
);
7740 /* The parsers are careful to generate TRUTH_NOT_EXPR
7741 only with operands that are always zero or one.
7742 We do not fold here but handle the only interesting case
7743 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
7744 *expr_p
= gimple_boolify (*expr_p
);
7745 if (TYPE_PRECISION (TREE_TYPE (*expr_p
)) == 1)
7746 *expr_p
= build1_loc (input_location
, BIT_NOT_EXPR
,
7747 TREE_TYPE (*expr_p
),
7748 TREE_OPERAND (*expr_p
, 0));
7750 *expr_p
= build2_loc (input_location
, BIT_XOR_EXPR
,
7751 TREE_TYPE (*expr_p
),
7752 TREE_OPERAND (*expr_p
, 0),
7753 build_int_cst (TREE_TYPE (*expr_p
), 1));
7754 if (!useless_type_conversion_p (type
, TREE_TYPE (*expr_p
)))
7755 *expr_p
= fold_convert_loc (input_location
, type
, *expr_p
);
7761 ret
= gimplify_addr_expr (expr_p
, pre_p
, post_p
);
7766 tree cond
= TREE_OPERAND (*expr_p
, 0);
7767 tree kind
= TREE_OPERAND (*expr_p
, 1);
7768 tree type
= TREE_TYPE (cond
);
7769 if (!INTEGRAL_TYPE_P (type
))
7775 tree tmp
= create_tmp_var (type
, NULL
);
7776 gimplify_arg (&cond
, pre_p
, EXPR_LOCATION (*expr_p
));
7778 = gimple_build_call_internal (IFN_ANNOTATE
, 2, cond
, kind
);
7779 gimple_call_set_lhs (call
, tmp
);
7780 gimplify_seq_add_stmt (pre_p
, call
);
7787 ret
= gimplify_va_arg_expr (expr_p
, pre_p
, post_p
);
7791 if (IS_EMPTY_STMT (*expr_p
))
7797 if (VOID_TYPE_P (TREE_TYPE (*expr_p
))
7798 || fallback
== fb_none
)
7800 /* Just strip a conversion to void (or in void context) and
7802 *expr_p
= TREE_OPERAND (*expr_p
, 0);
7807 ret
= gimplify_conversion (expr_p
);
7808 if (ret
== GS_ERROR
)
7810 if (*expr_p
!= save_expr
)
7814 case FIX_TRUNC_EXPR
:
7815 /* unary_expr: ... | '(' cast ')' val | ... */
7816 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7817 is_gimple_val
, fb_rvalue
);
7818 recalculate_side_effects (*expr_p
);
7823 bool volatilep
= TREE_THIS_VOLATILE (*expr_p
);
7824 bool notrap
= TREE_THIS_NOTRAP (*expr_p
);
7825 tree saved_ptr_type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 0));
7827 *expr_p
= fold_indirect_ref_loc (input_location
, *expr_p
);
7828 if (*expr_p
!= save_expr
)
7834 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7835 is_gimple_reg
, fb_rvalue
);
7836 if (ret
== GS_ERROR
)
7839 recalculate_side_effects (*expr_p
);
7840 *expr_p
= fold_build2_loc (input_location
, MEM_REF
,
7841 TREE_TYPE (*expr_p
),
7842 TREE_OPERAND (*expr_p
, 0),
7843 build_int_cst (saved_ptr_type
, 0));
7844 TREE_THIS_VOLATILE (*expr_p
) = volatilep
;
7845 TREE_THIS_NOTRAP (*expr_p
) = notrap
;
7850 /* We arrive here through the various re-gimplifcation paths. */
7852 /* First try re-folding the whole thing. */
7853 tmp
= fold_binary (MEM_REF
, TREE_TYPE (*expr_p
),
7854 TREE_OPERAND (*expr_p
, 0),
7855 TREE_OPERAND (*expr_p
, 1));
7859 recalculate_side_effects (*expr_p
);
7863 /* Avoid re-gimplifying the address operand if it is already
7864 in suitable form. Re-gimplifying would mark the address
7865 operand addressable. Always gimplify when not in SSA form
7866 as we still may have to gimplify decls with value-exprs. */
7867 if (!gimplify_ctxp
|| !gimplify_ctxp
->into_ssa
7868 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p
, 0)))
7870 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7871 is_gimple_mem_ref_addr
, fb_rvalue
);
7872 if (ret
== GS_ERROR
)
7875 recalculate_side_effects (*expr_p
);
7879 /* Constants need not be gimplified. */
7886 /* Drop the overflow flag on constants, we do not want
7887 that in the GIMPLE IL. */
7888 if (TREE_OVERFLOW_P (*expr_p
))
7889 *expr_p
= drop_tree_overflow (*expr_p
);
7894 /* If we require an lvalue, such as for ADDR_EXPR, retain the
7895 CONST_DECL node. Otherwise the decl is replaceable by its
7897 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
7898 if (fallback
& fb_lvalue
)
7902 *expr_p
= DECL_INITIAL (*expr_p
);
7908 ret
= gimplify_decl_expr (expr_p
, pre_p
);
7912 ret
= gimplify_bind_expr (expr_p
, pre_p
);
7916 ret
= gimplify_loop_expr (expr_p
, pre_p
);
7920 ret
= gimplify_switch_expr (expr_p
, pre_p
);
7924 ret
= gimplify_exit_expr (expr_p
);
7928 /* If the target is not LABEL, then it is a computed jump
7929 and the target needs to be gimplified. */
7930 if (TREE_CODE (GOTO_DESTINATION (*expr_p
)) != LABEL_DECL
)
7932 ret
= gimplify_expr (&GOTO_DESTINATION (*expr_p
), pre_p
,
7933 NULL
, is_gimple_val
, fb_rvalue
);
7934 if (ret
== GS_ERROR
)
7937 gimplify_seq_add_stmt (pre_p
,
7938 gimple_build_goto (GOTO_DESTINATION (*expr_p
)));
7943 gimplify_seq_add_stmt (pre_p
,
7944 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p
),
7945 PREDICT_EXPR_OUTCOME (*expr_p
)));
7951 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p
))
7952 == current_function_decl
);
7953 gimplify_seq_add_stmt (pre_p
,
7954 gimple_build_label (LABEL_EXPR_LABEL (*expr_p
)));
7957 case CASE_LABEL_EXPR
:
7958 ret
= gimplify_case_label_expr (expr_p
, pre_p
);
7962 ret
= gimplify_return_expr (*expr_p
, pre_p
);
7966 /* Don't reduce this in place; let gimplify_init_constructor work its
7967 magic. Buf if we're just elaborating this for side effects, just
7968 gimplify any element that has side-effects. */
7969 if (fallback
== fb_none
)
7971 unsigned HOST_WIDE_INT ix
;
7973 tree temp
= NULL_TREE
;
7974 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p
), ix
, val
)
7975 if (TREE_SIDE_EFFECTS (val
))
7976 append_to_statement_list (val
, &temp
);
7979 ret
= temp
? GS_OK
: GS_ALL_DONE
;
7981 /* C99 code may assign to an array in a constructed
7982 structure or union, and this has undefined behavior only
7983 on execution, so create a temporary if an lvalue is
7985 else if (fallback
== fb_lvalue
)
7987 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7988 mark_addressable (*expr_p
);
7995 /* The following are special cases that are not handled by the
7996 original GIMPLE grammar. */
7998 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
8001 ret
= gimplify_save_expr (expr_p
, pre_p
, post_p
);
8005 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8006 post_p
, is_gimple_lvalue
, fb_either
);
8007 recalculate_side_effects (*expr_p
);
8010 case TARGET_MEM_REF
:
8012 enum gimplify_status r0
= GS_ALL_DONE
, r1
= GS_ALL_DONE
;
8014 if (TMR_BASE (*expr_p
))
8015 r0
= gimplify_expr (&TMR_BASE (*expr_p
), pre_p
,
8016 post_p
, is_gimple_mem_ref_addr
, fb_either
);
8017 if (TMR_INDEX (*expr_p
))
8018 r1
= gimplify_expr (&TMR_INDEX (*expr_p
), pre_p
,
8019 post_p
, is_gimple_val
, fb_rvalue
);
8020 if (TMR_INDEX2 (*expr_p
))
8021 r1
= gimplify_expr (&TMR_INDEX2 (*expr_p
), pre_p
,
8022 post_p
, is_gimple_val
, fb_rvalue
);
8023 /* TMR_STEP and TMR_OFFSET are always integer constants. */
8028 case NON_LVALUE_EXPR
:
8029 /* This should have been stripped above. */
8033 ret
= gimplify_asm_expr (expr_p
, pre_p
, post_p
);
8036 case TRY_FINALLY_EXPR
:
8037 case TRY_CATCH_EXPR
:
8039 gimple_seq eval
, cleanup
;
8042 /* Calls to destructors are generated automatically in FINALLY/CATCH
8043 block. They should have location as UNKNOWN_LOCATION. However,
8044 gimplify_call_expr will reset these call stmts to input_location
8045 if it finds stmt's location is unknown. To prevent resetting for
8046 destructors, we set the input_location to unknown.
8047 Note that this only affects the destructor calls in FINALLY/CATCH
8048 block, and will automatically reset to its original value by the
8049 end of gimplify_expr. */
8050 input_location
= UNKNOWN_LOCATION
;
8051 eval
= cleanup
= NULL
;
8052 gimplify_and_add (TREE_OPERAND (*expr_p
, 0), &eval
);
8053 gimplify_and_add (TREE_OPERAND (*expr_p
, 1), &cleanup
);
8054 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
8055 if (gimple_seq_empty_p (cleanup
))
8057 gimple_seq_add_seq (pre_p
, eval
);
8061 try_
= gimple_build_try (eval
, cleanup
,
8062 TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
8063 ? GIMPLE_TRY_FINALLY
8064 : GIMPLE_TRY_CATCH
);
8065 if (LOCATION_LOCUS (saved_location
) != UNKNOWN_LOCATION
)
8066 gimple_set_location (try_
, saved_location
);
8068 gimple_set_location (try_
, EXPR_LOCATION (save_expr
));
8069 if (TREE_CODE (*expr_p
) == TRY_CATCH_EXPR
)
8070 gimple_try_set_catch_is_cleanup (try_
,
8071 TRY_CATCH_IS_CLEANUP (*expr_p
));
8072 gimplify_seq_add_stmt (pre_p
, try_
);
8077 case CLEANUP_POINT_EXPR
:
8078 ret
= gimplify_cleanup_point_expr (expr_p
, pre_p
);
8082 ret
= gimplify_target_expr (expr_p
, pre_p
, post_p
);
8088 gimple_seq handler
= NULL
;
8089 gimplify_and_add (CATCH_BODY (*expr_p
), &handler
);
8090 c
= gimple_build_catch (CATCH_TYPES (*expr_p
), handler
);
8091 gimplify_seq_add_stmt (pre_p
, c
);
8096 case EH_FILTER_EXPR
:
8099 gimple_seq failure
= NULL
;
8101 gimplify_and_add (EH_FILTER_FAILURE (*expr_p
), &failure
);
8102 ehf
= gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p
), failure
);
8103 gimple_set_no_warning (ehf
, TREE_NO_WARNING (*expr_p
));
8104 gimplify_seq_add_stmt (pre_p
, ehf
);
8111 enum gimplify_status r0
, r1
;
8112 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
,
8113 post_p
, is_gimple_val
, fb_rvalue
);
8114 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
,
8115 post_p
, is_gimple_val
, fb_rvalue
);
8116 TREE_SIDE_EFFECTS (*expr_p
) = 0;
8122 /* We get here when taking the address of a label. We mark
8123 the label as "forced"; meaning it can never be removed and
8124 it is a potential target for any computed goto. */
8125 FORCED_LABEL (*expr_p
) = 1;
8129 case STATEMENT_LIST
:
8130 ret
= gimplify_statement_list (expr_p
, pre_p
);
8133 case WITH_SIZE_EXPR
:
8135 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8136 post_p
== &internal_post
? NULL
: post_p
,
8137 gimple_test_f
, fallback
);
8138 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
8139 is_gimple_val
, fb_rvalue
);
8146 ret
= gimplify_var_or_parm_decl (expr_p
);
8150 /* When within an OpenMP context, notice uses of variables. */
8151 if (gimplify_omp_ctxp
)
8152 omp_notice_variable (gimplify_omp_ctxp
, *expr_p
, true);
8157 /* Allow callbacks into the gimplifier during optimization. */
8162 gimplify_omp_parallel (expr_p
, pre_p
);
8167 gimplify_omp_task (expr_p
, pre_p
);
8175 case OMP_DISTRIBUTE
:
8176 ret
= gimplify_omp_for (expr_p
, pre_p
);
8182 case OMP_TARGET_DATA
:
8184 gimplify_omp_workshare (expr_p
, pre_p
);
8188 case OMP_TARGET_UPDATE
:
8189 gimplify_omp_target_update (expr_p
, pre_p
);
8199 gimple_seq body
= NULL
;
8202 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
8203 switch (TREE_CODE (*expr_p
))
8206 g
= gimple_build_omp_section (body
);
8209 g
= gimple_build_omp_master (body
);
8213 gimple_seq cleanup
= NULL
;
8215 = builtin_decl_explicit (BUILT_IN_GOMP_TASKGROUP_END
);
8216 g
= gimple_build_call (fn
, 0);
8217 gimple_seq_add_stmt (&cleanup
, g
);
8218 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
8220 gimple_seq_add_stmt (&body
, g
);
8221 g
= gimple_build_omp_taskgroup (body
);
8225 g
= gimple_build_omp_ordered (body
);
8228 g
= gimple_build_omp_critical (body
,
8229 OMP_CRITICAL_NAME (*expr_p
));
8234 gimplify_seq_add_stmt (pre_p
, g
);
8240 case OMP_ATOMIC_READ
:
8241 case OMP_ATOMIC_CAPTURE_OLD
:
8242 case OMP_ATOMIC_CAPTURE_NEW
:
8243 ret
= gimplify_omp_atomic (expr_p
, pre_p
);
8246 case TRANSACTION_EXPR
:
8247 ret
= gimplify_transaction (expr_p
, pre_p
);
8250 case TRUTH_AND_EXPR
:
8252 case TRUTH_XOR_EXPR
:
8254 tree orig_type
= TREE_TYPE (*expr_p
);
8255 tree new_type
, xop0
, xop1
;
8256 *expr_p
= gimple_boolify (*expr_p
);
8257 new_type
= TREE_TYPE (*expr_p
);
8258 if (!useless_type_conversion_p (orig_type
, new_type
))
8260 *expr_p
= fold_convert_loc (input_location
, orig_type
, *expr_p
);
8265 /* Boolified binary truth expressions are semantically equivalent
8266 to bitwise binary expressions. Canonicalize them to the
8268 switch (TREE_CODE (*expr_p
))
8270 case TRUTH_AND_EXPR
:
8271 TREE_SET_CODE (*expr_p
, BIT_AND_EXPR
);
8274 TREE_SET_CODE (*expr_p
, BIT_IOR_EXPR
);
8276 case TRUTH_XOR_EXPR
:
8277 TREE_SET_CODE (*expr_p
, BIT_XOR_EXPR
);
8282 /* Now make sure that operands have compatible type to
8283 expression's new_type. */
8284 xop0
= TREE_OPERAND (*expr_p
, 0);
8285 xop1
= TREE_OPERAND (*expr_p
, 1);
8286 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop0
)))
8287 TREE_OPERAND (*expr_p
, 0) = fold_convert_loc (input_location
,
8290 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop1
)))
8291 TREE_OPERAND (*expr_p
, 1) = fold_convert_loc (input_location
,
8294 /* Continue classified as tcc_binary. */
8301 /* Classified as tcc_expression. */
8304 case POINTER_PLUS_EXPR
:
8306 enum gimplify_status r0
, r1
;
8307 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8308 post_p
, is_gimple_val
, fb_rvalue
);
8309 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
8310 post_p
, is_gimple_val
, fb_rvalue
);
8311 recalculate_side_effects (*expr_p
);
8313 /* Convert &X + CST to invariant &MEM[&X, CST]. Do this
8314 after gimplifying operands - this is similar to how
8315 it would be folding all gimplified stmts on creation
8316 to have them canonicalized, which is what we eventually
8317 should do anyway. */
8318 if (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == INTEGER_CST
8319 && is_gimple_min_invariant (TREE_OPERAND (*expr_p
, 0)))
8321 *expr_p
= build_fold_addr_expr_with_type_loc
8323 fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (*expr_p
)),
8324 TREE_OPERAND (*expr_p
, 0),
8325 fold_convert (ptr_type_node
,
8326 TREE_OPERAND (*expr_p
, 1))),
8327 TREE_TYPE (*expr_p
));
8328 ret
= MIN (ret
, GS_OK
);
8333 case CILK_SYNC_STMT
:
8335 if (!fn_contains_cilk_spawn_p (cfun
))
8337 error_at (EXPR_LOCATION (*expr_p
),
8338 "expected %<_Cilk_spawn%> before %<_Cilk_sync%>");
8343 gimplify_cilk_sync (expr_p
, pre_p
);
8350 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p
)))
8352 case tcc_comparison
:
8353 /* Handle comparison of objects of non scalar mode aggregates
8354 with a call to memcmp. It would be nice to only have to do
8355 this for variable-sized objects, but then we'd have to allow
8356 the same nest of reference nodes we allow for MODIFY_EXPR and
8359 Compare scalar mode aggregates as scalar mode values. Using
8360 memcmp for them would be very inefficient at best, and is
8361 plain wrong if bitfields are involved. */
8363 tree type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 1));
8365 /* Vector comparisons need no boolification. */
8366 if (TREE_CODE (type
) == VECTOR_TYPE
)
8368 else if (!AGGREGATE_TYPE_P (type
))
8370 tree org_type
= TREE_TYPE (*expr_p
);
8371 *expr_p
= gimple_boolify (*expr_p
);
8372 if (!useless_type_conversion_p (org_type
,
8373 TREE_TYPE (*expr_p
)))
8375 *expr_p
= fold_convert_loc (input_location
,
8382 else if (TYPE_MODE (type
) != BLKmode
)
8383 ret
= gimplify_scalar_mode_aggregate_compare (expr_p
);
8385 ret
= gimplify_variable_sized_compare (expr_p
);
8390 /* If *EXPR_P does not need to be special-cased, handle it
8391 according to its class. */
8393 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8394 post_p
, is_gimple_val
, fb_rvalue
);
8400 enum gimplify_status r0
, r1
;
8402 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8403 post_p
, is_gimple_val
, fb_rvalue
);
8404 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
8405 post_p
, is_gimple_val
, fb_rvalue
);
8413 enum gimplify_status r0
, r1
, r2
;
8415 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8416 post_p
, is_gimple_val
, fb_rvalue
);
8417 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
8418 post_p
, is_gimple_val
, fb_rvalue
);
8419 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
8420 post_p
, is_gimple_val
, fb_rvalue
);
8422 ret
= MIN (MIN (r0
, r1
), r2
);
8426 case tcc_declaration
:
8429 goto dont_recalculate
;
8435 recalculate_side_effects (*expr_p
);
8441 gcc_assert (*expr_p
|| ret
!= GS_OK
);
8443 while (ret
== GS_OK
);
8445 /* If we encountered an error_mark somewhere nested inside, either
8446 stub out the statement or propagate the error back out. */
8447 if (ret
== GS_ERROR
)
8454 /* This was only valid as a return value from the langhook, which
8455 we handled. Make sure it doesn't escape from any other context. */
8456 gcc_assert (ret
!= GS_UNHANDLED
);
8458 if (fallback
== fb_none
&& *expr_p
&& !is_gimple_stmt (*expr_p
))
8460 /* We aren't looking for a value, and we don't have a valid
8461 statement. If it doesn't have side-effects, throw it away. */
8462 if (!TREE_SIDE_EFFECTS (*expr_p
))
8464 else if (!TREE_THIS_VOLATILE (*expr_p
))
8466 /* This is probably a _REF that contains something nested that
8467 has side effects. Recurse through the operands to find it. */
8468 enum tree_code code
= TREE_CODE (*expr_p
);
8475 case VIEW_CONVERT_EXPR
:
8476 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8477 gimple_test_f
, fallback
);
8481 case ARRAY_RANGE_REF
:
8482 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8483 gimple_test_f
, fallback
);
8484 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
8485 gimple_test_f
, fallback
);
8489 /* Anything else with side-effects must be converted to
8490 a valid statement before we get here. */
8496 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p
))
8497 && TYPE_MODE (TREE_TYPE (*expr_p
)) != BLKmode
)
8499 /* Historically, the compiler has treated a bare reference
8500 to a non-BLKmode volatile lvalue as forcing a load. */
8501 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p
));
8503 /* Normally, we do not want to create a temporary for a
8504 TREE_ADDRESSABLE type because such a type should not be
8505 copied by bitwise-assignment. However, we make an
8506 exception here, as all we are doing here is ensuring that
8507 we read the bytes that make up the type. We use
8508 create_tmp_var_raw because create_tmp_var will abort when
8509 given a TREE_ADDRESSABLE type. */
8510 tree tmp
= create_tmp_var_raw (type
, "vol");
8511 gimple_add_tmp_var (tmp
);
8512 gimplify_assign (tmp
, *expr_p
, pre_p
);
8516 /* We can't do anything useful with a volatile reference to
8517 an incomplete type, so just throw it away. Likewise for
8518 a BLKmode type, since any implicit inner load should
8519 already have been turned into an explicit one by the
8520 gimplification process. */
8524 /* If we are gimplifying at the statement level, we're done. Tack
8525 everything together and return. */
8526 if (fallback
== fb_none
|| is_statement
)
8528 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
8529 it out for GC to reclaim it. */
8530 *expr_p
= NULL_TREE
;
8532 if (!gimple_seq_empty_p (internal_pre
)
8533 || !gimple_seq_empty_p (internal_post
))
8535 gimplify_seq_add_seq (&internal_pre
, internal_post
);
8536 gimplify_seq_add_seq (pre_p
, internal_pre
);
8539 /* The result of gimplifying *EXPR_P is going to be the last few
8540 statements in *PRE_P and *POST_P. Add location information
8541 to all the statements that were added by the gimplification
8543 if (!gimple_seq_empty_p (*pre_p
))
8544 annotate_all_with_location_after (*pre_p
, pre_last_gsi
, input_location
);
8546 if (!gimple_seq_empty_p (*post_p
))
8547 annotate_all_with_location_after (*post_p
, post_last_gsi
,
8553 #ifdef ENABLE_GIMPLE_CHECKING
8556 enum tree_code code
= TREE_CODE (*expr_p
);
8557 /* These expressions should already be in gimple IR form. */
8558 gcc_assert (code
!= MODIFY_EXPR
8560 && code
!= BIND_EXPR
8561 && code
!= CATCH_EXPR
8562 && (code
!= COND_EXPR
|| gimplify_ctxp
->allow_rhs_cond_expr
)
8563 && code
!= EH_FILTER_EXPR
8564 && code
!= GOTO_EXPR
8565 && code
!= LABEL_EXPR
8566 && code
!= LOOP_EXPR
8567 && code
!= SWITCH_EXPR
8568 && code
!= TRY_FINALLY_EXPR
8569 && code
!= OMP_CRITICAL
8571 && code
!= OMP_MASTER
8572 && code
!= OMP_TASKGROUP
8573 && code
!= OMP_ORDERED
8574 && code
!= OMP_PARALLEL
8575 && code
!= OMP_SECTIONS
8576 && code
!= OMP_SECTION
8577 && code
!= OMP_SINGLE
);
8581 /* Otherwise we're gimplifying a subexpression, so the resulting
8582 value is interesting. If it's a valid operand that matches
8583 GIMPLE_TEST_F, we're done. Unless we are handling some
8584 post-effects internally; if that's the case, we need to copy into
8585 a temporary before adding the post-effects to POST_P. */
8586 if (gimple_seq_empty_p (internal_post
) && (*gimple_test_f
) (*expr_p
))
8589 /* Otherwise, we need to create a new temporary for the gimplified
8592 /* We can't return an lvalue if we have an internal postqueue. The
8593 object the lvalue refers to would (probably) be modified by the
8594 postqueue; we need to copy the value out first, which means an
8596 if ((fallback
& fb_lvalue
)
8597 && gimple_seq_empty_p (internal_post
)
8598 && is_gimple_addressable (*expr_p
))
8600 /* An lvalue will do. Take the address of the expression, store it
8601 in a temporary, and replace the expression with an INDIRECT_REF of
8603 tmp
= build_fold_addr_expr_loc (input_location
, *expr_p
);
8604 gimplify_expr (&tmp
, pre_p
, post_p
, is_gimple_reg
, fb_rvalue
);
8605 *expr_p
= build_simple_mem_ref (tmp
);
8607 else if ((fallback
& fb_rvalue
) && is_gimple_reg_rhs_or_call (*expr_p
))
8609 /* An rvalue will do. Assign the gimplified expression into a
8610 new temporary TMP and replace the original expression with
8611 TMP. First, make sure that the expression has a type so that
8612 it can be assigned into a temporary. */
8613 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p
)));
8614 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
8618 #ifdef ENABLE_GIMPLE_CHECKING
8619 if (!(fallback
& fb_mayfail
))
8621 fprintf (stderr
, "gimplification failed:\n");
8622 print_generic_expr (stderr
, *expr_p
, 0);
8623 debug_tree (*expr_p
);
8624 internal_error ("gimplification failed");
8627 gcc_assert (fallback
& fb_mayfail
);
8629 /* If this is an asm statement, and the user asked for the
8630 impossible, don't die. Fail and let gimplify_asm_expr
8636 /* Make sure the temporary matches our predicate. */
8637 gcc_assert ((*gimple_test_f
) (*expr_p
));
8639 if (!gimple_seq_empty_p (internal_post
))
8641 annotate_all_with_location (internal_post
, input_location
);
8642 gimplify_seq_add_seq (pre_p
, internal_post
);
8646 input_location
= saved_location
;
8650 /* Look through TYPE for variable-sized objects and gimplify each such
8651 size that we find. Add to LIST_P any statements generated. */
8654 gimplify_type_sizes (tree type
, gimple_seq
*list_p
)
8658 if (type
== NULL
|| type
== error_mark_node
)
8661 /* We first do the main variant, then copy into any other variants. */
8662 type
= TYPE_MAIN_VARIANT (type
);
8664 /* Avoid infinite recursion. */
8665 if (TYPE_SIZES_GIMPLIFIED (type
))
8668 TYPE_SIZES_GIMPLIFIED (type
) = 1;
8670 switch (TREE_CODE (type
))
8676 case FIXED_POINT_TYPE
:
8677 gimplify_one_sizepos (&TYPE_MIN_VALUE (type
), list_p
);
8678 gimplify_one_sizepos (&TYPE_MAX_VALUE (type
), list_p
);
8680 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8682 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (type
);
8683 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (type
);
8688 /* These types may not have declarations, so handle them here. */
8689 gimplify_type_sizes (TREE_TYPE (type
), list_p
);
8690 gimplify_type_sizes (TYPE_DOMAIN (type
), list_p
);
8691 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
8692 with assigned stack slots, for -O1+ -g they should be tracked
8694 if (!(TYPE_NAME (type
)
8695 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
8696 && DECL_IGNORED_P (TYPE_NAME (type
)))
8697 && TYPE_DOMAIN (type
)
8698 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type
)))
8700 t
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
8701 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8702 DECL_IGNORED_P (t
) = 0;
8703 t
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
8704 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8705 DECL_IGNORED_P (t
) = 0;
8711 case QUAL_UNION_TYPE
:
8712 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
8713 if (TREE_CODE (field
) == FIELD_DECL
)
8715 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field
), list_p
);
8716 gimplify_one_sizepos (&DECL_SIZE (field
), list_p
);
8717 gimplify_one_sizepos (&DECL_SIZE_UNIT (field
), list_p
);
8718 gimplify_type_sizes (TREE_TYPE (field
), list_p
);
8723 case REFERENCE_TYPE
:
8724 /* We used to recurse on the pointed-to type here, which turned out to
8725 be incorrect because its definition might refer to variables not
8726 yet initialized at this point if a forward declaration is involved.
8728 It was actually useful for anonymous pointed-to types to ensure
8729 that the sizes evaluation dominates every possible later use of the
8730 values. Restricting to such types here would be safe since there
8731 is no possible forward declaration around, but would introduce an
8732 undesirable middle-end semantic to anonymity. We then defer to
8733 front-ends the responsibility of ensuring that the sizes are
8734 evaluated both early and late enough, e.g. by attaching artificial
8735 type declarations to the tree. */
8742 gimplify_one_sizepos (&TYPE_SIZE (type
), list_p
);
8743 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type
), list_p
);
8745 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8747 TYPE_SIZE (t
) = TYPE_SIZE (type
);
8748 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (type
);
8749 TYPE_SIZES_GIMPLIFIED (t
) = 1;
8753 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
8754 a size or position, has had all of its SAVE_EXPRs evaluated.
8755 We add any required statements to *STMT_P. */
8758 gimplify_one_sizepos (tree
*expr_p
, gimple_seq
*stmt_p
)
8760 tree expr
= *expr_p
;
8762 /* We don't do anything if the value isn't there, is constant, or contains
8763 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
8764 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
8765 will want to replace it with a new variable, but that will cause problems
8766 if this type is from outside the function. It's OK to have that here. */
8767 if (is_gimple_sizepos (expr
))
8770 *expr_p
= unshare_expr (expr
);
8772 gimplify_expr (expr_p
, stmt_p
, NULL
, is_gimple_val
, fb_rvalue
);
8775 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
8776 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
8777 is true, also gimplify the parameters. */
8780 gimplify_body (tree fndecl
, bool do_parms
)
8782 location_t saved_location
= input_location
;
8783 gimple_seq parm_stmts
, seq
;
8785 struct cgraph_node
*cgn
;
8787 timevar_push (TV_TREE_GIMPLIFY
);
8789 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
8791 default_rtl_profile ();
8793 gcc_assert (gimplify_ctxp
== NULL
);
8794 push_gimplify_context ();
8798 gcc_assert (gimplify_omp_ctxp
== NULL
);
8799 if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (fndecl
)))
8800 gimplify_omp_ctxp
= new_omp_context (ORT_TARGET
);
8803 /* Unshare most shared trees in the body and in that of any nested functions.
8804 It would seem we don't have to do this for nested functions because
8805 they are supposed to be output and then the outer function gimplified
8806 first, but the g++ front end doesn't always do it that way. */
8807 unshare_body (fndecl
);
8808 unvisit_body (fndecl
);
8810 cgn
= cgraph_node::get (fndecl
);
8811 if (cgn
&& cgn
->origin
)
8812 nonlocal_vlas
= new hash_set
<tree
>;
8814 /* Make sure input_location isn't set to something weird. */
8815 input_location
= DECL_SOURCE_LOCATION (fndecl
);
8817 /* Resolve callee-copies. This has to be done before processing
8818 the body so that DECL_VALUE_EXPR gets processed correctly. */
8819 parm_stmts
= do_parms
? gimplify_parameters () : NULL
;
8821 /* Gimplify the function's body. */
8823 gimplify_stmt (&DECL_SAVED_TREE (fndecl
), &seq
);
8824 outer_bind
= gimple_seq_first_stmt (seq
);
8827 outer_bind
= gimple_build_nop ();
8828 gimplify_seq_add_stmt (&seq
, outer_bind
);
8831 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
8832 not the case, wrap everything in a GIMPLE_BIND to make it so. */
8833 if (gimple_code (outer_bind
) == GIMPLE_BIND
8834 && gimple_seq_first (seq
) == gimple_seq_last (seq
))
8837 outer_bind
= gimple_build_bind (NULL_TREE
, seq
, NULL
);
8839 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
8841 /* If we had callee-copies statements, insert them at the beginning
8842 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
8843 if (!gimple_seq_empty_p (parm_stmts
))
8847 gimplify_seq_add_seq (&parm_stmts
, gimple_bind_body (outer_bind
));
8848 gimple_bind_set_body (outer_bind
, parm_stmts
);
8850 for (parm
= DECL_ARGUMENTS (current_function_decl
);
8851 parm
; parm
= DECL_CHAIN (parm
))
8852 if (DECL_HAS_VALUE_EXPR_P (parm
))
8854 DECL_HAS_VALUE_EXPR_P (parm
) = 0;
8855 DECL_IGNORED_P (parm
) = 0;
8861 if (nonlocal_vla_vars
)
8863 /* tree-nested.c may later on call declare_vars (..., true);
8864 which relies on BLOCK_VARS chain to be the tail of the
8865 gimple_bind_vars chain. Ensure we don't violate that
8867 if (gimple_bind_block (outer_bind
)
8868 == DECL_INITIAL (current_function_decl
))
8869 declare_vars (nonlocal_vla_vars
, outer_bind
, true);
8871 BLOCK_VARS (DECL_INITIAL (current_function_decl
))
8872 = chainon (BLOCK_VARS (DECL_INITIAL (current_function_decl
)),
8874 nonlocal_vla_vars
= NULL_TREE
;
8876 delete nonlocal_vlas
;
8877 nonlocal_vlas
= NULL
;
8880 if ((flag_openmp
|| flag_openmp_simd
) && gimplify_omp_ctxp
)
8882 delete_omp_context (gimplify_omp_ctxp
);
8883 gimplify_omp_ctxp
= NULL
;
8886 pop_gimplify_context (outer_bind
);
8887 gcc_assert (gimplify_ctxp
== NULL
);
8889 #ifdef ENABLE_CHECKING
8891 verify_gimple_in_seq (gimple_bind_body (outer_bind
));
8894 timevar_pop (TV_TREE_GIMPLIFY
);
8895 input_location
= saved_location
;
8900 typedef char *char_p
; /* For DEF_VEC_P. */
8902 /* Return whether we should exclude FNDECL from instrumentation. */
8905 flag_instrument_functions_exclude_p (tree fndecl
)
8909 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_functions
;
8910 if (v
&& v
->length () > 0)
8916 name
= lang_hooks
.decl_printable_name (fndecl
, 0);
8917 FOR_EACH_VEC_ELT (*v
, i
, s
)
8918 if (strstr (name
, s
) != NULL
)
8922 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_files
;
8923 if (v
&& v
->length () > 0)
8929 name
= DECL_SOURCE_FILE (fndecl
);
8930 FOR_EACH_VEC_ELT (*v
, i
, s
)
8931 if (strstr (name
, s
) != NULL
)
8938 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
8939 node for the function we want to gimplify.
8941 Return the sequence of GIMPLE statements corresponding to the body
8945 gimplify_function_tree (tree fndecl
)
8951 gcc_assert (!gimple_body (fndecl
));
8953 if (DECL_STRUCT_FUNCTION (fndecl
))
8954 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
8956 push_struct_function (fndecl
);
8958 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
8960 /* Preliminarily mark non-addressed complex variables as eligible
8961 for promotion to gimple registers. We'll transform their uses
8963 if ((TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
8964 || TREE_CODE (TREE_TYPE (parm
)) == VECTOR_TYPE
)
8965 && !TREE_THIS_VOLATILE (parm
)
8966 && !needs_to_live_in_memory (parm
))
8967 DECL_GIMPLE_REG_P (parm
) = 1;
8970 ret
= DECL_RESULT (fndecl
);
8971 if ((TREE_CODE (TREE_TYPE (ret
)) == COMPLEX_TYPE
8972 || TREE_CODE (TREE_TYPE (ret
)) == VECTOR_TYPE
)
8973 && !needs_to_live_in_memory (ret
))
8974 DECL_GIMPLE_REG_P (ret
) = 1;
8976 bind
= gimplify_body (fndecl
, true);
8978 /* The tree body of the function is no longer needed, replace it
8979 with the new GIMPLE body. */
8981 gimple_seq_add_stmt (&seq
, bind
);
8982 gimple_set_body (fndecl
, seq
);
8984 /* If we're instrumenting function entry/exit, then prepend the call to
8985 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
8986 catch the exit hook. */
8987 /* ??? Add some way to ignore exceptions for this TFE. */
8988 if (flag_instrument_function_entry_exit
8989 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
)
8990 && !flag_instrument_functions_exclude_p (fndecl
))
8995 gimple_seq cleanup
= NULL
, body
= NULL
;
8999 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
9000 call
= gimple_build_call (x
, 1, integer_zero_node
);
9001 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
9002 gimple_call_set_lhs (call
, tmp_var
);
9003 gimplify_seq_add_stmt (&cleanup
, call
);
9004 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT
);
9005 call
= gimple_build_call (x
, 2,
9006 build_fold_addr_expr (current_function_decl
),
9008 gimplify_seq_add_stmt (&cleanup
, call
);
9009 tf
= gimple_build_try (seq
, cleanup
, GIMPLE_TRY_FINALLY
);
9011 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
9012 call
= gimple_build_call (x
, 1, integer_zero_node
);
9013 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
9014 gimple_call_set_lhs (call
, tmp_var
);
9015 gimplify_seq_add_stmt (&body
, call
);
9016 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER
);
9017 call
= gimple_build_call (x
, 2,
9018 build_fold_addr_expr (current_function_decl
),
9020 gimplify_seq_add_stmt (&body
, call
);
9021 gimplify_seq_add_stmt (&body
, tf
);
9022 new_bind
= gimple_build_bind (NULL
, body
, gimple_bind_block (bind
));
9023 /* Clear the block for BIND, since it is no longer directly inside
9024 the function, but within a try block. */
9025 gimple_bind_set_block (bind
, NULL
);
9027 /* Replace the current function body with the body
9028 wrapped in the try/finally TF. */
9030 gimple_seq_add_stmt (&seq
, new_bind
);
9031 gimple_set_body (fndecl
, seq
);
9034 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
9035 cfun
->curr_properties
= PROP_gimple_any
;
9040 /* Return a dummy expression of type TYPE in order to keep going after an
9044 dummy_object (tree type
)
9046 tree t
= build_int_cst (build_pointer_type (type
), 0);
9047 return build2 (MEM_REF
, type
, t
, t
);
9050 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
9051 builtin function, but a very special sort of operator. */
9053 enum gimplify_status
9054 gimplify_va_arg_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
9056 tree promoted_type
, have_va_type
;
9057 tree valist
= TREE_OPERAND (*expr_p
, 0);
9058 tree type
= TREE_TYPE (*expr_p
);
9060 location_t loc
= EXPR_LOCATION (*expr_p
);
9062 /* Verify that valist is of the proper type. */
9063 have_va_type
= TREE_TYPE (valist
);
9064 if (have_va_type
== error_mark_node
)
9066 have_va_type
= targetm
.canonical_va_list_type (have_va_type
);
9068 if (have_va_type
== NULL_TREE
)
9070 error_at (loc
, "first argument to %<va_arg%> not of type %<va_list%>");
9074 /* Generate a diagnostic for requesting data of a type that cannot
9075 be passed through `...' due to type promotion at the call site. */
9076 if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
9079 static bool gave_help
;
9082 /* Unfortunately, this is merely undefined, rather than a constraint
9083 violation, so we cannot make this an error. If this call is never
9084 executed, the program is still strictly conforming. */
9085 warned
= warning_at (loc
, 0,
9086 "%qT is promoted to %qT when passed through %<...%>",
9087 type
, promoted_type
);
9088 if (!gave_help
&& warned
)
9091 inform (loc
, "(so you should pass %qT not %qT to %<va_arg%>)",
9092 promoted_type
, type
);
9095 /* We can, however, treat "undefined" any way we please.
9096 Call abort to encourage the user to fix the program. */
9098 inform (loc
, "if this code is reached, the program will abort");
9099 /* Before the abort, allow the evaluation of the va_list
9100 expression to exit or longjmp. */
9101 gimplify_and_add (valist
, pre_p
);
9102 t
= build_call_expr_loc (loc
,
9103 builtin_decl_implicit (BUILT_IN_TRAP
), 0);
9104 gimplify_and_add (t
, pre_p
);
9106 /* This is dead code, but go ahead and finish so that the
9107 mode of the result comes out right. */
9108 *expr_p
= dummy_object (type
);
9113 /* Make it easier for the backends by protecting the valist argument
9114 from multiple evaluations. */
9115 if (TREE_CODE (have_va_type
) == ARRAY_TYPE
)
9117 /* For this case, the backends will be expecting a pointer to
9118 TREE_TYPE (abi), but it's possible we've
9119 actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
9121 if (TREE_CODE (TREE_TYPE (valist
)) == ARRAY_TYPE
)
9123 tree p1
= build_pointer_type (TREE_TYPE (have_va_type
));
9124 valist
= fold_convert_loc (loc
, p1
,
9125 build_fold_addr_expr_loc (loc
, valist
));
9128 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
9131 gimplify_expr (&valist
, pre_p
, post_p
, is_gimple_min_lval
, fb_lvalue
);
9133 if (!targetm
.gimplify_va_arg_expr
)
9134 /* FIXME: Once most targets are converted we should merely
9135 assert this is non-null. */
9138 *expr_p
= targetm
.gimplify_va_arg_expr (valist
, type
, pre_p
, post_p
);
9143 /* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
9145 DST/SRC are the destination and source respectively. You can pass
9146 ungimplified trees in DST or SRC, in which case they will be
9147 converted to a gimple operand if necessary.
9149 This function returns the newly created GIMPLE_ASSIGN tuple. */
9152 gimplify_assign (tree dst
, tree src
, gimple_seq
*seq_p
)
9154 tree t
= build2 (MODIFY_EXPR
, TREE_TYPE (dst
), dst
, src
);
9155 gimplify_and_add (t
, seq_p
);
9157 return gimple_seq_last_stmt (*seq_p
);
9161 gimplify_hasher::hash (const value_type
*p
)
9164 return iterative_hash_expr (t
, 0);
9168 gimplify_hasher::equal (const value_type
*p1
, const compare_type
*p2
)
9172 enum tree_code code
= TREE_CODE (t1
);
9174 if (TREE_CODE (t2
) != code
9175 || TREE_TYPE (t1
) != TREE_TYPE (t2
))
9178 if (!operand_equal_p (t1
, t2
, 0))
9181 #ifdef ENABLE_CHECKING
9182 /* Only allow them to compare equal if they also hash equal; otherwise
9183 results are nondeterminate, and we fail bootstrap comparison. */
9184 gcc_assert (hash (p1
) == hash (p2
));