1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002-2015 Free Software Foundation, Inc.
4 Major work done by Sebastian Pop <s.pop@laposte.net>,
5 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
30 #include "gimple-predict.h"
34 #include "fold-const.h"
36 #include "insn-config.h"
45 #include "internal-fn.h"
46 #include "gimple-fold.h"
49 #include "gimple-iterator.h"
50 #include "stor-layout.h"
51 #include "print-tree.h"
52 #include "tree-iterator.h"
53 #include "tree-inline.h"
54 #include "tree-pretty-print.h"
55 #include "langhooks.h"
59 #include "diagnostic-core.h"
61 #include "splay-tree.h"
63 #include "gimple-low.h"
65 #include "gomp-constants.h"
66 #include "tree-dump.h"
68 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
69 #include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
72 enum gimplify_omp_var_data
78 GOVD_FIRSTPRIVATE
= 16,
79 GOVD_LASTPRIVATE
= 32,
83 GOVD_DEBUG_PRIVATE
= 512,
84 GOVD_PRIVATE_OUTER_REF
= 1024,
88 /* Flag for GOVD_MAP: don't copy back. */
89 GOVD_MAP_TO_ONLY
= 8192,
91 /* Flag for GOVD_LINEAR or GOVD_LASTPRIVATE: no outer reference. */
92 GOVD_LINEAR_LASTPRIVATE_NO_OUTER
= 16384,
94 GOVD_DATA_SHARE_CLASS
= (GOVD_SHARED
| GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
95 | GOVD_LASTPRIVATE
| GOVD_REDUCTION
| GOVD_LINEAR
105 ORT_COMBINED_PARALLEL
= 3,
109 ORT_COMBINED_TEAMS
= 9,
111 ORT_TARGET_DATA
= 16,
112 /* Data region with offloading. */
116 /* Gimplify hashtable helper. */
118 struct gimplify_hasher
: free_ptr_hash
<elt_t
>
120 static inline hashval_t
hash (const elt_t
*);
121 static inline bool equal (const elt_t
*, const elt_t
*);
126 struct gimplify_ctx
*prev_context
;
128 vec
<gbind
*> bind_expr_stack
;
130 gimple_seq conditional_cleanups
;
134 vec
<tree
> case_labels
;
135 /* The formal temporary table. Should this be persistent? */
136 hash_table
<gimplify_hasher
> *temp_htab
;
141 bool allow_rhs_cond_expr
;
142 bool in_cleanup_point_expr
;
145 struct gimplify_omp_ctx
147 struct gimplify_omp_ctx
*outer_context
;
148 splay_tree variables
;
149 hash_set
<tree
> *privatized_types
;
151 enum omp_clause_default_kind default_kind
;
152 enum omp_region_type region_type
;
157 static struct gimplify_ctx
*gimplify_ctxp
;
158 static struct gimplify_omp_ctx
*gimplify_omp_ctxp
;
160 /* Forward declaration. */
161 static enum gimplify_status
gimplify_compound_expr (tree
*, gimple_seq
*, bool);
163 /* Shorter alias name for the above function for use in gimplify.c
167 gimplify_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
169 gimple_seq_add_stmt_without_update (seq_p
, gs
);
172 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
173 NULL, a new sequence is allocated. This function is
174 similar to gimple_seq_add_seq, but does not scan the operands.
175 During gimplification, we need to manipulate statement sequences
176 before the def/use vectors have been constructed. */
179 gimplify_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
181 gimple_stmt_iterator si
;
186 si
= gsi_last (*dst_p
);
187 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
191 /* Pointer to a list of allocated gimplify_ctx structs to be used for pushing
192 and popping gimplify contexts. */
194 static struct gimplify_ctx
*ctx_pool
= NULL
;
196 /* Return a gimplify context struct from the pool. */
198 static inline struct gimplify_ctx
*
201 struct gimplify_ctx
* c
= ctx_pool
;
204 ctx_pool
= c
->prev_context
;
206 c
= XNEW (struct gimplify_ctx
);
208 memset (c
, '\0', sizeof (*c
));
212 /* Put gimplify context C back into the pool. */
215 ctx_free (struct gimplify_ctx
*c
)
217 c
->prev_context
= ctx_pool
;
221 /* Free allocated ctx stack memory. */
224 free_gimplify_stack (void)
226 struct gimplify_ctx
*c
;
228 while ((c
= ctx_pool
))
230 ctx_pool
= c
->prev_context
;
236 /* Set up a context for the gimplifier. */
239 push_gimplify_context (bool in_ssa
, bool rhs_cond_ok
)
241 struct gimplify_ctx
*c
= ctx_alloc ();
243 c
->prev_context
= gimplify_ctxp
;
245 gimplify_ctxp
->into_ssa
= in_ssa
;
246 gimplify_ctxp
->allow_rhs_cond_expr
= rhs_cond_ok
;
249 /* Tear down a context for the gimplifier. If BODY is non-null, then
250 put the temporaries into the outer BIND_EXPR. Otherwise, put them
253 BODY is not a sequence, but the first tuple in a sequence. */
256 pop_gimplify_context (gimple body
)
258 struct gimplify_ctx
*c
= gimplify_ctxp
;
261 && (!c
->bind_expr_stack
.exists ()
262 || c
->bind_expr_stack
.is_empty ()));
263 c
->bind_expr_stack
.release ();
264 gimplify_ctxp
= c
->prev_context
;
267 declare_vars (c
->temps
, body
, false);
269 record_vars (c
->temps
);
276 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
279 gimple_push_bind_expr (gbind
*bind_stmt
)
281 gimplify_ctxp
->bind_expr_stack
.reserve (8);
282 gimplify_ctxp
->bind_expr_stack
.safe_push (bind_stmt
);
285 /* Pop the first element off the stack of bindings. */
288 gimple_pop_bind_expr (void)
290 gimplify_ctxp
->bind_expr_stack
.pop ();
293 /* Return the first element of the stack of bindings. */
296 gimple_current_bind_expr (void)
298 return gimplify_ctxp
->bind_expr_stack
.last ();
301 /* Return the stack of bindings created during gimplification. */
304 gimple_bind_expr_stack (void)
306 return gimplify_ctxp
->bind_expr_stack
;
309 /* Return true iff there is a COND_EXPR between us and the innermost
310 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
313 gimple_conditional_context (void)
315 return gimplify_ctxp
->conditions
> 0;
318 /* Note that we've entered a COND_EXPR. */
321 gimple_push_condition (void)
323 #ifdef ENABLE_GIMPLE_CHECKING
324 if (gimplify_ctxp
->conditions
== 0)
325 gcc_assert (gimple_seq_empty_p (gimplify_ctxp
->conditional_cleanups
));
327 ++(gimplify_ctxp
->conditions
);
330 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
331 now, add any conditional cleanups we've seen to the prequeue. */
334 gimple_pop_condition (gimple_seq
*pre_p
)
336 int conds
= --(gimplify_ctxp
->conditions
);
338 gcc_assert (conds
>= 0);
341 gimplify_seq_add_seq (pre_p
, gimplify_ctxp
->conditional_cleanups
);
342 gimplify_ctxp
->conditional_cleanups
= NULL
;
346 /* A stable comparison routine for use with splay trees and DECLs. */
349 splay_tree_compare_decl_uid (splay_tree_key xa
, splay_tree_key xb
)
354 return DECL_UID (a
) - DECL_UID (b
);
357 /* Create a new omp construct that deals with variable remapping. */
359 static struct gimplify_omp_ctx
*
360 new_omp_context (enum omp_region_type region_type
)
362 struct gimplify_omp_ctx
*c
;
364 c
= XCNEW (struct gimplify_omp_ctx
);
365 c
->outer_context
= gimplify_omp_ctxp
;
366 c
->variables
= splay_tree_new (splay_tree_compare_decl_uid
, 0, 0);
367 c
->privatized_types
= new hash_set
<tree
>;
368 c
->location
= input_location
;
369 c
->region_type
= region_type
;
370 if ((region_type
& ORT_TASK
) == 0)
371 c
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
373 c
->default_kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
378 /* Destroy an omp construct that deals with variable remapping. */
381 delete_omp_context (struct gimplify_omp_ctx
*c
)
383 splay_tree_delete (c
->variables
);
384 delete c
->privatized_types
;
388 static void omp_add_variable (struct gimplify_omp_ctx
*, tree
, unsigned int);
389 static bool omp_notice_variable (struct gimplify_omp_ctx
*, tree
, bool);
391 /* Both gimplify the statement T and append it to *SEQ_P. This function
392 behaves exactly as gimplify_stmt, but you don't have to pass T as a
396 gimplify_and_add (tree t
, gimple_seq
*seq_p
)
398 gimplify_stmt (&t
, seq_p
);
401 /* Gimplify statement T into sequence *SEQ_P, and return the first
402 tuple in the sequence of generated tuples for this statement.
403 Return NULL if gimplifying T produced no tuples. */
406 gimplify_and_return_first (tree t
, gimple_seq
*seq_p
)
408 gimple_stmt_iterator last
= gsi_last (*seq_p
);
410 gimplify_and_add (t
, seq_p
);
412 if (!gsi_end_p (last
))
415 return gsi_stmt (last
);
418 return gimple_seq_first_stmt (*seq_p
);
421 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
422 LHS, or for a call argument. */
425 is_gimple_mem_rhs (tree t
)
427 /* If we're dealing with a renamable type, either source or dest must be
428 a renamed variable. */
429 if (is_gimple_reg_type (TREE_TYPE (t
)))
430 return is_gimple_val (t
);
432 return is_gimple_val (t
) || is_gimple_lvalue (t
);
435 /* Return true if T is a CALL_EXPR or an expression that can be
436 assigned to a temporary. Note that this predicate should only be
437 used during gimplification. See the rationale for this in
438 gimplify_modify_expr. */
441 is_gimple_reg_rhs_or_call (tree t
)
443 return (get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
444 || TREE_CODE (t
) == CALL_EXPR
);
447 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
448 this predicate should only be used during gimplification. See the
449 rationale for this in gimplify_modify_expr. */
452 is_gimple_mem_rhs_or_call (tree t
)
454 /* If we're dealing with a renamable type, either source or dest must be
455 a renamed variable. */
456 if (is_gimple_reg_type (TREE_TYPE (t
)))
457 return is_gimple_val (t
);
459 return (is_gimple_val (t
) || is_gimple_lvalue (t
)
460 || TREE_CODE (t
) == CALL_EXPR
);
463 /* Create a temporary with a name derived from VAL. Subroutine of
464 lookup_tmp_var; nobody else should call this function. */
467 create_tmp_from_val (tree val
)
469 /* Drop all qualifiers and address-space information from the value type. */
470 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (val
));
471 tree var
= create_tmp_var (type
, get_name (val
));
472 if (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
473 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
474 DECL_GIMPLE_REG_P (var
) = 1;
478 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
479 an existing expression temporary. */
482 lookup_tmp_var (tree val
, bool is_formal
)
486 /* If not optimizing, never really reuse a temporary. local-alloc
487 won't allocate any variable that is used in more than one basic
488 block, which means it will go into memory, causing much extra
489 work in reload and final and poorer code generation, outweighing
490 the extra memory allocation here. */
491 if (!optimize
|| !is_formal
|| TREE_SIDE_EFFECTS (val
))
492 ret
= create_tmp_from_val (val
);
499 if (!gimplify_ctxp
->temp_htab
)
500 gimplify_ctxp
->temp_htab
= new hash_table
<gimplify_hasher
> (1000);
501 slot
= gimplify_ctxp
->temp_htab
->find_slot (&elt
, INSERT
);
504 elt_p
= XNEW (elt_t
);
506 elt_p
->temp
= ret
= create_tmp_from_val (val
);
519 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
522 internal_get_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
527 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
528 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
529 gimplify_expr (&val
, pre_p
, post_p
, is_gimple_reg_rhs_or_call
,
532 if (gimplify_ctxp
->into_ssa
533 && is_gimple_reg_type (TREE_TYPE (val
)))
534 t
= make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val
)));
536 t
= lookup_tmp_var (val
, is_formal
);
538 mod
= build2 (INIT_EXPR
, TREE_TYPE (t
), t
, unshare_expr (val
));
540 SET_EXPR_LOCATION (mod
, EXPR_LOC_OR_LOC (val
, input_location
));
542 /* gimplify_modify_expr might want to reduce this further. */
543 gimplify_and_add (mod
, pre_p
);
549 /* Return a formal temporary variable initialized with VAL. PRE_P is as
550 in gimplify_expr. Only use this function if:
552 1) The value of the unfactored expression represented by VAL will not
553 change between the initialization and use of the temporary, and
554 2) The temporary will not be otherwise modified.
556 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
557 and #2 means it is inappropriate for && temps.
559 For other cases, use get_initialized_tmp_var instead. */
562 get_formal_tmp_var (tree val
, gimple_seq
*pre_p
)
564 return internal_get_tmp_var (val
, pre_p
, NULL
, true);
567 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
568 are as in gimplify_expr. */
571 get_initialized_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
573 return internal_get_tmp_var (val
, pre_p
, post_p
, false);
576 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
577 generate debug info for them; otherwise don't. */
580 declare_vars (tree vars
, gimple gs
, bool debug_info
)
587 gbind
*scope
= as_a
<gbind
*> (gs
);
589 temps
= nreverse (last
);
591 block
= gimple_bind_block (scope
);
592 gcc_assert (!block
|| TREE_CODE (block
) == BLOCK
);
593 if (!block
|| !debug_info
)
595 DECL_CHAIN (last
) = gimple_bind_vars (scope
);
596 gimple_bind_set_vars (scope
, temps
);
600 /* We need to attach the nodes both to the BIND_EXPR and to its
601 associated BLOCK for debugging purposes. The key point here
602 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
603 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
604 if (BLOCK_VARS (block
))
605 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), temps
);
608 gimple_bind_set_vars (scope
,
609 chainon (gimple_bind_vars (scope
), temps
));
610 BLOCK_VARS (block
) = temps
;
616 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
617 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
618 no such upper bound can be obtained. */
621 force_constant_size (tree var
)
623 /* The only attempt we make is by querying the maximum size of objects
624 of the variable's type. */
626 HOST_WIDE_INT max_size
;
628 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
630 max_size
= max_int_size_in_bytes (TREE_TYPE (var
));
632 gcc_assert (max_size
>= 0);
635 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var
)), max_size
);
637 = build_int_cst (TREE_TYPE (DECL_SIZE (var
)), max_size
* BITS_PER_UNIT
);
640 /* Push the temporary variable TMP into the current binding. */
643 gimple_add_tmp_var_fn (struct function
*fn
, tree tmp
)
645 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
647 /* Later processing assumes that the object size is constant, which might
648 not be true at this point. Force the use of a constant upper bound in
650 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (tmp
)))
651 force_constant_size (tmp
);
653 DECL_CONTEXT (tmp
) = fn
->decl
;
654 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
656 record_vars_into (tmp
, fn
->decl
);
659 /* Push the temporary variable TMP into the current binding. */
662 gimple_add_tmp_var (tree tmp
)
664 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
666 /* Later processing assumes that the object size is constant, which might
667 not be true at this point. Force the use of a constant upper bound in
669 if (!tree_fits_uhwi_p (DECL_SIZE_UNIT (tmp
)))
670 force_constant_size (tmp
);
672 DECL_CONTEXT (tmp
) = current_function_decl
;
673 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
677 DECL_CHAIN (tmp
) = gimplify_ctxp
->temps
;
678 gimplify_ctxp
->temps
= tmp
;
680 /* Mark temporaries local within the nearest enclosing parallel. */
681 if (gimplify_omp_ctxp
)
683 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
685 && (ctx
->region_type
== ORT_WORKSHARE
686 || ctx
->region_type
== ORT_SIMD
))
687 ctx
= ctx
->outer_context
;
689 omp_add_variable (ctx
, tmp
, GOVD_LOCAL
| GOVD_SEEN
);
698 /* This case is for nested functions. We need to expose the locals
700 body_seq
= gimple_body (current_function_decl
);
701 declare_vars (tmp
, gimple_seq_first_stmt (body_seq
), false);
707 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
708 nodes that are referenced more than once in GENERIC functions. This is
709 necessary because gimplification (translation into GIMPLE) is performed
710 by modifying tree nodes in-place, so gimplication of a shared node in a
711 first context could generate an invalid GIMPLE form in a second context.
713 This is achieved with a simple mark/copy/unmark algorithm that walks the
714 GENERIC representation top-down, marks nodes with TREE_VISITED the first
715 time it encounters them, duplicates them if they already have TREE_VISITED
716 set, and finally removes the TREE_VISITED marks it has set.
718 The algorithm works only at the function level, i.e. it generates a GENERIC
719 representation of a function with no nodes shared within the function when
720 passed a GENERIC function (except for nodes that are allowed to be shared).
722 At the global level, it is also necessary to unshare tree nodes that are
723 referenced in more than one function, for the same aforementioned reason.
724 This requires some cooperation from the front-end. There are 2 strategies:
726 1. Manual unsharing. The front-end needs to call unshare_expr on every
727 expression that might end up being shared across functions.
729 2. Deep unsharing. This is an extension of regular unsharing. Instead
730 of calling unshare_expr on expressions that might be shared across
731 functions, the front-end pre-marks them with TREE_VISITED. This will
732 ensure that they are unshared on the first reference within functions
733 when the regular unsharing algorithm runs. The counterpart is that
734 this algorithm must look deeper than for manual unsharing, which is
735 specified by LANG_HOOKS_DEEP_UNSHARING.
737 If there are only few specific cases of node sharing across functions, it is
738 probably easier for a front-end to unshare the expressions manually. On the
739 contrary, if the expressions generated at the global level are as widespread
740 as expressions generated within functions, deep unsharing is very likely the
743 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
744 These nodes model computations that must be done once. If we were to
745 unshare something like SAVE_EXPR(i++), the gimplification process would
746 create wrong code. However, if DATA is non-null, it must hold a pointer
747 set that is used to unshare the subtrees of these nodes. */
750 mostly_copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
753 enum tree_code code
= TREE_CODE (t
);
755 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
756 copy their subtrees if we can make sure to do it only once. */
757 if (code
== SAVE_EXPR
|| code
== TARGET_EXPR
|| code
== BIND_EXPR
)
759 if (data
&& !((hash_set
<tree
> *)data
)->add (t
))
765 /* Stop at types, decls, constants like copy_tree_r. */
766 else if (TREE_CODE_CLASS (code
) == tcc_type
767 || TREE_CODE_CLASS (code
) == tcc_declaration
768 || TREE_CODE_CLASS (code
) == tcc_constant
769 /* We can't do anything sensible with a BLOCK used as an
770 expression, but we also can't just die when we see it
771 because of non-expression uses. So we avert our eyes
772 and cross our fingers. Silly Java. */
776 /* Cope with the statement expression extension. */
777 else if (code
== STATEMENT_LIST
)
780 /* Leave the bulk of the work to copy_tree_r itself. */
782 copy_tree_r (tp
, walk_subtrees
, NULL
);
787 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
788 If *TP has been visited already, then *TP is deeply copied by calling
789 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
792 copy_if_shared_r (tree
*tp
, int *walk_subtrees
, void *data
)
795 enum tree_code code
= TREE_CODE (t
);
797 /* Skip types, decls, and constants. But we do want to look at their
798 types and the bounds of types. Mark them as visited so we properly
799 unmark their subtrees on the unmark pass. If we've already seen them,
800 don't look down further. */
801 if (TREE_CODE_CLASS (code
) == tcc_type
802 || TREE_CODE_CLASS (code
) == tcc_declaration
803 || TREE_CODE_CLASS (code
) == tcc_constant
)
805 if (TREE_VISITED (t
))
808 TREE_VISITED (t
) = 1;
811 /* If this node has been visited already, unshare it and don't look
813 else if (TREE_VISITED (t
))
815 walk_tree (tp
, mostly_copy_tree_r
, data
, NULL
);
819 /* Otherwise, mark the node as visited and keep looking. */
821 TREE_VISITED (t
) = 1;
826 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
827 copy_if_shared_r callback unmodified. */
830 copy_if_shared (tree
*tp
, void *data
)
832 walk_tree (tp
, copy_if_shared_r
, data
, NULL
);
835 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
836 any nested functions. */
839 unshare_body (tree fndecl
)
841 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
842 /* If the language requires deep unsharing, we need a pointer set to make
843 sure we don't repeatedly unshare subtrees of unshareable nodes. */
844 hash_set
<tree
> *visited
845 = lang_hooks
.deep_unsharing
? new hash_set
<tree
> : NULL
;
847 copy_if_shared (&DECL_SAVED_TREE (fndecl
), visited
);
848 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl
)), visited
);
849 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)), visited
);
854 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
855 unshare_body (cgn
->decl
);
858 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
859 Subtrees are walked until the first unvisited node is encountered. */
862 unmark_visited_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
866 /* If this node has been visited, unmark it and keep looking. */
867 if (TREE_VISITED (t
))
868 TREE_VISITED (t
) = 0;
870 /* Otherwise, don't look any deeper. */
877 /* Unmark the visited trees rooted at *TP. */
880 unmark_visited (tree
*tp
)
882 walk_tree (tp
, unmark_visited_r
, NULL
, NULL
);
885 /* Likewise, but mark all trees as not visited. */
888 unvisit_body (tree fndecl
)
890 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
892 unmark_visited (&DECL_SAVED_TREE (fndecl
));
893 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl
)));
894 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)));
897 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
898 unvisit_body (cgn
->decl
);
901 /* Unconditionally make an unshared copy of EXPR. This is used when using
902 stored expressions which span multiple functions, such as BINFO_VTABLE,
903 as the normal unsharing process can't tell that they're shared. */
906 unshare_expr (tree expr
)
908 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
912 /* Worker for unshare_expr_without_location. */
915 prune_expr_location (tree
*tp
, int *walk_subtrees
, void *)
918 SET_EXPR_LOCATION (*tp
, UNKNOWN_LOCATION
);
924 /* Similar to unshare_expr but also prune all expression locations
928 unshare_expr_without_location (tree expr
)
930 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
932 walk_tree (&expr
, prune_expr_location
, NULL
, NULL
);
936 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
937 contain statements and have a value. Assign its value to a temporary
938 and give it void_type_node. Return the temporary, or NULL_TREE if
939 WRAPPER was already void. */
942 voidify_wrapper_expr (tree wrapper
, tree temp
)
944 tree type
= TREE_TYPE (wrapper
);
945 if (type
&& !VOID_TYPE_P (type
))
949 /* Set p to point to the body of the wrapper. Loop until we find
950 something that isn't a wrapper. */
951 for (p
= &wrapper
; p
&& *p
; )
953 switch (TREE_CODE (*p
))
956 TREE_SIDE_EFFECTS (*p
) = 1;
957 TREE_TYPE (*p
) = void_type_node
;
958 /* For a BIND_EXPR, the body is operand 1. */
959 p
= &BIND_EXPR_BODY (*p
);
962 case CLEANUP_POINT_EXPR
:
963 case TRY_FINALLY_EXPR
:
965 TREE_SIDE_EFFECTS (*p
) = 1;
966 TREE_TYPE (*p
) = void_type_node
;
967 p
= &TREE_OPERAND (*p
, 0);
972 tree_stmt_iterator i
= tsi_last (*p
);
973 TREE_SIDE_EFFECTS (*p
) = 1;
974 TREE_TYPE (*p
) = void_type_node
;
975 p
= tsi_end_p (i
) ? NULL
: tsi_stmt_ptr (i
);
980 /* Advance to the last statement. Set all container types to
982 for (; TREE_CODE (*p
) == COMPOUND_EXPR
; p
= &TREE_OPERAND (*p
, 1))
984 TREE_SIDE_EFFECTS (*p
) = 1;
985 TREE_TYPE (*p
) = void_type_node
;
989 case TRANSACTION_EXPR
:
990 TREE_SIDE_EFFECTS (*p
) = 1;
991 TREE_TYPE (*p
) = void_type_node
;
992 p
= &TRANSACTION_EXPR_BODY (*p
);
996 /* Assume that any tree upon which voidify_wrapper_expr is
997 directly called is a wrapper, and that its body is op0. */
1000 TREE_SIDE_EFFECTS (*p
) = 1;
1001 TREE_TYPE (*p
) = void_type_node
;
1002 p
= &TREE_OPERAND (*p
, 0);
1010 if (p
== NULL
|| IS_EMPTY_STMT (*p
))
1014 /* The wrapper is on the RHS of an assignment that we're pushing
1016 gcc_assert (TREE_CODE (temp
) == INIT_EXPR
1017 || TREE_CODE (temp
) == MODIFY_EXPR
);
1018 TREE_OPERAND (temp
, 1) = *p
;
1023 temp
= create_tmp_var (type
, "retval");
1024 *p
= build2 (INIT_EXPR
, type
, temp
, *p
);
1033 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1034 a temporary through which they communicate. */
1037 build_stack_save_restore (gcall
**save
, gcall
**restore
)
1041 *save
= gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE
), 0);
1042 tmp_var
= create_tmp_var (ptr_type_node
, "saved_stack");
1043 gimple_call_set_lhs (*save
, tmp_var
);
1046 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE
),
1050 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1052 static enum gimplify_status
1053 gimplify_bind_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1055 tree bind_expr
= *expr_p
;
1056 bool old_save_stack
= gimplify_ctxp
->save_stack
;
1059 gimple_seq body
, cleanup
;
1061 location_t start_locus
= 0, end_locus
= 0;
1063 tree temp
= voidify_wrapper_expr (bind_expr
, NULL
);
1065 /* Mark variables seen in this bind expr. */
1066 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1068 if (TREE_CODE (t
) == VAR_DECL
)
1070 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1072 /* Mark variable as local. */
1073 if (ctx
&& !DECL_EXTERNAL (t
)
1074 && (! DECL_SEEN_IN_BIND_EXPR_P (t
)
1075 || splay_tree_lookup (ctx
->variables
,
1076 (splay_tree_key
) t
) == NULL
))
1078 if (ctx
->region_type
== ORT_SIMD
1079 && TREE_ADDRESSABLE (t
)
1080 && !TREE_STATIC (t
))
1081 omp_add_variable (ctx
, t
, GOVD_PRIVATE
| GOVD_SEEN
);
1083 omp_add_variable (ctx
, t
, GOVD_LOCAL
| GOVD_SEEN
);
1086 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
1088 if (DECL_HARD_REGISTER (t
) && !is_global_var (t
) && cfun
)
1089 cfun
->has_local_explicit_reg_vars
= true;
1092 /* Preliminarily mark non-addressed complex variables as eligible
1093 for promotion to gimple registers. We'll transform their uses
1095 if ((TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
1096 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1097 && !TREE_THIS_VOLATILE (t
)
1098 && (TREE_CODE (t
) == VAR_DECL
&& !DECL_HARD_REGISTER (t
))
1099 && !needs_to_live_in_memory (t
))
1100 DECL_GIMPLE_REG_P (t
) = 1;
1103 bind_stmt
= gimple_build_bind (BIND_EXPR_VARS (bind_expr
), NULL
,
1104 BIND_EXPR_BLOCK (bind_expr
));
1105 gimple_push_bind_expr (bind_stmt
);
1107 gimplify_ctxp
->save_stack
= false;
1109 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1111 gimplify_stmt (&BIND_EXPR_BODY (bind_expr
), &body
);
1112 gimple_bind_set_body (bind_stmt
, body
);
1114 /* Source location wise, the cleanup code (stack_restore and clobbers)
1115 belongs to the end of the block, so propagate what we have. The
1116 stack_save operation belongs to the beginning of block, which we can
1117 infer from the bind_expr directly if the block has no explicit
1119 if (BIND_EXPR_BLOCK (bind_expr
))
1121 end_locus
= BLOCK_SOURCE_END_LOCATION (BIND_EXPR_BLOCK (bind_expr
));
1122 start_locus
= BLOCK_SOURCE_LOCATION (BIND_EXPR_BLOCK (bind_expr
));
1124 if (start_locus
== 0)
1125 start_locus
= EXPR_LOCATION (bind_expr
);
1129 if (gimplify_ctxp
->save_stack
)
1131 gcall
*stack_restore
;
1133 /* Save stack on entry and restore it on exit. Add a try_finally
1134 block to achieve this. */
1135 build_stack_save_restore (&stack_save
, &stack_restore
);
1137 gimple_set_location (stack_save
, start_locus
);
1138 gimple_set_location (stack_restore
, end_locus
);
1140 gimplify_seq_add_stmt (&cleanup
, stack_restore
);
1143 /* Add clobbers for all variables that go out of scope. */
1144 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1146 if (TREE_CODE (t
) == VAR_DECL
1147 && !is_global_var (t
)
1148 && DECL_CONTEXT (t
) == current_function_decl
1149 && !DECL_HARD_REGISTER (t
)
1150 && !TREE_THIS_VOLATILE (t
)
1151 && !DECL_HAS_VALUE_EXPR_P (t
)
1152 /* Only care for variables that have to be in memory. Others
1153 will be rewritten into SSA names, hence moved to the top-level. */
1154 && !is_gimple_reg (t
)
1155 && flag_stack_reuse
!= SR_NONE
)
1157 tree clobber
= build_constructor (TREE_TYPE (t
), NULL
);
1158 gimple clobber_stmt
;
1159 TREE_THIS_VOLATILE (clobber
) = 1;
1160 clobber_stmt
= gimple_build_assign (t
, clobber
);
1161 gimple_set_location (clobber_stmt
, end_locus
);
1162 gimplify_seq_add_stmt (&cleanup
, clobber_stmt
);
1169 gimple_seq new_body
;
1172 gs
= gimple_build_try (gimple_bind_body (bind_stmt
), cleanup
,
1173 GIMPLE_TRY_FINALLY
);
1176 gimplify_seq_add_stmt (&new_body
, stack_save
);
1177 gimplify_seq_add_stmt (&new_body
, gs
);
1178 gimple_bind_set_body (bind_stmt
, new_body
);
1181 gimplify_ctxp
->save_stack
= old_save_stack
;
1182 gimple_pop_bind_expr ();
1184 gimplify_seq_add_stmt (pre_p
, bind_stmt
);
1192 *expr_p
= NULL_TREE
;
1196 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1197 GIMPLE value, it is assigned to a new temporary and the statement is
1198 re-written to return the temporary.
1200 PRE_P points to the sequence where side effects that must happen before
1201 STMT should be stored. */
1203 static enum gimplify_status
1204 gimplify_return_expr (tree stmt
, gimple_seq
*pre_p
)
1207 tree ret_expr
= TREE_OPERAND (stmt
, 0);
1208 tree result_decl
, result
;
1210 if (ret_expr
== error_mark_node
)
1213 /* Implicit _Cilk_sync must be inserted right before any return statement
1214 if there is a _Cilk_spawn in the function. If the user has provided a
1215 _Cilk_sync, the optimizer should remove this duplicate one. */
1216 if (fn_contains_cilk_spawn_p (cfun
))
1218 tree impl_sync
= build0 (CILK_SYNC_STMT
, void_type_node
);
1219 gimplify_and_add (impl_sync
, pre_p
);
1223 || TREE_CODE (ret_expr
) == RESULT_DECL
1224 || ret_expr
== error_mark_node
)
1226 greturn
*ret
= gimple_build_return (ret_expr
);
1227 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1228 gimplify_seq_add_stmt (pre_p
, ret
);
1232 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1233 result_decl
= NULL_TREE
;
1236 result_decl
= TREE_OPERAND (ret_expr
, 0);
1238 /* See through a return by reference. */
1239 if (TREE_CODE (result_decl
) == INDIRECT_REF
)
1240 result_decl
= TREE_OPERAND (result_decl
, 0);
1242 gcc_assert ((TREE_CODE (ret_expr
) == MODIFY_EXPR
1243 || TREE_CODE (ret_expr
) == INIT_EXPR
)
1244 && TREE_CODE (result_decl
) == RESULT_DECL
);
1247 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1248 Recall that aggregate_value_p is FALSE for any aggregate type that is
1249 returned in registers. If we're returning values in registers, then
1250 we don't want to extend the lifetime of the RESULT_DECL, particularly
1251 across another call. In addition, for those aggregates for which
1252 hard_function_value generates a PARALLEL, we'll die during normal
1253 expansion of structure assignments; there's special code in expand_return
1254 to handle this case that does not exist in expand_expr. */
1257 else if (aggregate_value_p (result_decl
, TREE_TYPE (current_function_decl
)))
1259 if (TREE_CODE (DECL_SIZE (result_decl
)) != INTEGER_CST
)
1261 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl
)))
1262 gimplify_type_sizes (TREE_TYPE (result_decl
), pre_p
);
1263 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1264 should be effectively allocated by the caller, i.e. all calls to
1265 this function must be subject to the Return Slot Optimization. */
1266 gimplify_one_sizepos (&DECL_SIZE (result_decl
), pre_p
);
1267 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl
), pre_p
);
1269 result
= result_decl
;
1271 else if (gimplify_ctxp
->return_temp
)
1272 result
= gimplify_ctxp
->return_temp
;
1275 result
= create_tmp_reg (TREE_TYPE (result_decl
));
1277 /* ??? With complex control flow (usually involving abnormal edges),
1278 we can wind up warning about an uninitialized value for this. Due
1279 to how this variable is constructed and initialized, this is never
1280 true. Give up and never warn. */
1281 TREE_NO_WARNING (result
) = 1;
1283 gimplify_ctxp
->return_temp
= result
;
1286 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1287 Then gimplify the whole thing. */
1288 if (result
!= result_decl
)
1289 TREE_OPERAND (ret_expr
, 0) = result
;
1291 gimplify_and_add (TREE_OPERAND (stmt
, 0), pre_p
);
1293 ret
= gimple_build_return (result
);
1294 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1295 gimplify_seq_add_stmt (pre_p
, ret
);
1300 /* Gimplify a variable-length array DECL. */
1303 gimplify_vla_decl (tree decl
, gimple_seq
*seq_p
)
1305 /* This is a variable-sized decl. Simplify its size and mark it
1306 for deferred expansion. */
1307 tree t
, addr
, ptr_type
;
1309 gimplify_one_sizepos (&DECL_SIZE (decl
), seq_p
);
1310 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl
), seq_p
);
1312 /* Don't mess with a DECL_VALUE_EXPR set by the front-end. */
1313 if (DECL_HAS_VALUE_EXPR_P (decl
))
1316 /* All occurrences of this decl in final gimplified code will be
1317 replaced by indirection. Setting DECL_VALUE_EXPR does two
1318 things: First, it lets the rest of the gimplifier know what
1319 replacement to use. Second, it lets the debug info know
1320 where to find the value. */
1321 ptr_type
= build_pointer_type (TREE_TYPE (decl
));
1322 addr
= create_tmp_var (ptr_type
, get_name (decl
));
1323 DECL_IGNORED_P (addr
) = 0;
1324 t
= build_fold_indirect_ref (addr
);
1325 TREE_THIS_NOTRAP (t
) = 1;
1326 SET_DECL_VALUE_EXPR (decl
, t
);
1327 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1329 t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
1330 t
= build_call_expr (t
, 2, DECL_SIZE_UNIT (decl
),
1331 size_int (DECL_ALIGN (decl
)));
1332 /* The call has been built for a variable-sized object. */
1333 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
1334 t
= fold_convert (ptr_type
, t
);
1335 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
1337 gimplify_and_add (t
, seq_p
);
1339 /* Indicate that we need to restore the stack level when the
1340 enclosing BIND_EXPR is exited. */
1341 gimplify_ctxp
->save_stack
= true;
1344 /* A helper function to be called via walk_tree. Mark all labels under *TP
1345 as being forced. To be called for DECL_INITIAL of static variables. */
1348 force_labels_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1352 if (TREE_CODE (*tp
) == LABEL_DECL
)
1353 FORCED_LABEL (*tp
) = 1;
1358 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1359 and initialization explicit. */
1361 static enum gimplify_status
1362 gimplify_decl_expr (tree
*stmt_p
, gimple_seq
*seq_p
)
1364 tree stmt
= *stmt_p
;
1365 tree decl
= DECL_EXPR_DECL (stmt
);
1367 *stmt_p
= NULL_TREE
;
1369 if (TREE_TYPE (decl
) == error_mark_node
)
1372 if ((TREE_CODE (decl
) == TYPE_DECL
1373 || TREE_CODE (decl
) == VAR_DECL
)
1374 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl
)))
1375 gimplify_type_sizes (TREE_TYPE (decl
), seq_p
);
1377 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1378 in case its size expressions contain problematic nodes like CALL_EXPR. */
1379 if (TREE_CODE (decl
) == TYPE_DECL
1380 && DECL_ORIGINAL_TYPE (decl
)
1381 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl
)))
1382 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl
), seq_p
);
1384 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1386 tree init
= DECL_INITIAL (decl
);
1388 if (TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1389 || (!TREE_STATIC (decl
)
1390 && flag_stack_check
== GENERIC_STACK_CHECK
1391 && compare_tree_int (DECL_SIZE_UNIT (decl
),
1392 STACK_CHECK_MAX_VAR_SIZE
) > 0))
1393 gimplify_vla_decl (decl
, seq_p
);
1395 /* Some front ends do not explicitly declare all anonymous
1396 artificial variables. We compensate here by declaring the
1397 variables, though it would be better if the front ends would
1398 explicitly declare them. */
1399 if (!DECL_SEEN_IN_BIND_EXPR_P (decl
)
1400 && DECL_ARTIFICIAL (decl
) && DECL_NAME (decl
) == NULL_TREE
)
1401 gimple_add_tmp_var (decl
);
1403 if (init
&& init
!= error_mark_node
)
1405 if (!TREE_STATIC (decl
))
1407 DECL_INITIAL (decl
) = NULL_TREE
;
1408 init
= build2 (INIT_EXPR
, void_type_node
, decl
, init
);
1409 gimplify_and_add (init
, seq_p
);
1413 /* We must still examine initializers for static variables
1414 as they may contain a label address. */
1415 walk_tree (&init
, force_labels_r
, NULL
, NULL
);
1422 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1423 and replacing the LOOP_EXPR with goto, but if the loop contains an
1424 EXIT_EXPR, we need to append a label for it to jump to. */
1426 static enum gimplify_status
1427 gimplify_loop_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1429 tree saved_label
= gimplify_ctxp
->exit_label
;
1430 tree start_label
= create_artificial_label (UNKNOWN_LOCATION
);
1432 gimplify_seq_add_stmt (pre_p
, gimple_build_label (start_label
));
1434 gimplify_ctxp
->exit_label
= NULL_TREE
;
1436 gimplify_and_add (LOOP_EXPR_BODY (*expr_p
), pre_p
);
1438 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (start_label
));
1440 if (gimplify_ctxp
->exit_label
)
1441 gimplify_seq_add_stmt (pre_p
,
1442 gimple_build_label (gimplify_ctxp
->exit_label
));
1444 gimplify_ctxp
->exit_label
= saved_label
;
1450 /* Gimplify a statement list onto a sequence. These may be created either
1451 by an enlightened front-end, or by shortcut_cond_expr. */
1453 static enum gimplify_status
1454 gimplify_statement_list (tree
*expr_p
, gimple_seq
*pre_p
)
1456 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
1458 tree_stmt_iterator i
= tsi_start (*expr_p
);
1460 while (!tsi_end_p (i
))
1462 gimplify_stmt (tsi_stmt_ptr (i
), pre_p
);
1476 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
1479 static enum gimplify_status
1480 gimplify_switch_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1482 tree switch_expr
= *expr_p
;
1483 gimple_seq switch_body_seq
= NULL
;
1484 enum gimplify_status ret
;
1485 tree index_type
= TREE_TYPE (switch_expr
);
1486 if (index_type
== NULL_TREE
)
1487 index_type
= TREE_TYPE (SWITCH_COND (switch_expr
));
1489 ret
= gimplify_expr (&SWITCH_COND (switch_expr
), pre_p
, NULL
, is_gimple_val
,
1491 if (ret
== GS_ERROR
|| ret
== GS_UNHANDLED
)
1494 if (SWITCH_BODY (switch_expr
))
1497 vec
<tree
> saved_labels
;
1498 tree default_case
= NULL_TREE
;
1499 gswitch
*switch_stmt
;
1501 /* If someone can be bothered to fill in the labels, they can
1502 be bothered to null out the body too. */
1503 gcc_assert (!SWITCH_LABELS (switch_expr
));
1505 /* Save old labels, get new ones from body, then restore the old
1506 labels. Save all the things from the switch body to append after. */
1507 saved_labels
= gimplify_ctxp
->case_labels
;
1508 gimplify_ctxp
->case_labels
.create (8);
1510 gimplify_stmt (&SWITCH_BODY (switch_expr
), &switch_body_seq
);
1511 labels
= gimplify_ctxp
->case_labels
;
1512 gimplify_ctxp
->case_labels
= saved_labels
;
1514 preprocess_case_label_vec_for_gimple (labels
, index_type
,
1519 glabel
*new_default
;
1522 = build_case_label (NULL_TREE
, NULL_TREE
,
1523 create_artificial_label (UNKNOWN_LOCATION
));
1524 new_default
= gimple_build_label (CASE_LABEL (default_case
));
1525 gimplify_seq_add_stmt (&switch_body_seq
, new_default
);
1528 switch_stmt
= gimple_build_switch (SWITCH_COND (switch_expr
),
1529 default_case
, labels
);
1530 gimplify_seq_add_stmt (pre_p
, switch_stmt
);
1531 gimplify_seq_add_seq (pre_p
, switch_body_seq
);
1535 gcc_assert (SWITCH_LABELS (switch_expr
));
1540 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
1542 static enum gimplify_status
1543 gimplify_case_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1545 struct gimplify_ctx
*ctxp
;
1548 /* Invalid programs can play Duff's Device type games with, for example,
1549 #pragma omp parallel. At least in the C front end, we don't
1550 detect such invalid branches until after gimplification, in the
1551 diagnose_omp_blocks pass. */
1552 for (ctxp
= gimplify_ctxp
; ; ctxp
= ctxp
->prev_context
)
1553 if (ctxp
->case_labels
.exists ())
1556 label_stmt
= gimple_build_label (CASE_LABEL (*expr_p
));
1557 ctxp
->case_labels
.safe_push (*expr_p
);
1558 gimplify_seq_add_stmt (pre_p
, label_stmt
);
1563 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1567 build_and_jump (tree
*label_p
)
1569 if (label_p
== NULL
)
1570 /* If there's nowhere to jump, just fall through. */
1573 if (*label_p
== NULL_TREE
)
1575 tree label
= create_artificial_label (UNKNOWN_LOCATION
);
1579 return build1 (GOTO_EXPR
, void_type_node
, *label_p
);
1582 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1583 This also involves building a label to jump to and communicating it to
1584 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1586 static enum gimplify_status
1587 gimplify_exit_expr (tree
*expr_p
)
1589 tree cond
= TREE_OPERAND (*expr_p
, 0);
1592 expr
= build_and_jump (&gimplify_ctxp
->exit_label
);
1593 expr
= build3 (COND_EXPR
, void_type_node
, cond
, expr
, NULL_TREE
);
1599 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1600 different from its canonical type, wrap the whole thing inside a
1601 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1604 The canonical type of a COMPONENT_REF is the type of the field being
1605 referenced--unless the field is a bit-field which can be read directly
1606 in a smaller mode, in which case the canonical type is the
1607 sign-appropriate type corresponding to that mode. */
1610 canonicalize_component_ref (tree
*expr_p
)
1612 tree expr
= *expr_p
;
1615 gcc_assert (TREE_CODE (expr
) == COMPONENT_REF
);
1617 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
1618 type
= TREE_TYPE (get_unwidened (expr
, NULL_TREE
));
1620 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
1622 /* One could argue that all the stuff below is not necessary for
1623 the non-bitfield case and declare it a FE error if type
1624 adjustment would be needed. */
1625 if (TREE_TYPE (expr
) != type
)
1627 #ifdef ENABLE_TYPES_CHECKING
1628 tree old_type
= TREE_TYPE (expr
);
1632 /* We need to preserve qualifiers and propagate them from
1634 type_quals
= TYPE_QUALS (type
)
1635 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1636 if (TYPE_QUALS (type
) != type_quals
)
1637 type
= build_qualified_type (TYPE_MAIN_VARIANT (type
), type_quals
);
1639 /* Set the type of the COMPONENT_REF to the underlying type. */
1640 TREE_TYPE (expr
) = type
;
1642 #ifdef ENABLE_TYPES_CHECKING
1643 /* It is now a FE error, if the conversion from the canonical
1644 type to the original expression type is not useless. */
1645 gcc_assert (useless_type_conversion_p (old_type
, type
));
1650 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1651 to foo, embed that change in the ADDR_EXPR by converting
1656 where L is the lower bound. For simplicity, only do this for constant
1658 The constraint is that the type of &array[L] is trivially convertible
1662 canonicalize_addr_expr (tree
*expr_p
)
1664 tree expr
= *expr_p
;
1665 tree addr_expr
= TREE_OPERAND (expr
, 0);
1666 tree datype
, ddatype
, pddatype
;
1668 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1669 if (!POINTER_TYPE_P (TREE_TYPE (expr
))
1670 || TREE_CODE (addr_expr
) != ADDR_EXPR
)
1673 /* The addr_expr type should be a pointer to an array. */
1674 datype
= TREE_TYPE (TREE_TYPE (addr_expr
));
1675 if (TREE_CODE (datype
) != ARRAY_TYPE
)
1678 /* The pointer to element type shall be trivially convertible to
1679 the expression pointer type. */
1680 ddatype
= TREE_TYPE (datype
);
1681 pddatype
= build_pointer_type (ddatype
);
1682 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)),
1686 /* The lower bound and element sizes must be constant. */
1687 if (!TYPE_SIZE_UNIT (ddatype
)
1688 || TREE_CODE (TYPE_SIZE_UNIT (ddatype
)) != INTEGER_CST
1689 || !TYPE_DOMAIN (datype
) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))
1690 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))) != INTEGER_CST
)
1693 /* All checks succeeded. Build a new node to merge the cast. */
1694 *expr_p
= build4 (ARRAY_REF
, ddatype
, TREE_OPERAND (addr_expr
, 0),
1695 TYPE_MIN_VALUE (TYPE_DOMAIN (datype
)),
1696 NULL_TREE
, NULL_TREE
);
1697 *expr_p
= build1 (ADDR_EXPR
, pddatype
, *expr_p
);
1699 /* We can have stripped a required restrict qualifier above. */
1700 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
1701 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
1704 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1705 underneath as appropriate. */
1707 static enum gimplify_status
1708 gimplify_conversion (tree
*expr_p
)
1710 location_t loc
= EXPR_LOCATION (*expr_p
);
1711 gcc_assert (CONVERT_EXPR_P (*expr_p
));
1713 /* Then strip away all but the outermost conversion. */
1714 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p
, 0));
1716 /* And remove the outermost conversion if it's useless. */
1717 if (tree_ssa_useless_type_conversion (*expr_p
))
1718 *expr_p
= TREE_OPERAND (*expr_p
, 0);
1720 /* If we still have a conversion at the toplevel,
1721 then canonicalize some constructs. */
1722 if (CONVERT_EXPR_P (*expr_p
))
1724 tree sub
= TREE_OPERAND (*expr_p
, 0);
1726 /* If a NOP conversion is changing the type of a COMPONENT_REF
1727 expression, then canonicalize its type now in order to expose more
1728 redundant conversions. */
1729 if (TREE_CODE (sub
) == COMPONENT_REF
)
1730 canonicalize_component_ref (&TREE_OPERAND (*expr_p
, 0));
1732 /* If a NOP conversion is changing a pointer to array of foo
1733 to a pointer to foo, embed that change in the ADDR_EXPR. */
1734 else if (TREE_CODE (sub
) == ADDR_EXPR
)
1735 canonicalize_addr_expr (expr_p
);
1738 /* If we have a conversion to a non-register type force the
1739 use of a VIEW_CONVERT_EXPR instead. */
1740 if (CONVERT_EXPR_P (*expr_p
) && !is_gimple_reg_type (TREE_TYPE (*expr_p
)))
1741 *expr_p
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (*expr_p
),
1742 TREE_OPERAND (*expr_p
, 0));
1744 /* Canonicalize CONVERT_EXPR to NOP_EXPR. */
1745 if (TREE_CODE (*expr_p
) == CONVERT_EXPR
)
1746 TREE_SET_CODE (*expr_p
, NOP_EXPR
);
1751 /* Nonlocal VLAs seen in the current function. */
1752 static hash_set
<tree
> *nonlocal_vlas
;
1754 /* The VAR_DECLs created for nonlocal VLAs for debug info purposes. */
1755 static tree nonlocal_vla_vars
;
1757 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
1758 DECL_VALUE_EXPR, and it's worth re-examining things. */
1760 static enum gimplify_status
1761 gimplify_var_or_parm_decl (tree
*expr_p
)
1763 tree decl
= *expr_p
;
1765 /* ??? If this is a local variable, and it has not been seen in any
1766 outer BIND_EXPR, then it's probably the result of a duplicate
1767 declaration, for which we've already issued an error. It would
1768 be really nice if the front end wouldn't leak these at all.
1769 Currently the only known culprit is C++ destructors, as seen
1770 in g++.old-deja/g++.jason/binding.C. */
1771 if (TREE_CODE (decl
) == VAR_DECL
1772 && !DECL_SEEN_IN_BIND_EXPR_P (decl
)
1773 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)
1774 && decl_function_context (decl
) == current_function_decl
)
1776 gcc_assert (seen_error ());
1780 /* When within an OMP context, notice uses of variables. */
1781 if (gimplify_omp_ctxp
&& omp_notice_variable (gimplify_omp_ctxp
, decl
, true))
1784 /* If the decl is an alias for another expression, substitute it now. */
1785 if (DECL_HAS_VALUE_EXPR_P (decl
))
1787 tree value_expr
= DECL_VALUE_EXPR (decl
);
1789 /* For referenced nonlocal VLAs add a decl for debugging purposes
1790 to the current function. */
1791 if (TREE_CODE (decl
) == VAR_DECL
1792 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1793 && nonlocal_vlas
!= NULL
1794 && TREE_CODE (value_expr
) == INDIRECT_REF
1795 && TREE_CODE (TREE_OPERAND (value_expr
, 0)) == VAR_DECL
1796 && decl_function_context (decl
) != current_function_decl
)
1798 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1800 && (ctx
->region_type
== ORT_WORKSHARE
1801 || ctx
->region_type
== ORT_SIMD
))
1802 ctx
= ctx
->outer_context
;
1803 if (!ctx
&& !nonlocal_vlas
->add (decl
))
1805 tree copy
= copy_node (decl
);
1807 lang_hooks
.dup_lang_specific_decl (copy
);
1808 SET_DECL_RTL (copy
, 0);
1809 TREE_USED (copy
) = 1;
1810 DECL_CHAIN (copy
) = nonlocal_vla_vars
;
1811 nonlocal_vla_vars
= copy
;
1812 SET_DECL_VALUE_EXPR (copy
, unshare_expr (value_expr
));
1813 DECL_HAS_VALUE_EXPR_P (copy
) = 1;
1817 *expr_p
= unshare_expr (value_expr
);
1824 /* Recalculate the value of the TREE_SIDE_EFFECTS flag for T. */
1827 recalculate_side_effects (tree t
)
1829 enum tree_code code
= TREE_CODE (t
);
1830 int len
= TREE_OPERAND_LENGTH (t
);
1833 switch (TREE_CODE_CLASS (code
))
1835 case tcc_expression
:
1841 case PREDECREMENT_EXPR
:
1842 case PREINCREMENT_EXPR
:
1843 case POSTDECREMENT_EXPR
:
1844 case POSTINCREMENT_EXPR
:
1845 /* All of these have side-effects, no matter what their
1854 case tcc_comparison
: /* a comparison expression */
1855 case tcc_unary
: /* a unary arithmetic expression */
1856 case tcc_binary
: /* a binary arithmetic expression */
1857 case tcc_reference
: /* a reference */
1858 case tcc_vl_exp
: /* a function call */
1859 TREE_SIDE_EFFECTS (t
) = TREE_THIS_VOLATILE (t
);
1860 for (i
= 0; i
< len
; ++i
)
1862 tree op
= TREE_OPERAND (t
, i
);
1863 if (op
&& TREE_SIDE_EFFECTS (op
))
1864 TREE_SIDE_EFFECTS (t
) = 1;
1869 /* No side-effects. */
1877 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1881 : min_lval '[' val ']'
1883 | compound_lval '[' val ']'
1884 | compound_lval '.' ID
1886 This is not part of the original SIMPLE definition, which separates
1887 array and member references, but it seems reasonable to handle them
1888 together. Also, this way we don't run into problems with union
1889 aliasing; gcc requires that for accesses through a union to alias, the
1890 union reference must be explicit, which was not always the case when we
1891 were splitting up array and member refs.
1893 PRE_P points to the sequence where side effects that must happen before
1894 *EXPR_P should be stored.
1896 POST_P points to the sequence where side effects that must happen after
1897 *EXPR_P should be stored. */
1899 static enum gimplify_status
1900 gimplify_compound_lval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
1901 fallback_t fallback
)
1904 enum gimplify_status ret
= GS_ALL_DONE
, tret
;
1906 location_t loc
= EXPR_LOCATION (*expr_p
);
1907 tree expr
= *expr_p
;
1909 /* Create a stack of the subexpressions so later we can walk them in
1910 order from inner to outer. */
1911 auto_vec
<tree
, 10> expr_stack
;
1913 /* We can handle anything that get_inner_reference can deal with. */
1914 for (p
= expr_p
; ; p
= &TREE_OPERAND (*p
, 0))
1917 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
1918 if (TREE_CODE (*p
) == INDIRECT_REF
)
1919 *p
= fold_indirect_ref_loc (loc
, *p
);
1921 if (handled_component_p (*p
))
1923 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
1924 additional COMPONENT_REFs. */
1925 else if ((TREE_CODE (*p
) == VAR_DECL
|| TREE_CODE (*p
) == PARM_DECL
)
1926 && gimplify_var_or_parm_decl (p
) == GS_OK
)
1931 expr_stack
.safe_push (*p
);
1934 gcc_assert (expr_stack
.length ());
1936 /* Now EXPR_STACK is a stack of pointers to all the refs we've
1937 walked through and P points to the innermost expression.
1939 Java requires that we elaborated nodes in source order. That
1940 means we must gimplify the inner expression followed by each of
1941 the indices, in order. But we can't gimplify the inner
1942 expression until we deal with any variable bounds, sizes, or
1943 positions in order to deal with PLACEHOLDER_EXPRs.
1945 So we do this in three steps. First we deal with the annotations
1946 for any variables in the components, then we gimplify the base,
1947 then we gimplify any indices, from left to right. */
1948 for (i
= expr_stack
.length () - 1; i
>= 0; i
--)
1950 tree t
= expr_stack
[i
];
1952 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
1954 /* Gimplify the low bound and element type size and put them into
1955 the ARRAY_REF. If these values are set, they have already been
1957 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
1959 tree low
= unshare_expr (array_ref_low_bound (t
));
1960 if (!is_gimple_min_invariant (low
))
1962 TREE_OPERAND (t
, 2) = low
;
1963 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
1964 post_p
, is_gimple_reg
,
1966 ret
= MIN (ret
, tret
);
1971 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
1972 is_gimple_reg
, fb_rvalue
);
1973 ret
= MIN (ret
, tret
);
1976 if (TREE_OPERAND (t
, 3) == NULL_TREE
)
1978 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0)));
1979 tree elmt_size
= unshare_expr (array_ref_element_size (t
));
1980 tree factor
= size_int (TYPE_ALIGN_UNIT (elmt_type
));
1982 /* Divide the element size by the alignment of the element
1985 = size_binop_loc (loc
, EXACT_DIV_EXPR
, elmt_size
, factor
);
1987 if (!is_gimple_min_invariant (elmt_size
))
1989 TREE_OPERAND (t
, 3) = elmt_size
;
1990 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
,
1991 post_p
, is_gimple_reg
,
1993 ret
= MIN (ret
, tret
);
1998 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
, post_p
,
1999 is_gimple_reg
, fb_rvalue
);
2000 ret
= MIN (ret
, tret
);
2003 else if (TREE_CODE (t
) == COMPONENT_REF
)
2005 /* Set the field offset into T and gimplify it. */
2006 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2008 tree offset
= unshare_expr (component_ref_field_offset (t
));
2009 tree field
= TREE_OPERAND (t
, 1);
2011 = size_int (DECL_OFFSET_ALIGN (field
) / BITS_PER_UNIT
);
2013 /* Divide the offset by its alignment. */
2014 offset
= size_binop_loc (loc
, EXACT_DIV_EXPR
, offset
, factor
);
2016 if (!is_gimple_min_invariant (offset
))
2018 TREE_OPERAND (t
, 2) = offset
;
2019 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2020 post_p
, is_gimple_reg
,
2022 ret
= MIN (ret
, tret
);
2027 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2028 is_gimple_reg
, fb_rvalue
);
2029 ret
= MIN (ret
, tret
);
2034 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2035 so as to match the min_lval predicate. Failure to do so may result
2036 in the creation of large aggregate temporaries. */
2037 tret
= gimplify_expr (p
, pre_p
, post_p
, is_gimple_min_lval
,
2038 fallback
| fb_lvalue
);
2039 ret
= MIN (ret
, tret
);
2041 /* And finally, the indices and operands of ARRAY_REF. During this
2042 loop we also remove any useless conversions. */
2043 for (; expr_stack
.length () > 0; )
2045 tree t
= expr_stack
.pop ();
2047 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2049 /* Gimplify the dimension. */
2050 if (!is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
2052 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2053 is_gimple_val
, fb_rvalue
);
2054 ret
= MIN (ret
, tret
);
2058 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t
, 0));
2060 /* The innermost expression P may have originally had
2061 TREE_SIDE_EFFECTS set which would have caused all the outer
2062 expressions in *EXPR_P leading to P to also have had
2063 TREE_SIDE_EFFECTS set. */
2064 recalculate_side_effects (t
);
2067 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2068 if ((fallback
& fb_rvalue
) && TREE_CODE (*expr_p
) == COMPONENT_REF
)
2070 canonicalize_component_ref (expr_p
);
2073 expr_stack
.release ();
2075 gcc_assert (*expr_p
== expr
|| ret
!= GS_ALL_DONE
);
2080 /* Gimplify the self modifying expression pointed to by EXPR_P
2083 PRE_P points to the list where side effects that must happen before
2084 *EXPR_P should be stored.
2086 POST_P points to the list where side effects that must happen after
2087 *EXPR_P should be stored.
2089 WANT_VALUE is nonzero iff we want to use the value of this expression
2090 in another expression.
2092 ARITH_TYPE is the type the computation should be performed in. */
2094 enum gimplify_status
2095 gimplify_self_mod_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2096 bool want_value
, tree arith_type
)
2098 enum tree_code code
;
2099 tree lhs
, lvalue
, rhs
, t1
;
2100 gimple_seq post
= NULL
, *orig_post_p
= post_p
;
2102 enum tree_code arith_code
;
2103 enum gimplify_status ret
;
2104 location_t loc
= EXPR_LOCATION (*expr_p
);
2106 code
= TREE_CODE (*expr_p
);
2108 gcc_assert (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
2109 || code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
);
2111 /* Prefix or postfix? */
2112 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
2113 /* Faster to treat as prefix if result is not used. */
2114 postfix
= want_value
;
2118 /* For postfix, make sure the inner expression's post side effects
2119 are executed after side effects from this expression. */
2123 /* Add or subtract? */
2124 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2125 arith_code
= PLUS_EXPR
;
2127 arith_code
= MINUS_EXPR
;
2129 /* Gimplify the LHS into a GIMPLE lvalue. */
2130 lvalue
= TREE_OPERAND (*expr_p
, 0);
2131 ret
= gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
2132 if (ret
== GS_ERROR
)
2135 /* Extract the operands to the arithmetic operation. */
2137 rhs
= TREE_OPERAND (*expr_p
, 1);
2139 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2140 that as the result value and in the postqueue operation. */
2143 ret
= gimplify_expr (&lhs
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
2144 if (ret
== GS_ERROR
)
2147 lhs
= get_initialized_tmp_var (lhs
, pre_p
, NULL
);
2150 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2151 if (POINTER_TYPE_P (TREE_TYPE (lhs
)))
2153 rhs
= convert_to_ptrofftype_loc (loc
, rhs
);
2154 if (arith_code
== MINUS_EXPR
)
2155 rhs
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
2156 t1
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (*expr_p
), lhs
, rhs
);
2159 t1
= fold_convert (TREE_TYPE (*expr_p
),
2160 fold_build2 (arith_code
, arith_type
,
2161 fold_convert (arith_type
, lhs
),
2162 fold_convert (arith_type
, rhs
)));
2166 gimplify_assign (lvalue
, t1
, pre_p
);
2167 gimplify_seq_add_seq (orig_post_p
, post
);
2173 *expr_p
= build2 (MODIFY_EXPR
, TREE_TYPE (lvalue
), lvalue
, t1
);
2178 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2181 maybe_with_size_expr (tree
*expr_p
)
2183 tree expr
= *expr_p
;
2184 tree type
= TREE_TYPE (expr
);
2187 /* If we've already wrapped this or the type is error_mark_node, we can't do
2189 if (TREE_CODE (expr
) == WITH_SIZE_EXPR
2190 || type
== error_mark_node
)
2193 /* If the size isn't known or is a constant, we have nothing to do. */
2194 size
= TYPE_SIZE_UNIT (type
);
2195 if (!size
|| TREE_CODE (size
) == INTEGER_CST
)
2198 /* Otherwise, make a WITH_SIZE_EXPR. */
2199 size
= unshare_expr (size
);
2200 size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (size
, expr
);
2201 *expr_p
= build2 (WITH_SIZE_EXPR
, type
, expr
, size
);
2204 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2205 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2208 enum gimplify_status
2209 gimplify_arg (tree
*arg_p
, gimple_seq
*pre_p
, location_t call_location
)
2211 bool (*test
) (tree
);
2214 /* In general, we allow lvalues for function arguments to avoid
2215 extra overhead of copying large aggregates out of even larger
2216 aggregates into temporaries only to copy the temporaries to
2217 the argument list. Make optimizers happy by pulling out to
2218 temporaries those types that fit in registers. */
2219 if (is_gimple_reg_type (TREE_TYPE (*arg_p
)))
2220 test
= is_gimple_val
, fb
= fb_rvalue
;
2223 test
= is_gimple_lvalue
, fb
= fb_either
;
2224 /* Also strip a TARGET_EXPR that would force an extra copy. */
2225 if (TREE_CODE (*arg_p
) == TARGET_EXPR
)
2227 tree init
= TARGET_EXPR_INITIAL (*arg_p
);
2229 && !VOID_TYPE_P (TREE_TYPE (init
)))
2234 /* If this is a variable sized type, we must remember the size. */
2235 maybe_with_size_expr (arg_p
);
2237 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2238 /* Make sure arguments have the same location as the function call
2240 protected_set_expr_location (*arg_p
, call_location
);
2242 /* There is a sequence point before a function call. Side effects in
2243 the argument list must occur before the actual call. So, when
2244 gimplifying arguments, force gimplify_expr to use an internal
2245 post queue which is then appended to the end of PRE_P. */
2246 return gimplify_expr (arg_p
, pre_p
, NULL
, test
, fb
);
2249 /* Don't fold inside offloading or taskreg regions: it can break code by
2250 adding decl references that weren't in the source. We'll do it during
2251 omplower pass instead. */
2254 maybe_fold_stmt (gimple_stmt_iterator
*gsi
)
2256 struct gimplify_omp_ctx
*ctx
;
2257 for (ctx
= gimplify_omp_ctxp
; ctx
; ctx
= ctx
->outer_context
)
2258 if (ctx
->region_type
== ORT_TARGET
2259 || (ctx
->region_type
& (ORT_PARALLEL
| ORT_TASK
)) != 0)
2261 return fold_stmt (gsi
);
2264 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2265 WANT_VALUE is true if the result of the call is desired. */
2267 static enum gimplify_status
2268 gimplify_call_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
2270 tree fndecl
, parms
, p
, fnptrtype
;
2271 enum gimplify_status ret
;
2274 bool builtin_va_start_p
= false;
2275 location_t loc
= EXPR_LOCATION (*expr_p
);
2277 gcc_assert (TREE_CODE (*expr_p
) == CALL_EXPR
);
2279 /* For reliable diagnostics during inlining, it is necessary that
2280 every call_expr be annotated with file and line. */
2281 if (! EXPR_HAS_LOCATION (*expr_p
))
2282 SET_EXPR_LOCATION (*expr_p
, input_location
);
2284 /* Gimplify internal functions created in the FEs. */
2285 if (CALL_EXPR_FN (*expr_p
) == NULL_TREE
)
2290 nargs
= call_expr_nargs (*expr_p
);
2291 enum internal_fn ifn
= CALL_EXPR_IFN (*expr_p
);
2292 auto_vec
<tree
> vargs (nargs
);
2294 for (i
= 0; i
< nargs
; i
++)
2296 gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
2297 EXPR_LOCATION (*expr_p
));
2298 vargs
.quick_push (CALL_EXPR_ARG (*expr_p
, i
));
2300 gimple call
= gimple_build_call_internal_vec (ifn
, vargs
);
2301 gimplify_seq_add_stmt (pre_p
, call
);
2305 /* This may be a call to a builtin function.
2307 Builtin function calls may be transformed into different
2308 (and more efficient) builtin function calls under certain
2309 circumstances. Unfortunately, gimplification can muck things
2310 up enough that the builtin expanders are not aware that certain
2311 transformations are still valid.
2313 So we attempt transformation/gimplification of the call before
2314 we gimplify the CALL_EXPR. At this time we do not manage to
2315 transform all calls in the same manner as the expanders do, but
2316 we do transform most of them. */
2317 fndecl
= get_callee_fndecl (*expr_p
);
2319 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
2320 switch (DECL_FUNCTION_CODE (fndecl
))
2322 case BUILT_IN_VA_START
:
2324 builtin_va_start_p
= TRUE
;
2325 if (call_expr_nargs (*expr_p
) < 2)
2327 error ("too few arguments to function %<va_start%>");
2328 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2332 if (fold_builtin_next_arg (*expr_p
, true))
2334 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2341 *expr_p
= build_int_cst (TREE_TYPE (*expr_p
),
2342 LOCATION_LINE (EXPR_LOCATION (*expr_p
)));
2347 const char *locfile
= LOCATION_FILE (EXPR_LOCATION (*expr_p
));
2348 *expr_p
= build_string_literal (strlen (locfile
) + 1, locfile
);
2351 case BUILT_IN_FUNCTION
:
2353 const char *function
;
2354 function
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
2355 *expr_p
= build_string_literal (strlen (function
) + 1, function
);
2361 if (fndecl
&& DECL_BUILT_IN (fndecl
))
2363 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2364 if (new_tree
&& new_tree
!= *expr_p
)
2366 /* There was a transformation of this call which computes the
2367 same value, but in a more efficient way. Return and try
2374 /* Remember the original function pointer type. */
2375 fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*expr_p
));
2377 /* There is a sequence point before the call, so any side effects in
2378 the calling expression must occur before the actual call. Force
2379 gimplify_expr to use an internal post queue. */
2380 ret
= gimplify_expr (&CALL_EXPR_FN (*expr_p
), pre_p
, NULL
,
2381 is_gimple_call_addr
, fb_rvalue
);
2383 nargs
= call_expr_nargs (*expr_p
);
2385 /* Get argument types for verification. */
2386 fndecl
= get_callee_fndecl (*expr_p
);
2389 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2391 parms
= TYPE_ARG_TYPES (TREE_TYPE (fnptrtype
));
2393 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
2394 p
= DECL_ARGUMENTS (fndecl
);
2399 for (i
= 0; i
< nargs
&& p
; i
++, p
= TREE_CHAIN (p
))
2402 /* If the last argument is __builtin_va_arg_pack () and it is not
2403 passed as a named argument, decrease the number of CALL_EXPR
2404 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2407 && TREE_CODE (CALL_EXPR_ARG (*expr_p
, nargs
- 1)) == CALL_EXPR
)
2409 tree last_arg
= CALL_EXPR_ARG (*expr_p
, nargs
- 1);
2410 tree last_arg_fndecl
= get_callee_fndecl (last_arg
);
2413 && TREE_CODE (last_arg_fndecl
) == FUNCTION_DECL
2414 && DECL_BUILT_IN_CLASS (last_arg_fndecl
) == BUILT_IN_NORMAL
2415 && DECL_FUNCTION_CODE (last_arg_fndecl
) == BUILT_IN_VA_ARG_PACK
)
2417 tree call
= *expr_p
;
2420 *expr_p
= build_call_array_loc (loc
, TREE_TYPE (call
),
2421 CALL_EXPR_FN (call
),
2422 nargs
, CALL_EXPR_ARGP (call
));
2424 /* Copy all CALL_EXPR flags, location and block, except
2425 CALL_EXPR_VA_ARG_PACK flag. */
2426 CALL_EXPR_STATIC_CHAIN (*expr_p
) = CALL_EXPR_STATIC_CHAIN (call
);
2427 CALL_EXPR_TAILCALL (*expr_p
) = CALL_EXPR_TAILCALL (call
);
2428 CALL_EXPR_RETURN_SLOT_OPT (*expr_p
)
2429 = CALL_EXPR_RETURN_SLOT_OPT (call
);
2430 CALL_FROM_THUNK_P (*expr_p
) = CALL_FROM_THUNK_P (call
);
2431 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (call
));
2433 /* Set CALL_EXPR_VA_ARG_PACK. */
2434 CALL_EXPR_VA_ARG_PACK (*expr_p
) = 1;
2438 /* Gimplify the function arguments. */
2441 for (i
= (PUSH_ARGS_REVERSED
? nargs
- 1 : 0);
2442 PUSH_ARGS_REVERSED
? i
>= 0 : i
< nargs
;
2443 PUSH_ARGS_REVERSED
? i
-- : i
++)
2445 enum gimplify_status t
;
2447 /* Avoid gimplifying the second argument to va_start, which needs to
2448 be the plain PARM_DECL. */
2449 if ((i
!= 1) || !builtin_va_start_p
)
2451 t
= gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
2452 EXPR_LOCATION (*expr_p
));
2460 /* Gimplify the static chain. */
2461 if (CALL_EXPR_STATIC_CHAIN (*expr_p
))
2463 if (fndecl
&& !DECL_STATIC_CHAIN (fndecl
))
2464 CALL_EXPR_STATIC_CHAIN (*expr_p
) = NULL
;
2467 enum gimplify_status t
;
2468 t
= gimplify_arg (&CALL_EXPR_STATIC_CHAIN (*expr_p
), pre_p
,
2469 EXPR_LOCATION (*expr_p
));
2475 /* Verify the function result. */
2476 if (want_value
&& fndecl
2477 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype
))))
2479 error_at (loc
, "using result of function returning %<void%>");
2483 /* Try this again in case gimplification exposed something. */
2484 if (ret
!= GS_ERROR
)
2486 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2488 if (new_tree
&& new_tree
!= *expr_p
)
2490 /* There was a transformation of this call which computes the
2491 same value, but in a more efficient way. Return and try
2499 *expr_p
= error_mark_node
;
2503 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2504 decl. This allows us to eliminate redundant or useless
2505 calls to "const" functions. */
2506 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
2508 int flags
= call_expr_flags (*expr_p
);
2509 if (flags
& (ECF_CONST
| ECF_PURE
)
2510 /* An infinite loop is considered a side effect. */
2511 && !(flags
& (ECF_LOOPING_CONST_OR_PURE
)))
2512 TREE_SIDE_EFFECTS (*expr_p
) = 0;
2515 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2516 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2517 form and delegate the creation of a GIMPLE_CALL to
2518 gimplify_modify_expr. This is always possible because when
2519 WANT_VALUE is true, the caller wants the result of this call into
2520 a temporary, which means that we will emit an INIT_EXPR in
2521 internal_get_tmp_var which will then be handled by
2522 gimplify_modify_expr. */
2525 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2526 have to do is replicate it as a GIMPLE_CALL tuple. */
2527 gimple_stmt_iterator gsi
;
2528 call
= gimple_build_call_from_tree (*expr_p
);
2529 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
2530 notice_special_calls (call
);
2531 gimplify_seq_add_stmt (pre_p
, call
);
2532 gsi
= gsi_last (*pre_p
);
2533 maybe_fold_stmt (&gsi
);
2534 *expr_p
= NULL_TREE
;
2537 /* Remember the original function type. */
2538 CALL_EXPR_FN (*expr_p
) = build1 (NOP_EXPR
, fnptrtype
,
2539 CALL_EXPR_FN (*expr_p
));
2544 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2545 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2547 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2548 condition is true or false, respectively. If null, we should generate
2549 our own to skip over the evaluation of this specific expression.
2551 LOCUS is the source location of the COND_EXPR.
2553 This function is the tree equivalent of do_jump.
2555 shortcut_cond_r should only be called by shortcut_cond_expr. */
2558 shortcut_cond_r (tree pred
, tree
*true_label_p
, tree
*false_label_p
,
2561 tree local_label
= NULL_TREE
;
2562 tree t
, expr
= NULL
;
2564 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2565 retain the shortcut semantics. Just insert the gotos here;
2566 shortcut_cond_expr will append the real blocks later. */
2567 if (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2569 location_t new_locus
;
2571 /* Turn if (a && b) into
2573 if (a); else goto no;
2574 if (b) goto yes; else goto no;
2577 if (false_label_p
== NULL
)
2578 false_label_p
= &local_label
;
2580 /* Keep the original source location on the first 'if'. */
2581 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), NULL
, false_label_p
, locus
);
2582 append_to_statement_list (t
, &expr
);
2584 /* Set the source location of the && on the second 'if'. */
2585 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2586 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2588 append_to_statement_list (t
, &expr
);
2590 else if (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2592 location_t new_locus
;
2594 /* Turn if (a || b) into
2597 if (b) goto yes; else goto no;
2600 if (true_label_p
== NULL
)
2601 true_label_p
= &local_label
;
2603 /* Keep the original source location on the first 'if'. */
2604 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), true_label_p
, NULL
, locus
);
2605 append_to_statement_list (t
, &expr
);
2607 /* Set the source location of the || on the second 'if'. */
2608 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2609 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2611 append_to_statement_list (t
, &expr
);
2613 else if (TREE_CODE (pred
) == COND_EXPR
2614 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 1)))
2615 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 2))))
2617 location_t new_locus
;
2619 /* As long as we're messing with gotos, turn if (a ? b : c) into
2621 if (b) goto yes; else goto no;
2623 if (c) goto yes; else goto no;
2625 Don't do this if one of the arms has void type, which can happen
2626 in C++ when the arm is throw. */
2628 /* Keep the original source location on the first 'if'. Set the source
2629 location of the ? on the second 'if'. */
2630 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2631 expr
= build3 (COND_EXPR
, void_type_node
, TREE_OPERAND (pred
, 0),
2632 shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
,
2633 false_label_p
, locus
),
2634 shortcut_cond_r (TREE_OPERAND (pred
, 2), true_label_p
,
2635 false_label_p
, new_locus
));
2639 expr
= build3 (COND_EXPR
, void_type_node
, pred
,
2640 build_and_jump (true_label_p
),
2641 build_and_jump (false_label_p
));
2642 SET_EXPR_LOCATION (expr
, locus
);
2647 t
= build1 (LABEL_EXPR
, void_type_node
, local_label
);
2648 append_to_statement_list (t
, &expr
);
2654 /* Given a conditional expression EXPR with short-circuit boolean
2655 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2656 predicate apart into the equivalent sequence of conditionals. */
2659 shortcut_cond_expr (tree expr
)
2661 tree pred
= TREE_OPERAND (expr
, 0);
2662 tree then_
= TREE_OPERAND (expr
, 1);
2663 tree else_
= TREE_OPERAND (expr
, 2);
2664 tree true_label
, false_label
, end_label
, t
;
2666 tree
*false_label_p
;
2667 bool emit_end
, emit_false
, jump_over_else
;
2668 bool then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2669 bool else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2671 /* First do simple transformations. */
2674 /* If there is no 'else', turn
2677 if (a) if (b) then c. */
2678 while (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2680 /* Keep the original source location on the first 'if'. */
2681 location_t locus
= EXPR_LOC_OR_LOC (expr
, input_location
);
2682 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2683 /* Set the source location of the && on the second 'if'. */
2684 if (EXPR_HAS_LOCATION (pred
))
2685 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2686 then_
= shortcut_cond_expr (expr
);
2687 then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2688 pred
= TREE_OPERAND (pred
, 0);
2689 expr
= build3 (COND_EXPR
, void_type_node
, pred
, then_
, NULL_TREE
);
2690 SET_EXPR_LOCATION (expr
, locus
);
2696 /* If there is no 'then', turn
2699 if (a); else if (b); else d. */
2700 while (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2702 /* Keep the original source location on the first 'if'. */
2703 location_t locus
= EXPR_LOC_OR_LOC (expr
, input_location
);
2704 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2705 /* Set the source location of the || on the second 'if'. */
2706 if (EXPR_HAS_LOCATION (pred
))
2707 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2708 else_
= shortcut_cond_expr (expr
);
2709 else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2710 pred
= TREE_OPERAND (pred
, 0);
2711 expr
= build3 (COND_EXPR
, void_type_node
, pred
, NULL_TREE
, else_
);
2712 SET_EXPR_LOCATION (expr
, locus
);
2716 /* If we're done, great. */
2717 if (TREE_CODE (pred
) != TRUTH_ANDIF_EXPR
2718 && TREE_CODE (pred
) != TRUTH_ORIF_EXPR
)
2721 /* Otherwise we need to mess with gotos. Change
2724 if (a); else goto no;
2727 and recursively gimplify the condition. */
2729 true_label
= false_label
= end_label
= NULL_TREE
;
2731 /* If our arms just jump somewhere, hijack those labels so we don't
2732 generate jumps to jumps. */
2735 && TREE_CODE (then_
) == GOTO_EXPR
2736 && TREE_CODE (GOTO_DESTINATION (then_
)) == LABEL_DECL
)
2738 true_label
= GOTO_DESTINATION (then_
);
2744 && TREE_CODE (else_
) == GOTO_EXPR
2745 && TREE_CODE (GOTO_DESTINATION (else_
)) == LABEL_DECL
)
2747 false_label
= GOTO_DESTINATION (else_
);
2752 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2754 true_label_p
= &true_label
;
2756 true_label_p
= NULL
;
2758 /* The 'else' branch also needs a label if it contains interesting code. */
2759 if (false_label
|| else_se
)
2760 false_label_p
= &false_label
;
2762 false_label_p
= NULL
;
2764 /* If there was nothing else in our arms, just forward the label(s). */
2765 if (!then_se
&& !else_se
)
2766 return shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2767 EXPR_LOC_OR_LOC (expr
, input_location
));
2769 /* If our last subexpression already has a terminal label, reuse it. */
2771 t
= expr_last (else_
);
2773 t
= expr_last (then_
);
2776 if (t
&& TREE_CODE (t
) == LABEL_EXPR
)
2777 end_label
= LABEL_EXPR_LABEL (t
);
2779 /* If we don't care about jumping to the 'else' branch, jump to the end
2780 if the condition is false. */
2782 false_label_p
= &end_label
;
2784 /* We only want to emit these labels if we aren't hijacking them. */
2785 emit_end
= (end_label
== NULL_TREE
);
2786 emit_false
= (false_label
== NULL_TREE
);
2788 /* We only emit the jump over the else clause if we have to--if the
2789 then clause may fall through. Otherwise we can wind up with a
2790 useless jump and a useless label at the end of gimplified code,
2791 which will cause us to think that this conditional as a whole
2792 falls through even if it doesn't. If we then inline a function
2793 which ends with such a condition, that can cause us to issue an
2794 inappropriate warning about control reaching the end of a
2795 non-void function. */
2796 jump_over_else
= block_may_fallthru (then_
);
2798 pred
= shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2799 EXPR_LOC_OR_LOC (expr
, input_location
));
2802 append_to_statement_list (pred
, &expr
);
2804 append_to_statement_list (then_
, &expr
);
2809 tree last
= expr_last (expr
);
2810 t
= build_and_jump (&end_label
);
2811 if (EXPR_HAS_LOCATION (last
))
2812 SET_EXPR_LOCATION (t
, EXPR_LOCATION (last
));
2813 append_to_statement_list (t
, &expr
);
2817 t
= build1 (LABEL_EXPR
, void_type_node
, false_label
);
2818 append_to_statement_list (t
, &expr
);
2820 append_to_statement_list (else_
, &expr
);
2822 if (emit_end
&& end_label
)
2824 t
= build1 (LABEL_EXPR
, void_type_node
, end_label
);
2825 append_to_statement_list (t
, &expr
);
2831 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2834 gimple_boolify (tree expr
)
2836 tree type
= TREE_TYPE (expr
);
2837 location_t loc
= EXPR_LOCATION (expr
);
2839 if (TREE_CODE (expr
) == NE_EXPR
2840 && TREE_CODE (TREE_OPERAND (expr
, 0)) == CALL_EXPR
2841 && integer_zerop (TREE_OPERAND (expr
, 1)))
2843 tree call
= TREE_OPERAND (expr
, 0);
2844 tree fn
= get_callee_fndecl (call
);
2846 /* For __builtin_expect ((long) (x), y) recurse into x as well
2847 if x is truth_value_p. */
2849 && DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2850 && DECL_FUNCTION_CODE (fn
) == BUILT_IN_EXPECT
2851 && call_expr_nargs (call
) == 2)
2853 tree arg
= CALL_EXPR_ARG (call
, 0);
2856 if (TREE_CODE (arg
) == NOP_EXPR
2857 && TREE_TYPE (arg
) == TREE_TYPE (call
))
2858 arg
= TREE_OPERAND (arg
, 0);
2859 if (truth_value_p (TREE_CODE (arg
)))
2861 arg
= gimple_boolify (arg
);
2862 CALL_EXPR_ARG (call
, 0)
2863 = fold_convert_loc (loc
, TREE_TYPE (call
), arg
);
2869 switch (TREE_CODE (expr
))
2871 case TRUTH_AND_EXPR
:
2873 case TRUTH_XOR_EXPR
:
2874 case TRUTH_ANDIF_EXPR
:
2875 case TRUTH_ORIF_EXPR
:
2876 /* Also boolify the arguments of truth exprs. */
2877 TREE_OPERAND (expr
, 1) = gimple_boolify (TREE_OPERAND (expr
, 1));
2880 case TRUTH_NOT_EXPR
:
2881 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
2883 /* These expressions always produce boolean results. */
2884 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
2885 TREE_TYPE (expr
) = boolean_type_node
;
2889 switch ((enum annot_expr_kind
) TREE_INT_CST_LOW (TREE_OPERAND (expr
, 1)))
2891 case annot_expr_ivdep_kind
:
2892 case annot_expr_no_vector_kind
:
2893 case annot_expr_vector_kind
:
2894 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
2895 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
2896 TREE_TYPE (expr
) = boolean_type_node
;
2903 if (COMPARISON_CLASS_P (expr
))
2905 /* There expressions always prduce boolean results. */
2906 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
2907 TREE_TYPE (expr
) = boolean_type_node
;
2910 /* Other expressions that get here must have boolean values, but
2911 might need to be converted to the appropriate mode. */
2912 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
2914 return fold_convert_loc (loc
, boolean_type_node
, expr
);
2918 /* Given a conditional expression *EXPR_P without side effects, gimplify
2919 its operands. New statements are inserted to PRE_P. */
2921 static enum gimplify_status
2922 gimplify_pure_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2924 tree expr
= *expr_p
, cond
;
2925 enum gimplify_status ret
, tret
;
2926 enum tree_code code
;
2928 cond
= gimple_boolify (COND_EXPR_COND (expr
));
2930 /* We need to handle && and || specially, as their gimplification
2931 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
2932 code
= TREE_CODE (cond
);
2933 if (code
== TRUTH_ANDIF_EXPR
)
2934 TREE_SET_CODE (cond
, TRUTH_AND_EXPR
);
2935 else if (code
== TRUTH_ORIF_EXPR
)
2936 TREE_SET_CODE (cond
, TRUTH_OR_EXPR
);
2937 ret
= gimplify_expr (&cond
, pre_p
, NULL
, is_gimple_condexpr
, fb_rvalue
);
2938 COND_EXPR_COND (*expr_p
) = cond
;
2940 tret
= gimplify_expr (&COND_EXPR_THEN (expr
), pre_p
, NULL
,
2941 is_gimple_val
, fb_rvalue
);
2942 ret
= MIN (ret
, tret
);
2943 tret
= gimplify_expr (&COND_EXPR_ELSE (expr
), pre_p
, NULL
,
2944 is_gimple_val
, fb_rvalue
);
2946 return MIN (ret
, tret
);
2949 /* Return true if evaluating EXPR could trap.
2950 EXPR is GENERIC, while tree_could_trap_p can be called
2954 generic_expr_could_trap_p (tree expr
)
2958 if (!expr
|| is_gimple_val (expr
))
2961 if (!EXPR_P (expr
) || tree_could_trap_p (expr
))
2964 n
= TREE_OPERAND_LENGTH (expr
);
2965 for (i
= 0; i
< n
; i
++)
2966 if (generic_expr_could_trap_p (TREE_OPERAND (expr
, i
)))
2972 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2981 The second form is used when *EXPR_P is of type void.
2983 PRE_P points to the list where side effects that must happen before
2984 *EXPR_P should be stored. */
2986 static enum gimplify_status
2987 gimplify_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
, fallback_t fallback
)
2989 tree expr
= *expr_p
;
2990 tree type
= TREE_TYPE (expr
);
2991 location_t loc
= EXPR_LOCATION (expr
);
2992 tree tmp
, arm1
, arm2
;
2993 enum gimplify_status ret
;
2994 tree label_true
, label_false
, label_cont
;
2995 bool have_then_clause_p
, have_else_clause_p
;
2997 enum tree_code pred_code
;
2998 gimple_seq seq
= NULL
;
3000 /* If this COND_EXPR has a value, copy the values into a temporary within
3002 if (!VOID_TYPE_P (type
))
3004 tree then_
= TREE_OPERAND (expr
, 1), else_
= TREE_OPERAND (expr
, 2);
3007 /* If either an rvalue is ok or we do not require an lvalue, create the
3008 temporary. But we cannot do that if the type is addressable. */
3009 if (((fallback
& fb_rvalue
) || !(fallback
& fb_lvalue
))
3010 && !TREE_ADDRESSABLE (type
))
3012 if (gimplify_ctxp
->allow_rhs_cond_expr
3013 /* If either branch has side effects or could trap, it can't be
3014 evaluated unconditionally. */
3015 && !TREE_SIDE_EFFECTS (then_
)
3016 && !generic_expr_could_trap_p (then_
)
3017 && !TREE_SIDE_EFFECTS (else_
)
3018 && !generic_expr_could_trap_p (else_
))
3019 return gimplify_pure_cond_expr (expr_p
, pre_p
);
3021 tmp
= create_tmp_var (type
, "iftmp");
3025 /* Otherwise, only create and copy references to the values. */
3028 type
= build_pointer_type (type
);
3030 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3031 then_
= build_fold_addr_expr_loc (loc
, then_
);
3033 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3034 else_
= build_fold_addr_expr_loc (loc
, else_
);
3037 = build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0), then_
, else_
);
3039 tmp
= create_tmp_var (type
, "iftmp");
3040 result
= build_simple_mem_ref_loc (loc
, tmp
);
3043 /* Build the new then clause, `tmp = then_;'. But don't build the
3044 assignment if the value is void; in C++ it can be if it's a throw. */
3045 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3046 TREE_OPERAND (expr
, 1) = build2 (MODIFY_EXPR
, type
, tmp
, then_
);
3048 /* Similarly, build the new else clause, `tmp = else_;'. */
3049 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3050 TREE_OPERAND (expr
, 2) = build2 (MODIFY_EXPR
, type
, tmp
, else_
);
3052 TREE_TYPE (expr
) = void_type_node
;
3053 recalculate_side_effects (expr
);
3055 /* Move the COND_EXPR to the prequeue. */
3056 gimplify_stmt (&expr
, pre_p
);
3062 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
3063 STRIP_TYPE_NOPS (TREE_OPERAND (expr
, 0));
3064 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == COMPOUND_EXPR
)
3065 gimplify_compound_expr (&TREE_OPERAND (expr
, 0), pre_p
, true);
3067 /* Make sure the condition has BOOLEAN_TYPE. */
3068 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3070 /* Break apart && and || conditions. */
3071 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ANDIF_EXPR
3072 || TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ORIF_EXPR
)
3074 expr
= shortcut_cond_expr (expr
);
3076 if (expr
!= *expr_p
)
3080 /* We can't rely on gimplify_expr to re-gimplify the expanded
3081 form properly, as cleanups might cause the target labels to be
3082 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3083 set up a conditional context. */
3084 gimple_push_condition ();
3085 gimplify_stmt (expr_p
, &seq
);
3086 gimple_pop_condition (pre_p
);
3087 gimple_seq_add_seq (pre_p
, seq
);
3093 /* Now do the normal gimplification. */
3095 /* Gimplify condition. */
3096 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, NULL
, is_gimple_condexpr
,
3098 if (ret
== GS_ERROR
)
3100 gcc_assert (TREE_OPERAND (expr
, 0) != NULL_TREE
);
3102 gimple_push_condition ();
3104 have_then_clause_p
= have_else_clause_p
= false;
3105 if (TREE_OPERAND (expr
, 1) != NULL
3106 && TREE_CODE (TREE_OPERAND (expr
, 1)) == GOTO_EXPR
3107 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 1))) == LABEL_DECL
3108 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 1)))
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
, 1))
3116 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 1))))
3118 label_true
= GOTO_DESTINATION (TREE_OPERAND (expr
, 1));
3119 have_then_clause_p
= true;
3122 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
3123 if (TREE_OPERAND (expr
, 2) != NULL
3124 && TREE_CODE (TREE_OPERAND (expr
, 2)) == GOTO_EXPR
3125 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 2))) == LABEL_DECL
3126 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 2)))
3127 == current_function_decl
)
3128 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3129 have different locations, otherwise we end up with incorrect
3130 location information on the branches. */
3132 || !EXPR_HAS_LOCATION (expr
)
3133 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 2))
3134 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 2))))
3136 label_false
= GOTO_DESTINATION (TREE_OPERAND (expr
, 2));
3137 have_else_clause_p
= true;
3140 label_false
= create_artificial_label (UNKNOWN_LOCATION
);
3142 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr
), &pred_code
, &arm1
,
3145 cond_stmt
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
,
3148 gimplify_seq_add_stmt (&seq
, cond_stmt
);
3149 label_cont
= NULL_TREE
;
3150 if (!have_then_clause_p
)
3152 /* For if (...) {} else { code; } put label_true after
3154 if (TREE_OPERAND (expr
, 1) == NULL_TREE
3155 && !have_else_clause_p
3156 && TREE_OPERAND (expr
, 2) != NULL_TREE
)
3157 label_cont
= label_true
;
3160 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_true
));
3161 have_then_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 1), &seq
);
3162 /* For if (...) { code; } else {} or
3163 if (...) { code; } else goto label; or
3164 if (...) { code; return; } else { ... }
3165 label_cont isn't needed. */
3166 if (!have_else_clause_p
3167 && TREE_OPERAND (expr
, 2) != NULL_TREE
3168 && gimple_seq_may_fallthru (seq
))
3171 label_cont
= create_artificial_label (UNKNOWN_LOCATION
);
3173 g
= gimple_build_goto (label_cont
);
3175 /* GIMPLE_COND's are very low level; they have embedded
3176 gotos. This particular embedded goto should not be marked
3177 with the location of the original COND_EXPR, as it would
3178 correspond to the COND_EXPR's condition, not the ELSE or the
3179 THEN arms. To avoid marking it with the wrong location, flag
3180 it as "no location". */
3181 gimple_set_do_not_emit_location (g
);
3183 gimplify_seq_add_stmt (&seq
, g
);
3187 if (!have_else_clause_p
)
3189 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_false
));
3190 have_else_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 2), &seq
);
3193 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_cont
));
3195 gimple_pop_condition (pre_p
);
3196 gimple_seq_add_seq (pre_p
, seq
);
3198 if (ret
== GS_ERROR
)
3200 else if (have_then_clause_p
|| have_else_clause_p
)
3204 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3205 expr
= TREE_OPERAND (expr
, 0);
3206 gimplify_stmt (&expr
, pre_p
);
3213 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3214 to be marked addressable.
3216 We cannot rely on such an expression being directly markable if a temporary
3217 has been created by the gimplification. In this case, we create another
3218 temporary and initialize it with a copy, which will become a store after we
3219 mark it addressable. This can happen if the front-end passed us something
3220 that it could not mark addressable yet, like a Fortran pass-by-reference
3221 parameter (int) floatvar. */
3224 prepare_gimple_addressable (tree
*expr_p
, gimple_seq
*seq_p
)
3226 while (handled_component_p (*expr_p
))
3227 expr_p
= &TREE_OPERAND (*expr_p
, 0);
3228 if (is_gimple_reg (*expr_p
))
3230 tree var
= get_initialized_tmp_var (*expr_p
, seq_p
, NULL
);
3231 DECL_GIMPLE_REG_P (var
) = 0;
3236 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3237 a call to __builtin_memcpy. */
3239 static enum gimplify_status
3240 gimplify_modify_expr_to_memcpy (tree
*expr_p
, tree size
, bool want_value
,
3243 tree t
, to
, to_ptr
, from
, from_ptr
;
3245 location_t loc
= EXPR_LOCATION (*expr_p
);
3247 to
= TREE_OPERAND (*expr_p
, 0);
3248 from
= TREE_OPERAND (*expr_p
, 1);
3250 /* Mark the RHS addressable. Beware that it may not be possible to do so
3251 directly if a temporary has been created by the gimplification. */
3252 prepare_gimple_addressable (&from
, seq_p
);
3254 mark_addressable (from
);
3255 from_ptr
= build_fold_addr_expr_loc (loc
, from
);
3256 gimplify_arg (&from_ptr
, seq_p
, loc
);
3258 mark_addressable (to
);
3259 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3260 gimplify_arg (&to_ptr
, seq_p
, loc
);
3262 t
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3264 gs
= gimple_build_call (t
, 3, to_ptr
, from_ptr
, size
);
3268 /* tmp = memcpy() */
3269 t
= create_tmp_var (TREE_TYPE (to_ptr
));
3270 gimple_call_set_lhs (gs
, t
);
3271 gimplify_seq_add_stmt (seq_p
, gs
);
3273 *expr_p
= build_simple_mem_ref (t
);
3277 gimplify_seq_add_stmt (seq_p
, gs
);
3282 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3283 a call to __builtin_memset. In this case we know that the RHS is
3284 a CONSTRUCTOR with an empty element list. */
3286 static enum gimplify_status
3287 gimplify_modify_expr_to_memset (tree
*expr_p
, tree size
, bool want_value
,
3290 tree t
, from
, to
, to_ptr
;
3292 location_t loc
= EXPR_LOCATION (*expr_p
);
3294 /* Assert our assumptions, to abort instead of producing wrong code
3295 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3296 not be immediately exposed. */
3297 from
= TREE_OPERAND (*expr_p
, 1);
3298 if (TREE_CODE (from
) == WITH_SIZE_EXPR
)
3299 from
= TREE_OPERAND (from
, 0);
3301 gcc_assert (TREE_CODE (from
) == CONSTRUCTOR
3302 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from
)));
3305 to
= TREE_OPERAND (*expr_p
, 0);
3307 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3308 gimplify_arg (&to_ptr
, seq_p
, loc
);
3309 t
= builtin_decl_implicit (BUILT_IN_MEMSET
);
3311 gs
= gimple_build_call (t
, 3, to_ptr
, integer_zero_node
, size
);
3315 /* tmp = memset() */
3316 t
= create_tmp_var (TREE_TYPE (to_ptr
));
3317 gimple_call_set_lhs (gs
, t
);
3318 gimplify_seq_add_stmt (seq_p
, gs
);
3320 *expr_p
= build1 (INDIRECT_REF
, TREE_TYPE (to
), t
);
3324 gimplify_seq_add_stmt (seq_p
, gs
);
3329 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3330 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3331 assignment. Return non-null if we detect a potential overlap. */
3333 struct gimplify_init_ctor_preeval_data
3335 /* The base decl of the lhs object. May be NULL, in which case we
3336 have to assume the lhs is indirect. */
3339 /* The alias set of the lhs object. */
3340 alias_set_type lhs_alias_set
;
3344 gimplify_init_ctor_preeval_1 (tree
*tp
, int *walk_subtrees
, void *xdata
)
3346 struct gimplify_init_ctor_preeval_data
*data
3347 = (struct gimplify_init_ctor_preeval_data
*) xdata
;
3350 /* If we find the base object, obviously we have overlap. */
3351 if (data
->lhs_base_decl
== t
)
3354 /* If the constructor component is indirect, determine if we have a
3355 potential overlap with the lhs. The only bits of information we
3356 have to go on at this point are addressability and alias sets. */
3357 if ((INDIRECT_REF_P (t
)
3358 || TREE_CODE (t
) == MEM_REF
)
3359 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3360 && alias_sets_conflict_p (data
->lhs_alias_set
, get_alias_set (t
)))
3363 /* If the constructor component is a call, determine if it can hide a
3364 potential overlap with the lhs through an INDIRECT_REF like above.
3365 ??? Ugh - this is completely broken. In fact this whole analysis
3366 doesn't look conservative. */
3367 if (TREE_CODE (t
) == CALL_EXPR
)
3369 tree type
, fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t
)));
3371 for (type
= TYPE_ARG_TYPES (fntype
); type
; type
= TREE_CHAIN (type
))
3372 if (POINTER_TYPE_P (TREE_VALUE (type
))
3373 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3374 && alias_sets_conflict_p (data
->lhs_alias_set
,
3376 (TREE_TYPE (TREE_VALUE (type
)))))
3380 if (IS_TYPE_OR_DECL_P (t
))
3385 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3386 force values that overlap with the lhs (as described by *DATA)
3387 into temporaries. */
3390 gimplify_init_ctor_preeval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3391 struct gimplify_init_ctor_preeval_data
*data
)
3393 enum gimplify_status one
;
3395 /* If the value is constant, then there's nothing to pre-evaluate. */
3396 if (TREE_CONSTANT (*expr_p
))
3398 /* Ensure it does not have side effects, it might contain a reference to
3399 the object we're initializing. */
3400 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p
));
3404 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3405 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p
)))
3408 /* Recurse for nested constructors. */
3409 if (TREE_CODE (*expr_p
) == CONSTRUCTOR
)
3411 unsigned HOST_WIDE_INT ix
;
3412 constructor_elt
*ce
;
3413 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (*expr_p
);
3415 FOR_EACH_VEC_SAFE_ELT (v
, ix
, ce
)
3416 gimplify_init_ctor_preeval (&ce
->value
, pre_p
, post_p
, data
);
3421 /* If this is a variable sized type, we must remember the size. */
3422 maybe_with_size_expr (expr_p
);
3424 /* Gimplify the constructor element to something appropriate for the rhs
3425 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3426 the gimplifier will consider this a store to memory. Doing this
3427 gimplification now means that we won't have to deal with complicated
3428 language-specific trees, nor trees like SAVE_EXPR that can induce
3429 exponential search behavior. */
3430 one
= gimplify_expr (expr_p
, pre_p
, post_p
, is_gimple_mem_rhs
, fb_rvalue
);
3431 if (one
== GS_ERROR
)
3437 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3438 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3439 always be true for all scalars, since is_gimple_mem_rhs insists on a
3440 temporary variable for them. */
3441 if (DECL_P (*expr_p
))
3444 /* If this is of variable size, we have no choice but to assume it doesn't
3445 overlap since we can't make a temporary for it. */
3446 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p
))) != INTEGER_CST
)
3449 /* Otherwise, we must search for overlap ... */
3450 if (!walk_tree (expr_p
, gimplify_init_ctor_preeval_1
, data
, NULL
))
3453 /* ... and if found, force the value into a temporary. */
3454 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
3457 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3458 a RANGE_EXPR in a CONSTRUCTOR for an array.
3462 object[var] = value;
3469 We increment var _after_ the loop exit check because we might otherwise
3470 fail if upper == TYPE_MAX_VALUE (type for upper).
3472 Note that we never have to deal with SAVE_EXPRs here, because this has
3473 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3475 static void gimplify_init_ctor_eval (tree
, vec
<constructor_elt
, va_gc
> *,
3476 gimple_seq
*, bool);
3479 gimplify_init_ctor_eval_range (tree object
, tree lower
, tree upper
,
3480 tree value
, tree array_elt_type
,
3481 gimple_seq
*pre_p
, bool cleared
)
3483 tree loop_entry_label
, loop_exit_label
, fall_thru_label
;
3484 tree var
, var_type
, cref
, tmp
;
3486 loop_entry_label
= create_artificial_label (UNKNOWN_LOCATION
);
3487 loop_exit_label
= create_artificial_label (UNKNOWN_LOCATION
);
3488 fall_thru_label
= create_artificial_label (UNKNOWN_LOCATION
);
3490 /* Create and initialize the index variable. */
3491 var_type
= TREE_TYPE (upper
);
3492 var
= create_tmp_var (var_type
);
3493 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, lower
));
3495 /* Add the loop entry label. */
3496 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_entry_label
));
3498 /* Build the reference. */
3499 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3500 var
, NULL_TREE
, NULL_TREE
);
3502 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3503 the store. Otherwise just assign value to the reference. */
3505 if (TREE_CODE (value
) == CONSTRUCTOR
)
3506 /* NB we might have to call ourself recursively through
3507 gimplify_init_ctor_eval if the value is a constructor. */
3508 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3511 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (cref
, value
));
3513 /* We exit the loop when the index var is equal to the upper bound. */
3514 gimplify_seq_add_stmt (pre_p
,
3515 gimple_build_cond (EQ_EXPR
, var
, upper
,
3516 loop_exit_label
, fall_thru_label
));
3518 gimplify_seq_add_stmt (pre_p
, gimple_build_label (fall_thru_label
));
3520 /* Otherwise, increment the index var... */
3521 tmp
= build2 (PLUS_EXPR
, var_type
, var
,
3522 fold_convert (var_type
, integer_one_node
));
3523 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, tmp
));
3525 /* ...and jump back to the loop entry. */
3526 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (loop_entry_label
));
3528 /* Add the loop exit label. */
3529 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_exit_label
));
3532 /* Return true if FDECL is accessing a field that is zero sized. */
3535 zero_sized_field_decl (const_tree fdecl
)
3537 if (TREE_CODE (fdecl
) == FIELD_DECL
&& DECL_SIZE (fdecl
)
3538 && integer_zerop (DECL_SIZE (fdecl
)))
3543 /* Return true if TYPE is zero sized. */
3546 zero_sized_type (const_tree type
)
3548 if (AGGREGATE_TYPE_P (type
) && TYPE_SIZE (type
)
3549 && integer_zerop (TYPE_SIZE (type
)))
3554 /* A subroutine of gimplify_init_constructor. Generate individual
3555 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3556 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3557 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3561 gimplify_init_ctor_eval (tree object
, vec
<constructor_elt
, va_gc
> *elts
,
3562 gimple_seq
*pre_p
, bool cleared
)
3564 tree array_elt_type
= NULL
;
3565 unsigned HOST_WIDE_INT ix
;
3566 tree purpose
, value
;
3568 if (TREE_CODE (TREE_TYPE (object
)) == ARRAY_TYPE
)
3569 array_elt_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object
)));
3571 FOR_EACH_CONSTRUCTOR_ELT (elts
, ix
, purpose
, value
)
3575 /* NULL values are created above for gimplification errors. */
3579 if (cleared
&& initializer_zerop (value
))
3582 /* ??? Here's to hoping the front end fills in all of the indices,
3583 so we don't have to figure out what's missing ourselves. */
3584 gcc_assert (purpose
);
3586 /* Skip zero-sized fields, unless value has side-effects. This can
3587 happen with calls to functions returning a zero-sized type, which
3588 we shouldn't discard. As a number of downstream passes don't
3589 expect sets of zero-sized fields, we rely on the gimplification of
3590 the MODIFY_EXPR we make below to drop the assignment statement. */
3591 if (! TREE_SIDE_EFFECTS (value
) && zero_sized_field_decl (purpose
))
3594 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3596 if (TREE_CODE (purpose
) == RANGE_EXPR
)
3598 tree lower
= TREE_OPERAND (purpose
, 0);
3599 tree upper
= TREE_OPERAND (purpose
, 1);
3601 /* If the lower bound is equal to upper, just treat it as if
3602 upper was the index. */
3603 if (simple_cst_equal (lower
, upper
))
3607 gimplify_init_ctor_eval_range (object
, lower
, upper
, value
,
3608 array_elt_type
, pre_p
, cleared
);
3615 /* Do not use bitsizetype for ARRAY_REF indices. */
3616 if (TYPE_DOMAIN (TREE_TYPE (object
)))
3618 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object
))),
3620 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3621 purpose
, NULL_TREE
, NULL_TREE
);
3625 gcc_assert (TREE_CODE (purpose
) == FIELD_DECL
);
3626 cref
= build3 (COMPONENT_REF
, TREE_TYPE (purpose
),
3627 unshare_expr (object
), purpose
, NULL_TREE
);
3630 if (TREE_CODE (value
) == CONSTRUCTOR
3631 && TREE_CODE (TREE_TYPE (value
)) != VECTOR_TYPE
)
3632 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3636 tree init
= build2 (INIT_EXPR
, TREE_TYPE (cref
), cref
, value
);
3637 gimplify_and_add (init
, pre_p
);
3643 /* Return the appropriate RHS predicate for this LHS. */
3646 rhs_predicate_for (tree lhs
)
3648 if (is_gimple_reg (lhs
))
3649 return is_gimple_reg_rhs_or_call
;
3651 return is_gimple_mem_rhs_or_call
;
3654 /* Gimplify a C99 compound literal expression. This just means adding
3655 the DECL_EXPR before the current statement and using its anonymous
3658 static enum gimplify_status
3659 gimplify_compound_literal_expr (tree
*expr_p
, gimple_seq
*pre_p
,
3660 bool (*gimple_test_f
) (tree
),
3661 fallback_t fallback
)
3663 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p
);
3664 tree decl
= DECL_EXPR_DECL (decl_s
);
3665 tree init
= DECL_INITIAL (decl
);
3666 /* Mark the decl as addressable if the compound literal
3667 expression is addressable now, otherwise it is marked too late
3668 after we gimplify the initialization expression. */
3669 if (TREE_ADDRESSABLE (*expr_p
))
3670 TREE_ADDRESSABLE (decl
) = 1;
3671 /* Otherwise, if we don't need an lvalue and have a literal directly
3672 substitute it. Check if it matches the gimple predicate, as
3673 otherwise we'd generate a new temporary, and we can as well just
3674 use the decl we already have. */
3675 else if (!TREE_ADDRESSABLE (decl
)
3677 && (fallback
& fb_lvalue
) == 0
3678 && gimple_test_f (init
))
3684 /* Preliminarily mark non-addressed complex variables as eligible
3685 for promotion to gimple registers. We'll transform their uses
3687 if ((TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
3688 || TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
)
3689 && !TREE_THIS_VOLATILE (decl
)
3690 && !needs_to_live_in_memory (decl
))
3691 DECL_GIMPLE_REG_P (decl
) = 1;
3693 /* If the decl is not addressable, then it is being used in some
3694 expression or on the right hand side of a statement, and it can
3695 be put into a readonly data section. */
3696 if (!TREE_ADDRESSABLE (decl
) && (fallback
& fb_lvalue
) == 0)
3697 TREE_READONLY (decl
) = 1;
3699 /* This decl isn't mentioned in the enclosing block, so add it to the
3700 list of temps. FIXME it seems a bit of a kludge to say that
3701 anonymous artificial vars aren't pushed, but everything else is. */
3702 if (DECL_NAME (decl
) == NULL_TREE
&& !DECL_SEEN_IN_BIND_EXPR_P (decl
))
3703 gimple_add_tmp_var (decl
);
3705 gimplify_and_add (decl_s
, pre_p
);
3710 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3711 return a new CONSTRUCTOR if something changed. */
3714 optimize_compound_literals_in_ctor (tree orig_ctor
)
3716 tree ctor
= orig_ctor
;
3717 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
3718 unsigned int idx
, num
= vec_safe_length (elts
);
3720 for (idx
= 0; idx
< num
; idx
++)
3722 tree value
= (*elts
)[idx
].value
;
3723 tree newval
= value
;
3724 if (TREE_CODE (value
) == CONSTRUCTOR
)
3725 newval
= optimize_compound_literals_in_ctor (value
);
3726 else if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
3728 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (value
);
3729 tree decl
= DECL_EXPR_DECL (decl_s
);
3730 tree init
= DECL_INITIAL (decl
);
3732 if (!TREE_ADDRESSABLE (value
)
3733 && !TREE_ADDRESSABLE (decl
)
3735 && TREE_CODE (init
) == CONSTRUCTOR
)
3736 newval
= optimize_compound_literals_in_ctor (init
);
3738 if (newval
== value
)
3741 if (ctor
== orig_ctor
)
3743 ctor
= copy_node (orig_ctor
);
3744 CONSTRUCTOR_ELTS (ctor
) = vec_safe_copy (elts
);
3745 elts
= CONSTRUCTOR_ELTS (ctor
);
3747 (*elts
)[idx
].value
= newval
;
3752 /* A subroutine of gimplify_modify_expr. Break out elements of a
3753 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3755 Note that we still need to clear any elements that don't have explicit
3756 initializers, so if not all elements are initialized we keep the
3757 original MODIFY_EXPR, we just remove all of the constructor elements.
3759 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3760 GS_ERROR if we would have to create a temporary when gimplifying
3761 this constructor. Otherwise, return GS_OK.
3763 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3765 static enum gimplify_status
3766 gimplify_init_constructor (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3767 bool want_value
, bool notify_temp_creation
)
3769 tree object
, ctor
, type
;
3770 enum gimplify_status ret
;
3771 vec
<constructor_elt
, va_gc
> *elts
;
3773 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == CONSTRUCTOR
);
3775 if (!notify_temp_creation
)
3777 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
3778 is_gimple_lvalue
, fb_lvalue
);
3779 if (ret
== GS_ERROR
)
3783 object
= TREE_OPERAND (*expr_p
, 0);
3784 ctor
= TREE_OPERAND (*expr_p
, 1) =
3785 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p
, 1));
3786 type
= TREE_TYPE (ctor
);
3787 elts
= CONSTRUCTOR_ELTS (ctor
);
3790 switch (TREE_CODE (type
))
3794 case QUAL_UNION_TYPE
:
3797 struct gimplify_init_ctor_preeval_data preeval_data
;
3798 HOST_WIDE_INT num_ctor_elements
, num_nonzero_elements
;
3799 bool cleared
, complete_p
, valid_const_initializer
;
3801 /* Aggregate types must lower constructors to initialization of
3802 individual elements. The exception is that a CONSTRUCTOR node
3803 with no elements indicates zero-initialization of the whole. */
3804 if (vec_safe_is_empty (elts
))
3806 if (notify_temp_creation
)
3811 /* Fetch information about the constructor to direct later processing.
3812 We might want to make static versions of it in various cases, and
3813 can only do so if it known to be a valid constant initializer. */
3814 valid_const_initializer
3815 = categorize_ctor_elements (ctor
, &num_nonzero_elements
,
3816 &num_ctor_elements
, &complete_p
);
3818 /* If a const aggregate variable is being initialized, then it
3819 should never be a lose to promote the variable to be static. */
3820 if (valid_const_initializer
3821 && num_nonzero_elements
> 1
3822 && TREE_READONLY (object
)
3823 && TREE_CODE (object
) == VAR_DECL
3824 && (flag_merge_constants
>= 2 || !TREE_ADDRESSABLE (object
)))
3826 if (notify_temp_creation
)
3828 DECL_INITIAL (object
) = ctor
;
3829 TREE_STATIC (object
) = 1;
3830 if (!DECL_NAME (object
))
3831 DECL_NAME (object
) = create_tmp_var_name ("C");
3832 walk_tree (&DECL_INITIAL (object
), force_labels_r
, NULL
, NULL
);
3834 /* ??? C++ doesn't automatically append a .<number> to the
3835 assembler name, and even when it does, it looks at FE private
3836 data structures to figure out what that number should be,
3837 which are not set for this variable. I suppose this is
3838 important for local statics for inline functions, which aren't
3839 "local" in the object file sense. So in order to get a unique
3840 TU-local symbol, we must invoke the lhd version now. */
3841 lhd_set_decl_assembler_name (object
);
3843 *expr_p
= NULL_TREE
;
3847 /* If there are "lots" of initialized elements, even discounting
3848 those that are not address constants (and thus *must* be
3849 computed at runtime), then partition the constructor into
3850 constant and non-constant parts. Block copy the constant
3851 parts in, then generate code for the non-constant parts. */
3852 /* TODO. There's code in cp/typeck.c to do this. */
3854 if (int_size_in_bytes (TREE_TYPE (ctor
)) < 0)
3855 /* store_constructor will ignore the clearing of variable-sized
3856 objects. Initializers for such objects must explicitly set
3857 every field that needs to be set. */
3859 else if (!complete_p
&& !CONSTRUCTOR_NO_CLEARING (ctor
))
3860 /* If the constructor isn't complete, clear the whole object
3861 beforehand, unless CONSTRUCTOR_NO_CLEARING is set on it.
3863 ??? This ought not to be needed. For any element not present
3864 in the initializer, we should simply set them to zero. Except
3865 we'd need to *find* the elements that are not present, and that
3866 requires trickery to avoid quadratic compile-time behavior in
3867 large cases or excessive memory use in small cases. */
3869 else if (num_ctor_elements
- num_nonzero_elements
3870 > CLEAR_RATIO (optimize_function_for_speed_p (cfun
))
3871 && num_nonzero_elements
< num_ctor_elements
/ 4)
3872 /* If there are "lots" of zeros, it's more efficient to clear
3873 the memory and then set the nonzero elements. */
3878 /* If there are "lots" of initialized elements, and all of them
3879 are valid address constants, then the entire initializer can
3880 be dropped to memory, and then memcpy'd out. Don't do this
3881 for sparse arrays, though, as it's more efficient to follow
3882 the standard CONSTRUCTOR behavior of memset followed by
3883 individual element initialization. Also don't do this for small
3884 all-zero initializers (which aren't big enough to merit
3885 clearing), and don't try to make bitwise copies of
3886 TREE_ADDRESSABLE types.
3888 We cannot apply such transformation when compiling chkp static
3889 initializer because creation of initializer image in the memory
3890 will require static initialization of bounds for it. It should
3891 result in another gimplification of similar initializer and we
3892 may fall into infinite loop. */
3893 if (valid_const_initializer
3894 && !(cleared
|| num_nonzero_elements
== 0)
3895 && !TREE_ADDRESSABLE (type
)
3896 && (!current_function_decl
3897 || !lookup_attribute ("chkp ctor",
3898 DECL_ATTRIBUTES (current_function_decl
))))
3900 HOST_WIDE_INT size
= int_size_in_bytes (type
);
3903 /* ??? We can still get unbounded array types, at least
3904 from the C++ front end. This seems wrong, but attempt
3905 to work around it for now. */
3908 size
= int_size_in_bytes (TREE_TYPE (object
));
3910 TREE_TYPE (ctor
) = type
= TREE_TYPE (object
);
3913 /* Find the maximum alignment we can assume for the object. */
3914 /* ??? Make use of DECL_OFFSET_ALIGN. */
3915 if (DECL_P (object
))
3916 align
= DECL_ALIGN (object
);
3918 align
= TYPE_ALIGN (type
);
3920 /* Do a block move either if the size is so small as to make
3921 each individual move a sub-unit move on average, or if it
3922 is so large as to make individual moves inefficient. */
3924 && num_nonzero_elements
> 1
3925 && (size
< num_nonzero_elements
3926 || !can_move_by_pieces (size
, align
)))
3928 if (notify_temp_creation
)
3931 walk_tree (&ctor
, force_labels_r
, NULL
, NULL
);
3932 ctor
= tree_output_constant_def (ctor
);
3933 if (!useless_type_conversion_p (type
, TREE_TYPE (ctor
)))
3934 ctor
= build1 (VIEW_CONVERT_EXPR
, type
, ctor
);
3935 TREE_OPERAND (*expr_p
, 1) = ctor
;
3937 /* This is no longer an assignment of a CONSTRUCTOR, but
3938 we still may have processing to do on the LHS. So
3939 pretend we didn't do anything here to let that happen. */
3940 return GS_UNHANDLED
;
3944 /* If the target is volatile, we have non-zero elements and more than
3945 one field to assign, initialize the target from a temporary. */
3946 if (TREE_THIS_VOLATILE (object
)
3947 && !TREE_ADDRESSABLE (type
)
3948 && num_nonzero_elements
> 0
3949 && vec_safe_length (elts
) > 1)
3951 tree temp
= create_tmp_var (TYPE_MAIN_VARIANT (type
));
3952 TREE_OPERAND (*expr_p
, 0) = temp
;
3953 *expr_p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*expr_p
),
3955 build2 (MODIFY_EXPR
, void_type_node
,
3960 if (notify_temp_creation
)
3963 /* If there are nonzero elements and if needed, pre-evaluate to capture
3964 elements overlapping with the lhs into temporaries. We must do this
3965 before clearing to fetch the values before they are zeroed-out. */
3966 if (num_nonzero_elements
> 0 && TREE_CODE (*expr_p
) != INIT_EXPR
)
3968 preeval_data
.lhs_base_decl
= get_base_address (object
);
3969 if (!DECL_P (preeval_data
.lhs_base_decl
))
3970 preeval_data
.lhs_base_decl
= NULL
;
3971 preeval_data
.lhs_alias_set
= get_alias_set (object
);
3973 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p
, 1),
3974 pre_p
, post_p
, &preeval_data
);
3977 bool ctor_has_side_effects_p
3978 = TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p
, 1));
3982 /* Zap the CONSTRUCTOR element list, which simplifies this case.
3983 Note that we still have to gimplify, in order to handle the
3984 case of variable sized types. Avoid shared tree structures. */
3985 CONSTRUCTOR_ELTS (ctor
) = NULL
;
3986 TREE_SIDE_EFFECTS (ctor
) = 0;
3987 object
= unshare_expr (object
);
3988 gimplify_stmt (expr_p
, pre_p
);
3991 /* If we have not block cleared the object, or if there are nonzero
3992 elements in the constructor, or if the constructor has side effects,
3993 add assignments to the individual scalar fields of the object. */
3995 || num_nonzero_elements
> 0
3996 || ctor_has_side_effects_p
)
3997 gimplify_init_ctor_eval (object
, elts
, pre_p
, cleared
);
3999 *expr_p
= NULL_TREE
;
4007 if (notify_temp_creation
)
4010 /* Extract the real and imaginary parts out of the ctor. */
4011 gcc_assert (elts
->length () == 2);
4012 r
= (*elts
)[0].value
;
4013 i
= (*elts
)[1].value
;
4014 if (r
== NULL
|| i
== NULL
)
4016 tree zero
= build_zero_cst (TREE_TYPE (type
));
4023 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
4024 represent creation of a complex value. */
4025 if (TREE_CONSTANT (r
) && TREE_CONSTANT (i
))
4027 ctor
= build_complex (type
, r
, i
);
4028 TREE_OPERAND (*expr_p
, 1) = ctor
;
4032 ctor
= build2 (COMPLEX_EXPR
, type
, r
, i
);
4033 TREE_OPERAND (*expr_p
, 1) = ctor
;
4034 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1),
4037 rhs_predicate_for (TREE_OPERAND (*expr_p
, 0)),
4045 unsigned HOST_WIDE_INT ix
;
4046 constructor_elt
*ce
;
4048 if (notify_temp_creation
)
4051 /* Go ahead and simplify constant constructors to VECTOR_CST. */
4052 if (TREE_CONSTANT (ctor
))
4054 bool constant_p
= true;
4057 /* Even when ctor is constant, it might contain non-*_CST
4058 elements, such as addresses or trapping values like
4059 1.0/0.0 - 1.0/0.0. Such expressions don't belong
4060 in VECTOR_CST nodes. */
4061 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
4062 if (!CONSTANT_CLASS_P (value
))
4070 TREE_OPERAND (*expr_p
, 1) = build_vector_from_ctor (type
, elts
);
4074 TREE_CONSTANT (ctor
) = 0;
4077 /* Vector types use CONSTRUCTOR all the way through gimple
4078 compilation as a general initializer. */
4079 FOR_EACH_VEC_SAFE_ELT (elts
, ix
, ce
)
4081 enum gimplify_status tret
;
4082 tret
= gimplify_expr (&ce
->value
, pre_p
, post_p
, is_gimple_val
,
4084 if (tret
== GS_ERROR
)
4087 if (!is_gimple_reg (TREE_OPERAND (*expr_p
, 0)))
4088 TREE_OPERAND (*expr_p
, 1) = get_formal_tmp_var (ctor
, pre_p
);
4093 /* So how did we get a CONSTRUCTOR for a scalar type? */
4097 if (ret
== GS_ERROR
)
4099 else if (want_value
)
4106 /* If we have gimplified both sides of the initializer but have
4107 not emitted an assignment, do so now. */
4110 tree lhs
= TREE_OPERAND (*expr_p
, 0);
4111 tree rhs
= TREE_OPERAND (*expr_p
, 1);
4112 gassign
*init
= gimple_build_assign (lhs
, rhs
);
4113 gimplify_seq_add_stmt (pre_p
, init
);
4121 /* Given a pointer value OP0, return a simplified version of an
4122 indirection through OP0, or NULL_TREE if no simplification is
4123 possible. This may only be applied to a rhs of an expression.
4124 Note that the resulting type may be different from the type pointed
4125 to in the sense that it is still compatible from the langhooks
4129 gimple_fold_indirect_ref_rhs (tree t
)
4131 return gimple_fold_indirect_ref (t
);
4134 /* Subroutine of gimplify_modify_expr to do simplifications of
4135 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4136 something changes. */
4138 static enum gimplify_status
4139 gimplify_modify_expr_rhs (tree
*expr_p
, tree
*from_p
, tree
*to_p
,
4140 gimple_seq
*pre_p
, gimple_seq
*post_p
,
4143 enum gimplify_status ret
= GS_UNHANDLED
;
4149 switch (TREE_CODE (*from_p
))
4152 /* If we're assigning from a read-only variable initialized with
4153 a constructor, do the direct assignment from the constructor,
4154 but only if neither source nor target are volatile since this
4155 latter assignment might end up being done on a per-field basis. */
4156 if (DECL_INITIAL (*from_p
)
4157 && TREE_READONLY (*from_p
)
4158 && !TREE_THIS_VOLATILE (*from_p
)
4159 && !TREE_THIS_VOLATILE (*to_p
)
4160 && TREE_CODE (DECL_INITIAL (*from_p
)) == CONSTRUCTOR
)
4162 tree old_from
= *from_p
;
4163 enum gimplify_status subret
;
4165 /* Move the constructor into the RHS. */
4166 *from_p
= unshare_expr (DECL_INITIAL (*from_p
));
4168 /* Let's see if gimplify_init_constructor will need to put
4170 subret
= gimplify_init_constructor (expr_p
, NULL
, NULL
,
4172 if (subret
== GS_ERROR
)
4174 /* If so, revert the change. */
4186 /* If we have code like
4190 where the type of "x" is a (possibly cv-qualified variant
4191 of "A"), treat the entire expression as identical to "x".
4192 This kind of code arises in C++ when an object is bound
4193 to a const reference, and if "x" is a TARGET_EXPR we want
4194 to take advantage of the optimization below. */
4195 bool volatile_p
= TREE_THIS_VOLATILE (*from_p
);
4196 tree t
= gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p
, 0));
4199 if (TREE_THIS_VOLATILE (t
) != volatile_p
)
4202 t
= build_simple_mem_ref_loc (EXPR_LOCATION (*from_p
),
4203 build_fold_addr_expr (t
));
4204 if (REFERENCE_CLASS_P (t
))
4205 TREE_THIS_VOLATILE (t
) = volatile_p
;
4216 /* If we are initializing something from a TARGET_EXPR, strip the
4217 TARGET_EXPR and initialize it directly, if possible. This can't
4218 be done if the initializer is void, since that implies that the
4219 temporary is set in some non-trivial way.
4221 ??? What about code that pulls out the temp and uses it
4222 elsewhere? I think that such code never uses the TARGET_EXPR as
4223 an initializer. If I'm wrong, we'll die because the temp won't
4224 have any RTL. In that case, I guess we'll need to replace
4225 references somehow. */
4226 tree init
= TARGET_EXPR_INITIAL (*from_p
);
4229 && !VOID_TYPE_P (TREE_TYPE (init
)))
4239 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4241 gimplify_compound_expr (from_p
, pre_p
, true);
4247 /* If we already made some changes, let the front end have a
4248 crack at this before we break it down. */
4249 if (ret
!= GS_UNHANDLED
)
4251 /* If we're initializing from a CONSTRUCTOR, break this into
4252 individual MODIFY_EXPRs. */
4253 return gimplify_init_constructor (expr_p
, pre_p
, post_p
, want_value
,
4257 /* If we're assigning to a non-register type, push the assignment
4258 down into the branches. This is mandatory for ADDRESSABLE types,
4259 since we cannot generate temporaries for such, but it saves a
4260 copy in other cases as well. */
4261 if (!is_gimple_reg_type (TREE_TYPE (*from_p
)))
4263 /* This code should mirror the code in gimplify_cond_expr. */
4264 enum tree_code code
= TREE_CODE (*expr_p
);
4265 tree cond
= *from_p
;
4266 tree result
= *to_p
;
4268 ret
= gimplify_expr (&result
, pre_p
, post_p
,
4269 is_gimple_lvalue
, fb_lvalue
);
4270 if (ret
!= GS_ERROR
)
4273 if (TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
)
4274 TREE_OPERAND (cond
, 1)
4275 = build2 (code
, void_type_node
, result
,
4276 TREE_OPERAND (cond
, 1));
4277 if (TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
4278 TREE_OPERAND (cond
, 2)
4279 = build2 (code
, void_type_node
, unshare_expr (result
),
4280 TREE_OPERAND (cond
, 2));
4282 TREE_TYPE (cond
) = void_type_node
;
4283 recalculate_side_effects (cond
);
4287 gimplify_and_add (cond
, pre_p
);
4288 *expr_p
= unshare_expr (result
);
4297 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4298 return slot so that we don't generate a temporary. */
4299 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p
)
4300 && aggregate_value_p (*from_p
, *from_p
))
4304 if (!(rhs_predicate_for (*to_p
))(*from_p
))
4305 /* If we need a temporary, *to_p isn't accurate. */
4307 /* It's OK to use the return slot directly unless it's an NRV. */
4308 else if (TREE_CODE (*to_p
) == RESULT_DECL
4309 && DECL_NAME (*to_p
) == NULL_TREE
4310 && needs_to_live_in_memory (*to_p
))
4312 else if (is_gimple_reg_type (TREE_TYPE (*to_p
))
4313 || (DECL_P (*to_p
) && DECL_REGISTER (*to_p
)))
4314 /* Don't force regs into memory. */
4316 else if (TREE_CODE (*expr_p
) == INIT_EXPR
)
4317 /* It's OK to use the target directly if it's being
4320 else if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (*to_p
)))
4322 /* Always use the target and thus RSO for variable-sized types.
4323 GIMPLE cannot deal with a variable-sized assignment
4324 embedded in a call statement. */
4326 else if (TREE_CODE (*to_p
) != SSA_NAME
4327 && (!is_gimple_variable (*to_p
)
4328 || needs_to_live_in_memory (*to_p
)))
4329 /* Don't use the original target if it's already addressable;
4330 if its address escapes, and the called function uses the
4331 NRV optimization, a conforming program could see *to_p
4332 change before the called function returns; see c++/19317.
4333 When optimizing, the return_slot pass marks more functions
4334 as safe after we have escape info. */
4341 CALL_EXPR_RETURN_SLOT_OPT (*from_p
) = 1;
4342 mark_addressable (*to_p
);
4347 case WITH_SIZE_EXPR
:
4348 /* Likewise for calls that return an aggregate of non-constant size,
4349 since we would not be able to generate a temporary at all. */
4350 if (TREE_CODE (TREE_OPERAND (*from_p
, 0)) == CALL_EXPR
)
4352 *from_p
= TREE_OPERAND (*from_p
, 0);
4353 /* We don't change ret in this case because the
4354 WITH_SIZE_EXPR might have been added in
4355 gimplify_modify_expr, so returning GS_OK would lead to an
4361 /* If we're initializing from a container, push the initialization
4363 case CLEANUP_POINT_EXPR
:
4365 case STATEMENT_LIST
:
4367 tree wrap
= *from_p
;
4370 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_min_lval
,
4372 if (ret
!= GS_ERROR
)
4375 t
= voidify_wrapper_expr (wrap
, *expr_p
);
4376 gcc_assert (t
== *expr_p
);
4380 gimplify_and_add (wrap
, pre_p
);
4381 *expr_p
= unshare_expr (*to_p
);
4388 case COMPOUND_LITERAL_EXPR
:
4390 tree complit
= TREE_OPERAND (*expr_p
, 1);
4391 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (complit
);
4392 tree decl
= DECL_EXPR_DECL (decl_s
);
4393 tree init
= DECL_INITIAL (decl
);
4395 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4396 into struct T x = { 0, 1, 2 } if the address of the
4397 compound literal has never been taken. */
4398 if (!TREE_ADDRESSABLE (complit
)
4399 && !TREE_ADDRESSABLE (decl
)
4402 *expr_p
= copy_node (*expr_p
);
4403 TREE_OPERAND (*expr_p
, 1) = init
;
4418 /* Return true if T looks like a valid GIMPLE statement. */
4421 is_gimple_stmt (tree t
)
4423 const enum tree_code code
= TREE_CODE (t
);
4428 /* The only valid NOP_EXPR is the empty statement. */
4429 return IS_EMPTY_STMT (t
);
4433 /* These are only valid if they're void. */
4434 return TREE_TYPE (t
) == NULL
|| VOID_TYPE_P (TREE_TYPE (t
));
4440 case CASE_LABEL_EXPR
:
4441 case TRY_CATCH_EXPR
:
4442 case TRY_FINALLY_EXPR
:
4443 case EH_FILTER_EXPR
:
4446 case STATEMENT_LIST
:
4450 case OACC_HOST_DATA
:
4453 case OACC_ENTER_DATA
:
4454 case OACC_EXIT_DATA
:
4460 case OMP_DISTRIBUTE
:
4470 /* These are always void. */
4476 /* These are valid regardless of their type. */
4485 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4486 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4487 DECL_GIMPLE_REG_P set.
4489 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4490 other, unmodified part of the complex object just before the total store.
4491 As a consequence, if the object is still uninitialized, an undefined value
4492 will be loaded into a register, which may result in a spurious exception
4493 if the register is floating-point and the value happens to be a signaling
4494 NaN for example. Then the fully-fledged complex operations lowering pass
4495 followed by a DCE pass are necessary in order to fix things up. */
4497 static enum gimplify_status
4498 gimplify_modify_expr_complex_part (tree
*expr_p
, gimple_seq
*pre_p
,
4501 enum tree_code code
, ocode
;
4502 tree lhs
, rhs
, new_rhs
, other
, realpart
, imagpart
;
4504 lhs
= TREE_OPERAND (*expr_p
, 0);
4505 rhs
= TREE_OPERAND (*expr_p
, 1);
4506 code
= TREE_CODE (lhs
);
4507 lhs
= TREE_OPERAND (lhs
, 0);
4509 ocode
= code
== REALPART_EXPR
? IMAGPART_EXPR
: REALPART_EXPR
;
4510 other
= build1 (ocode
, TREE_TYPE (rhs
), lhs
);
4511 TREE_NO_WARNING (other
) = 1;
4512 other
= get_formal_tmp_var (other
, pre_p
);
4514 realpart
= code
== REALPART_EXPR
? rhs
: other
;
4515 imagpart
= code
== REALPART_EXPR
? other
: rhs
;
4517 if (TREE_CONSTANT (realpart
) && TREE_CONSTANT (imagpart
))
4518 new_rhs
= build_complex (TREE_TYPE (lhs
), realpart
, imagpart
);
4520 new_rhs
= build2 (COMPLEX_EXPR
, TREE_TYPE (lhs
), realpart
, imagpart
);
4522 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (lhs
, new_rhs
));
4523 *expr_p
= (want_value
) ? rhs
: NULL_TREE
;
4528 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4534 PRE_P points to the list where side effects that must happen before
4535 *EXPR_P should be stored.
4537 POST_P points to the list where side effects that must happen after
4538 *EXPR_P should be stored.
4540 WANT_VALUE is nonzero iff we want to use the value of this expression
4541 in another expression. */
4543 static enum gimplify_status
4544 gimplify_modify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4547 tree
*from_p
= &TREE_OPERAND (*expr_p
, 1);
4548 tree
*to_p
= &TREE_OPERAND (*expr_p
, 0);
4549 enum gimplify_status ret
= GS_UNHANDLED
;
4551 location_t loc
= EXPR_LOCATION (*expr_p
);
4552 gimple_stmt_iterator gsi
;
4554 gcc_assert (TREE_CODE (*expr_p
) == MODIFY_EXPR
4555 || TREE_CODE (*expr_p
) == INIT_EXPR
);
4557 /* Trying to simplify a clobber using normal logic doesn't work,
4558 so handle it here. */
4559 if (TREE_CLOBBER_P (*from_p
))
4561 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4562 if (ret
== GS_ERROR
)
4564 gcc_assert (!want_value
4565 && (TREE_CODE (*to_p
) == VAR_DECL
4566 || TREE_CODE (*to_p
) == MEM_REF
));
4567 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (*to_p
, *from_p
));
4572 /* Insert pointer conversions required by the middle-end that are not
4573 required by the frontend. This fixes middle-end type checking for
4574 for example gcc.dg/redecl-6.c. */
4575 if (POINTER_TYPE_P (TREE_TYPE (*to_p
)))
4577 STRIP_USELESS_TYPE_CONVERSION (*from_p
);
4578 if (!useless_type_conversion_p (TREE_TYPE (*to_p
), TREE_TYPE (*from_p
)))
4579 *from_p
= fold_convert_loc (loc
, TREE_TYPE (*to_p
), *from_p
);
4582 /* See if any simplifications can be done based on what the RHS is. */
4583 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4585 if (ret
!= GS_UNHANDLED
)
4588 /* For zero sized types only gimplify the left hand side and right hand
4589 side as statements and throw away the assignment. Do this after
4590 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4592 if (zero_sized_type (TREE_TYPE (*from_p
)) && !want_value
)
4594 gimplify_stmt (from_p
, pre_p
);
4595 gimplify_stmt (to_p
, pre_p
);
4596 *expr_p
= NULL_TREE
;
4600 /* If the value being copied is of variable width, compute the length
4601 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4602 before gimplifying any of the operands so that we can resolve any
4603 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4604 the size of the expression to be copied, not of the destination, so
4605 that is what we must do here. */
4606 maybe_with_size_expr (from_p
);
4608 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4609 if (ret
== GS_ERROR
)
4612 /* As a special case, we have to temporarily allow for assignments
4613 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4614 a toplevel statement, when gimplifying the GENERIC expression
4615 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4616 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4618 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4619 prevent gimplify_expr from trying to create a new temporary for
4620 foo's LHS, we tell it that it should only gimplify until it
4621 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4622 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4623 and all we need to do here is set 'a' to be its LHS. */
4624 ret
= gimplify_expr (from_p
, pre_p
, post_p
, rhs_predicate_for (*to_p
),
4626 if (ret
== GS_ERROR
)
4629 /* In case of va_arg internal fn wrappped in a WITH_SIZE_EXPR, add the type
4630 size as argument to the call. */
4631 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
4633 tree call
= TREE_OPERAND (*from_p
, 0);
4634 tree vlasize
= TREE_OPERAND (*from_p
, 1);
4636 if (TREE_CODE (call
) == CALL_EXPR
4637 && CALL_EXPR_IFN (call
) == IFN_VA_ARG
)
4639 int nargs
= call_expr_nargs (call
);
4640 tree type
= TREE_TYPE (call
);
4641 tree ap
= CALL_EXPR_ARG (call
, 0);
4642 tree tag
= CALL_EXPR_ARG (call
, 1);
4643 tree newcall
= build_call_expr_internal_loc (EXPR_LOCATION (call
),
4647 tree
*call_p
= &(TREE_OPERAND (*from_p
, 0));
4652 /* Now see if the above changed *from_p to something we handle specially. */
4653 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4655 if (ret
!= GS_UNHANDLED
)
4658 /* If we've got a variable sized assignment between two lvalues (i.e. does
4659 not involve a call), then we can make things a bit more straightforward
4660 by converting the assignment to memcpy or memset. */
4661 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
4663 tree from
= TREE_OPERAND (*from_p
, 0);
4664 tree size
= TREE_OPERAND (*from_p
, 1);
4666 if (TREE_CODE (from
) == CONSTRUCTOR
)
4667 return gimplify_modify_expr_to_memset (expr_p
, size
, want_value
, pre_p
);
4669 if (is_gimple_addressable (from
))
4672 return gimplify_modify_expr_to_memcpy (expr_p
, size
, want_value
,
4677 /* Transform partial stores to non-addressable complex variables into
4678 total stores. This allows us to use real instead of virtual operands
4679 for these variables, which improves optimization. */
4680 if ((TREE_CODE (*to_p
) == REALPART_EXPR
4681 || TREE_CODE (*to_p
) == IMAGPART_EXPR
)
4682 && is_gimple_reg (TREE_OPERAND (*to_p
, 0)))
4683 return gimplify_modify_expr_complex_part (expr_p
, pre_p
, want_value
);
4685 /* Try to alleviate the effects of the gimplification creating artificial
4686 temporaries (see for example is_gimple_reg_rhs) on the debug info, but
4687 make sure not to create DECL_DEBUG_EXPR links across functions. */
4688 if (!gimplify_ctxp
->into_ssa
4689 && TREE_CODE (*from_p
) == VAR_DECL
4690 && DECL_IGNORED_P (*from_p
)
4692 && !DECL_IGNORED_P (*to_p
)
4693 && decl_function_context (*to_p
) == current_function_decl
)
4695 if (!DECL_NAME (*from_p
) && DECL_NAME (*to_p
))
4697 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p
)));
4698 DECL_HAS_DEBUG_EXPR_P (*from_p
) = 1;
4699 SET_DECL_DEBUG_EXPR (*from_p
, *to_p
);
4702 if (want_value
&& TREE_THIS_VOLATILE (*to_p
))
4703 *from_p
= get_initialized_tmp_var (*from_p
, pre_p
, post_p
);
4705 if (TREE_CODE (*from_p
) == CALL_EXPR
)
4707 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4708 instead of a GIMPLE_ASSIGN. */
4710 if (CALL_EXPR_FN (*from_p
) == NULL_TREE
)
4712 /* Gimplify internal functions created in the FEs. */
4713 int nargs
= call_expr_nargs (*from_p
), i
;
4714 enum internal_fn ifn
= CALL_EXPR_IFN (*from_p
);
4715 auto_vec
<tree
> vargs (nargs
);
4717 for (i
= 0; i
< nargs
; i
++)
4719 gimplify_arg (&CALL_EXPR_ARG (*from_p
, i
), pre_p
,
4720 EXPR_LOCATION (*from_p
));
4721 vargs
.quick_push (CALL_EXPR_ARG (*from_p
, i
));
4723 call_stmt
= gimple_build_call_internal_vec (ifn
, vargs
);
4724 gimple_set_location (call_stmt
, EXPR_LOCATION (*expr_p
));
4728 tree fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*from_p
));
4729 CALL_EXPR_FN (*from_p
) = TREE_OPERAND (CALL_EXPR_FN (*from_p
), 0);
4730 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p
));
4731 tree fndecl
= get_callee_fndecl (*from_p
);
4733 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
4734 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_EXPECT
4735 && call_expr_nargs (*from_p
) == 3)
4736 call_stmt
= gimple_build_call_internal (IFN_BUILTIN_EXPECT
, 3,
4737 CALL_EXPR_ARG (*from_p
, 0),
4738 CALL_EXPR_ARG (*from_p
, 1),
4739 CALL_EXPR_ARG (*from_p
, 2));
4742 call_stmt
= gimple_build_call_from_tree (*from_p
);
4743 gimple_call_set_fntype (call_stmt
, TREE_TYPE (fnptrtype
));
4746 notice_special_calls (call_stmt
);
4747 if (!gimple_call_noreturn_p (call_stmt
))
4748 gimple_call_set_lhs (call_stmt
, *to_p
);
4753 assign
= gimple_build_assign (*to_p
, *from_p
);
4754 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
4757 if (gimplify_ctxp
->into_ssa
&& is_gimple_reg (*to_p
))
4759 /* We should have got an SSA name from the start. */
4760 gcc_assert (TREE_CODE (*to_p
) == SSA_NAME
);
4763 gimplify_seq_add_stmt (pre_p
, assign
);
4764 gsi
= gsi_last (*pre_p
);
4765 maybe_fold_stmt (&gsi
);
4769 *expr_p
= TREE_THIS_VOLATILE (*to_p
) ? *from_p
: unshare_expr (*to_p
);
4778 /* Gimplify a comparison between two variable-sized objects. Do this
4779 with a call to BUILT_IN_MEMCMP. */
4781 static enum gimplify_status
4782 gimplify_variable_sized_compare (tree
*expr_p
)
4784 location_t loc
= EXPR_LOCATION (*expr_p
);
4785 tree op0
= TREE_OPERAND (*expr_p
, 0);
4786 tree op1
= TREE_OPERAND (*expr_p
, 1);
4787 tree t
, arg
, dest
, src
, expr
;
4789 arg
= TYPE_SIZE_UNIT (TREE_TYPE (op0
));
4790 arg
= unshare_expr (arg
);
4791 arg
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg
, op0
);
4792 src
= build_fold_addr_expr_loc (loc
, op1
);
4793 dest
= build_fold_addr_expr_loc (loc
, op0
);
4794 t
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
4795 t
= build_call_expr_loc (loc
, t
, 3, dest
, src
, arg
);
4798 = build2 (TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), t
, integer_zero_node
);
4799 SET_EXPR_LOCATION (expr
, loc
);
4805 /* Gimplify a comparison between two aggregate objects of integral scalar
4806 mode as a comparison between the bitwise equivalent scalar values. */
4808 static enum gimplify_status
4809 gimplify_scalar_mode_aggregate_compare (tree
*expr_p
)
4811 location_t loc
= EXPR_LOCATION (*expr_p
);
4812 tree op0
= TREE_OPERAND (*expr_p
, 0);
4813 tree op1
= TREE_OPERAND (*expr_p
, 1);
4815 tree type
= TREE_TYPE (op0
);
4816 tree scalar_type
= lang_hooks
.types
.type_for_mode (TYPE_MODE (type
), 1);
4818 op0
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op0
);
4819 op1
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op1
);
4822 = fold_build2_loc (loc
, TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), op0
, op1
);
4827 /* Gimplify an expression sequence. This function gimplifies each
4828 expression and rewrites the original expression with the last
4829 expression of the sequence in GIMPLE form.
4831 PRE_P points to the list where the side effects for all the
4832 expressions in the sequence will be emitted.
4834 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
4836 static enum gimplify_status
4837 gimplify_compound_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
4843 tree
*sub_p
= &TREE_OPERAND (t
, 0);
4845 if (TREE_CODE (*sub_p
) == COMPOUND_EXPR
)
4846 gimplify_compound_expr (sub_p
, pre_p
, false);
4848 gimplify_stmt (sub_p
, pre_p
);
4850 t
= TREE_OPERAND (t
, 1);
4852 while (TREE_CODE (t
) == COMPOUND_EXPR
);
4859 gimplify_stmt (expr_p
, pre_p
);
4864 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
4865 gimplify. After gimplification, EXPR_P will point to a new temporary
4866 that holds the original value of the SAVE_EXPR node.
4868 PRE_P points to the list where side effects that must happen before
4869 *EXPR_P should be stored. */
4871 static enum gimplify_status
4872 gimplify_save_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4874 enum gimplify_status ret
= GS_ALL_DONE
;
4877 gcc_assert (TREE_CODE (*expr_p
) == SAVE_EXPR
);
4878 val
= TREE_OPERAND (*expr_p
, 0);
4880 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
4881 if (!SAVE_EXPR_RESOLVED_P (*expr_p
))
4883 /* The operand may be a void-valued expression such as SAVE_EXPRs
4884 generated by the Java frontend for class initialization. It is
4885 being executed only for its side-effects. */
4886 if (TREE_TYPE (val
) == void_type_node
)
4888 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
4889 is_gimple_stmt
, fb_none
);
4893 val
= get_initialized_tmp_var (val
, pre_p
, post_p
);
4895 TREE_OPERAND (*expr_p
, 0) = val
;
4896 SAVE_EXPR_RESOLVED_P (*expr_p
) = 1;
4904 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
4911 PRE_P points to the list where side effects that must happen before
4912 *EXPR_P should be stored.
4914 POST_P points to the list where side effects that must happen after
4915 *EXPR_P should be stored. */
4917 static enum gimplify_status
4918 gimplify_addr_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4920 tree expr
= *expr_p
;
4921 tree op0
= TREE_OPERAND (expr
, 0);
4922 enum gimplify_status ret
;
4923 location_t loc
= EXPR_LOCATION (*expr_p
);
4925 switch (TREE_CODE (op0
))
4929 /* Check if we are dealing with an expression of the form '&*ptr'.
4930 While the front end folds away '&*ptr' into 'ptr', these
4931 expressions may be generated internally by the compiler (e.g.,
4932 builtins like __builtin_va_end). */
4933 /* Caution: the silent array decomposition semantics we allow for
4934 ADDR_EXPR means we can't always discard the pair. */
4935 /* Gimplification of the ADDR_EXPR operand may drop
4936 cv-qualification conversions, so make sure we add them if
4939 tree op00
= TREE_OPERAND (op0
, 0);
4940 tree t_expr
= TREE_TYPE (expr
);
4941 tree t_op00
= TREE_TYPE (op00
);
4943 if (!useless_type_conversion_p (t_expr
, t_op00
))
4944 op00
= fold_convert_loc (loc
, TREE_TYPE (expr
), op00
);
4950 case VIEW_CONVERT_EXPR
:
4951 /* Take the address of our operand and then convert it to the type of
4954 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
4955 all clear. The impact of this transformation is even less clear. */
4957 /* If the operand is a useless conversion, look through it. Doing so
4958 guarantees that the ADDR_EXPR and its operand will remain of the
4960 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0
, 0)))
4961 op0
= TREE_OPERAND (op0
, 0);
4963 *expr_p
= fold_convert_loc (loc
, TREE_TYPE (expr
),
4964 build_fold_addr_expr_loc (loc
,
4965 TREE_OPERAND (op0
, 0)));
4970 /* If we see a call to a declared builtin or see its address
4971 being taken (we can unify those cases here) then we can mark
4972 the builtin for implicit generation by GCC. */
4973 if (TREE_CODE (op0
) == FUNCTION_DECL
4974 && DECL_BUILT_IN_CLASS (op0
) == BUILT_IN_NORMAL
4975 && builtin_decl_declared_p (DECL_FUNCTION_CODE (op0
)))
4976 set_builtin_decl_implicit_p (DECL_FUNCTION_CODE (op0
), true);
4978 /* We use fb_either here because the C frontend sometimes takes
4979 the address of a call that returns a struct; see
4980 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
4981 the implied temporary explicit. */
4983 /* Make the operand addressable. */
4984 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, post_p
,
4985 is_gimple_addressable
, fb_either
);
4986 if (ret
== GS_ERROR
)
4989 /* Then mark it. Beware that it may not be possible to do so directly
4990 if a temporary has been created by the gimplification. */
4991 prepare_gimple_addressable (&TREE_OPERAND (expr
, 0), pre_p
);
4993 op0
= TREE_OPERAND (expr
, 0);
4995 /* For various reasons, the gimplification of the expression
4996 may have made a new INDIRECT_REF. */
4997 if (TREE_CODE (op0
) == INDIRECT_REF
)
4998 goto do_indirect_ref
;
5000 mark_addressable (TREE_OPERAND (expr
, 0));
5002 /* The FEs may end up building ADDR_EXPRs early on a decl with
5003 an incomplete type. Re-build ADDR_EXPRs in canonical form
5005 if (!types_compatible_p (TREE_TYPE (op0
), TREE_TYPE (TREE_TYPE (expr
))))
5006 *expr_p
= build_fold_addr_expr (op0
);
5008 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
5009 recompute_tree_invariant_for_addr_expr (*expr_p
);
5011 /* If we re-built the ADDR_EXPR add a conversion to the original type
5013 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
5014 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
5022 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
5023 value; output operands should be a gimple lvalue. */
5025 static enum gimplify_status
5026 gimplify_asm_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5030 const char **oconstraints
;
5033 const char *constraint
;
5034 bool allows_mem
, allows_reg
, is_inout
;
5035 enum gimplify_status ret
, tret
;
5037 vec
<tree
, va_gc
> *inputs
;
5038 vec
<tree
, va_gc
> *outputs
;
5039 vec
<tree
, va_gc
> *clobbers
;
5040 vec
<tree
, va_gc
> *labels
;
5044 noutputs
= list_length (ASM_OUTPUTS (expr
));
5045 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
5053 link_next
= NULL_TREE
;
5054 for (i
= 0, link
= ASM_OUTPUTS (expr
); link
; ++i
, link
= link_next
)
5057 size_t constraint_len
;
5059 link_next
= TREE_CHAIN (link
);
5063 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5064 constraint_len
= strlen (constraint
);
5065 if (constraint_len
== 0)
5068 ok
= parse_output_constraint (&constraint
, i
, 0, 0,
5069 &allows_mem
, &allows_reg
, &is_inout
);
5076 if (!allows_reg
&& allows_mem
)
5077 mark_addressable (TREE_VALUE (link
));
5079 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5080 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
5081 fb_lvalue
| fb_mayfail
);
5082 if (tret
== GS_ERROR
)
5084 error ("invalid lvalue in asm output %d", i
);
5088 vec_safe_push (outputs
, link
);
5089 TREE_CHAIN (link
) = NULL_TREE
;
5093 /* An input/output operand. To give the optimizers more
5094 flexibility, split it into separate input and output
5099 /* Turn the in/out constraint into an output constraint. */
5100 char *p
= xstrdup (constraint
);
5102 TREE_VALUE (TREE_PURPOSE (link
)) = build_string (constraint_len
, p
);
5104 /* And add a matching input constraint. */
5107 sprintf (buf
, "%d", i
);
5109 /* If there are multiple alternatives in the constraint,
5110 handle each of them individually. Those that allow register
5111 will be replaced with operand number, the others will stay
5113 if (strchr (p
, ',') != NULL
)
5115 size_t len
= 0, buflen
= strlen (buf
);
5116 char *beg
, *end
, *str
, *dst
;
5120 end
= strchr (beg
, ',');
5122 end
= strchr (beg
, '\0');
5123 if ((size_t) (end
- beg
) < buflen
)
5126 len
+= end
- beg
+ 1;
5133 str
= (char *) alloca (len
);
5134 for (beg
= p
+ 1, dst
= str
;;)
5137 bool mem_p
, reg_p
, inout_p
;
5139 end
= strchr (beg
, ',');
5144 parse_output_constraint (&tem
, i
, 0, 0,
5145 &mem_p
, ®_p
, &inout_p
);
5150 memcpy (dst
, buf
, buflen
);
5159 memcpy (dst
, beg
, len
);
5168 input
= build_string (dst
- str
, str
);
5171 input
= build_string (strlen (buf
), buf
);
5174 input
= build_string (constraint_len
- 1, constraint
+ 1);
5178 input
= build_tree_list (build_tree_list (NULL_TREE
, input
),
5179 unshare_expr (TREE_VALUE (link
)));
5180 ASM_INPUTS (expr
) = chainon (ASM_INPUTS (expr
), input
);
5184 link_next
= NULL_TREE
;
5185 for (link
= ASM_INPUTS (expr
); link
; ++i
, link
= link_next
)
5187 link_next
= TREE_CHAIN (link
);
5188 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5189 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
5190 oconstraints
, &allows_mem
, &allows_reg
);
5192 /* If we can't make copies, we can only accept memory. */
5193 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link
))))
5199 error ("impossible constraint in %<asm%>");
5200 error ("non-memory input %d must stay in memory", i
);
5205 /* If the operand is a memory input, it should be an lvalue. */
5206 if (!allows_reg
&& allows_mem
)
5208 tree inputv
= TREE_VALUE (link
);
5209 STRIP_NOPS (inputv
);
5210 if (TREE_CODE (inputv
) == PREDECREMENT_EXPR
5211 || TREE_CODE (inputv
) == PREINCREMENT_EXPR
5212 || TREE_CODE (inputv
) == POSTDECREMENT_EXPR
5213 || TREE_CODE (inputv
) == POSTINCREMENT_EXPR
)
5214 TREE_VALUE (link
) = error_mark_node
;
5215 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5216 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
5217 mark_addressable (TREE_VALUE (link
));
5218 if (tret
== GS_ERROR
)
5220 if (EXPR_HAS_LOCATION (TREE_VALUE (link
)))
5221 input_location
= EXPR_LOCATION (TREE_VALUE (link
));
5222 error ("memory input %d is not directly addressable", i
);
5228 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5229 is_gimple_asm_val
, fb_rvalue
);
5230 if (tret
== GS_ERROR
)
5234 TREE_CHAIN (link
) = NULL_TREE
;
5235 vec_safe_push (inputs
, link
);
5238 link_next
= NULL_TREE
;
5239 for (link
= ASM_CLOBBERS (expr
); link
; ++i
, link
= link_next
)
5241 link_next
= TREE_CHAIN (link
);
5242 TREE_CHAIN (link
) = NULL_TREE
;
5243 vec_safe_push (clobbers
, link
);
5246 link_next
= NULL_TREE
;
5247 for (link
= ASM_LABELS (expr
); link
; ++i
, link
= link_next
)
5249 link_next
= TREE_CHAIN (link
);
5250 TREE_CHAIN (link
) = NULL_TREE
;
5251 vec_safe_push (labels
, link
);
5254 /* Do not add ASMs with errors to the gimple IL stream. */
5255 if (ret
!= GS_ERROR
)
5257 stmt
= gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr
)),
5258 inputs
, outputs
, clobbers
, labels
);
5260 gimple_asm_set_volatile (stmt
, ASM_VOLATILE_P (expr
) || noutputs
== 0);
5261 gimple_asm_set_input (stmt
, ASM_INPUT_P (expr
));
5263 gimplify_seq_add_stmt (pre_p
, stmt
);
5269 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
5270 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
5271 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
5272 return to this function.
5274 FIXME should we complexify the prequeue handling instead? Or use flags
5275 for all the cleanups and let the optimizer tighten them up? The current
5276 code seems pretty fragile; it will break on a cleanup within any
5277 non-conditional nesting. But any such nesting would be broken, anyway;
5278 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
5279 and continues out of it. We can do that at the RTL level, though, so
5280 having an optimizer to tighten up try/finally regions would be a Good
5283 static enum gimplify_status
5284 gimplify_cleanup_point_expr (tree
*expr_p
, gimple_seq
*pre_p
)
5286 gimple_stmt_iterator iter
;
5287 gimple_seq body_sequence
= NULL
;
5289 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
5291 /* We only care about the number of conditions between the innermost
5292 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5293 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5294 int old_conds
= gimplify_ctxp
->conditions
;
5295 gimple_seq old_cleanups
= gimplify_ctxp
->conditional_cleanups
;
5296 bool old_in_cleanup_point_expr
= gimplify_ctxp
->in_cleanup_point_expr
;
5297 gimplify_ctxp
->conditions
= 0;
5298 gimplify_ctxp
->conditional_cleanups
= NULL
;
5299 gimplify_ctxp
->in_cleanup_point_expr
= true;
5301 gimplify_stmt (&TREE_OPERAND (*expr_p
, 0), &body_sequence
);
5303 gimplify_ctxp
->conditions
= old_conds
;
5304 gimplify_ctxp
->conditional_cleanups
= old_cleanups
;
5305 gimplify_ctxp
->in_cleanup_point_expr
= old_in_cleanup_point_expr
;
5307 for (iter
= gsi_start (body_sequence
); !gsi_end_p (iter
); )
5309 gimple wce
= gsi_stmt (iter
);
5311 if (gimple_code (wce
) == GIMPLE_WITH_CLEANUP_EXPR
)
5313 if (gsi_one_before_end_p (iter
))
5315 /* Note that gsi_insert_seq_before and gsi_remove do not
5316 scan operands, unlike some other sequence mutators. */
5317 if (!gimple_wce_cleanup_eh_only (wce
))
5318 gsi_insert_seq_before_without_update (&iter
,
5319 gimple_wce_cleanup (wce
),
5321 gsi_remove (&iter
, true);
5328 enum gimple_try_flags kind
;
5330 if (gimple_wce_cleanup_eh_only (wce
))
5331 kind
= GIMPLE_TRY_CATCH
;
5333 kind
= GIMPLE_TRY_FINALLY
;
5334 seq
= gsi_split_seq_after (iter
);
5336 gtry
= gimple_build_try (seq
, gimple_wce_cleanup (wce
), kind
);
5337 /* Do not use gsi_replace here, as it may scan operands.
5338 We want to do a simple structural modification only. */
5339 gsi_set_stmt (&iter
, gtry
);
5340 iter
= gsi_start (gtry
->eval
);
5347 gimplify_seq_add_seq (pre_p
, body_sequence
);
5360 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5361 is the cleanup action required. EH_ONLY is true if the cleanup should
5362 only be executed if an exception is thrown, not on normal exit. */
5365 gimple_push_cleanup (tree var
, tree cleanup
, bool eh_only
, gimple_seq
*pre_p
)
5368 gimple_seq cleanup_stmts
= NULL
;
5370 /* Errors can result in improperly nested cleanups. Which results in
5371 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5375 if (gimple_conditional_context ())
5377 /* If we're in a conditional context, this is more complex. We only
5378 want to run the cleanup if we actually ran the initialization that
5379 necessitates it, but we want to run it after the end of the
5380 conditional context. So we wrap the try/finally around the
5381 condition and use a flag to determine whether or not to actually
5382 run the destructor. Thus
5386 becomes (approximately)
5390 if (test) { A::A(temp); flag = 1; val = f(temp); }
5393 if (flag) A::~A(temp);
5397 tree flag
= create_tmp_var (boolean_type_node
, "cleanup");
5398 gassign
*ffalse
= gimple_build_assign (flag
, boolean_false_node
);
5399 gassign
*ftrue
= gimple_build_assign (flag
, boolean_true_node
);
5401 cleanup
= build3 (COND_EXPR
, void_type_node
, flag
, cleanup
, NULL
);
5402 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5403 wce
= gimple_build_wce (cleanup_stmts
);
5405 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, ffalse
);
5406 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
5407 gimplify_seq_add_stmt (pre_p
, ftrue
);
5409 /* Because of this manipulation, and the EH edges that jump
5410 threading cannot redirect, the temporary (VAR) will appear
5411 to be used uninitialized. Don't warn. */
5412 TREE_NO_WARNING (var
) = 1;
5416 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5417 wce
= gimple_build_wce (cleanup_stmts
);
5418 gimple_wce_set_cleanup_eh_only (wce
, eh_only
);
5419 gimplify_seq_add_stmt (pre_p
, wce
);
5423 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5425 static enum gimplify_status
5426 gimplify_target_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5428 tree targ
= *expr_p
;
5429 tree temp
= TARGET_EXPR_SLOT (targ
);
5430 tree init
= TARGET_EXPR_INITIAL (targ
);
5431 enum gimplify_status ret
;
5435 tree cleanup
= NULL_TREE
;
5437 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5438 to the temps list. Handle also variable length TARGET_EXPRs. */
5439 if (TREE_CODE (DECL_SIZE (temp
)) != INTEGER_CST
)
5441 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp
)))
5442 gimplify_type_sizes (TREE_TYPE (temp
), pre_p
);
5443 gimplify_vla_decl (temp
, pre_p
);
5446 gimple_add_tmp_var (temp
);
5448 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5449 expression is supposed to initialize the slot. */
5450 if (VOID_TYPE_P (TREE_TYPE (init
)))
5451 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5454 tree init_expr
= build2 (INIT_EXPR
, void_type_node
, temp
, init
);
5456 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5458 ggc_free (init_expr
);
5460 if (ret
== GS_ERROR
)
5462 /* PR c++/28266 Make sure this is expanded only once. */
5463 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5467 gimplify_and_add (init
, pre_p
);
5469 /* If needed, push the cleanup for the temp. */
5470 if (TARGET_EXPR_CLEANUP (targ
))
5472 if (CLEANUP_EH_ONLY (targ
))
5473 gimple_push_cleanup (temp
, TARGET_EXPR_CLEANUP (targ
),
5474 CLEANUP_EH_ONLY (targ
), pre_p
);
5476 cleanup
= TARGET_EXPR_CLEANUP (targ
);
5479 /* Add a clobber for the temporary going out of scope, like
5480 gimplify_bind_expr. */
5481 if (gimplify_ctxp
->in_cleanup_point_expr
5482 && needs_to_live_in_memory (temp
)
5483 && flag_stack_reuse
== SR_ALL
)
5485 tree clobber
= build_constructor (TREE_TYPE (temp
),
5487 TREE_THIS_VOLATILE (clobber
) = true;
5488 clobber
= build2 (MODIFY_EXPR
, TREE_TYPE (temp
), temp
, clobber
);
5490 cleanup
= build2 (COMPOUND_EXPR
, void_type_node
, cleanup
,
5497 gimple_push_cleanup (temp
, cleanup
, false, pre_p
);
5499 /* Only expand this once. */
5500 TREE_OPERAND (targ
, 3) = init
;
5501 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5504 /* We should have expanded this before. */
5505 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp
));
5511 /* Gimplification of expression trees. */
5513 /* Gimplify an expression which appears at statement context. The
5514 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5515 NULL, a new sequence is allocated.
5517 Return true if we actually added a statement to the queue. */
5520 gimplify_stmt (tree
*stmt_p
, gimple_seq
*seq_p
)
5522 gimple_seq_node last
;
5524 last
= gimple_seq_last (*seq_p
);
5525 gimplify_expr (stmt_p
, seq_p
, NULL
, is_gimple_stmt
, fb_none
);
5526 return last
!= gimple_seq_last (*seq_p
);
5529 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5530 to CTX. If entries already exist, force them to be some flavor of private.
5531 If there is no enclosing parallel, do nothing. */
5534 omp_firstprivatize_variable (struct gimplify_omp_ctx
*ctx
, tree decl
)
5538 if (decl
== NULL
|| !DECL_P (decl
))
5543 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5546 if (n
->value
& GOVD_SHARED
)
5547 n
->value
= GOVD_FIRSTPRIVATE
| (n
->value
& GOVD_SEEN
);
5548 else if (n
->value
& GOVD_MAP
)
5549 n
->value
|= GOVD_MAP_TO_ONLY
;
5553 else if (ctx
->region_type
== ORT_TARGET
)
5554 omp_add_variable (ctx
, decl
, GOVD_MAP
| GOVD_MAP_TO_ONLY
);
5555 else if (ctx
->region_type
!= ORT_WORKSHARE
5556 && ctx
->region_type
!= ORT_SIMD
5557 && ctx
->region_type
!= ORT_TARGET_DATA
)
5558 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
5560 ctx
= ctx
->outer_context
;
5565 /* Similarly for each of the type sizes of TYPE. */
5568 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx
*ctx
, tree type
)
5570 if (type
== NULL
|| type
== error_mark_node
)
5572 type
= TYPE_MAIN_VARIANT (type
);
5574 if (ctx
->privatized_types
->add (type
))
5577 switch (TREE_CODE (type
))
5583 case FIXED_POINT_TYPE
:
5584 omp_firstprivatize_variable (ctx
, TYPE_MIN_VALUE (type
));
5585 omp_firstprivatize_variable (ctx
, TYPE_MAX_VALUE (type
));
5589 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5590 omp_firstprivatize_type_sizes (ctx
, TYPE_DOMAIN (type
));
5595 case QUAL_UNION_TYPE
:
5598 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
5599 if (TREE_CODE (field
) == FIELD_DECL
)
5601 omp_firstprivatize_variable (ctx
, DECL_FIELD_OFFSET (field
));
5602 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (field
));
5608 case REFERENCE_TYPE
:
5609 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5616 omp_firstprivatize_variable (ctx
, TYPE_SIZE (type
));
5617 omp_firstprivatize_variable (ctx
, TYPE_SIZE_UNIT (type
));
5618 lang_hooks
.types
.omp_firstprivatize_type_sizes (ctx
, type
);
5621 /* Add an entry for DECL in the OMP context CTX with FLAGS. */
5624 omp_add_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned int flags
)
5627 unsigned int nflags
;
5630 if (error_operand_p (decl
))
5633 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5634 there are constructors involved somewhere. */
5635 if (TREE_ADDRESSABLE (TREE_TYPE (decl
))
5636 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
5639 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5640 if (n
!= NULL
&& n
->value
!= GOVD_ALIGNED
)
5642 /* We shouldn't be re-adding the decl with the same data
5644 gcc_assert ((n
->value
& GOVD_DATA_SHARE_CLASS
& flags
) == 0);
5645 /* The only combination of data sharing classes we should see is
5646 FIRSTPRIVATE and LASTPRIVATE. */
5647 nflags
= n
->value
| flags
;
5648 gcc_assert ((nflags
& GOVD_DATA_SHARE_CLASS
)
5649 == (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
)
5650 || (flags
& GOVD_DATA_SHARE_CLASS
) == 0);
5655 /* When adding a variable-sized variable, we have to handle all sorts
5656 of additional bits of data: the pointer replacement variable, and
5657 the parameters of the type. */
5658 if (DECL_SIZE (decl
) && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5660 /* Add the pointer replacement variable as PRIVATE if the variable
5661 replacement is private, else FIRSTPRIVATE since we'll need the
5662 address of the original variable either for SHARED, or for the
5663 copy into or out of the context. */
5664 if (!(flags
& GOVD_LOCAL
))
5666 if (flags
& GOVD_MAP
)
5667 nflags
= GOVD_MAP
| GOVD_MAP_TO_ONLY
| GOVD_EXPLICIT
;
5668 else if (flags
& GOVD_PRIVATE
)
5669 nflags
= GOVD_PRIVATE
;
5671 nflags
= GOVD_FIRSTPRIVATE
;
5672 nflags
|= flags
& GOVD_SEEN
;
5673 t
= DECL_VALUE_EXPR (decl
);
5674 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5675 t
= TREE_OPERAND (t
, 0);
5676 gcc_assert (DECL_P (t
));
5677 omp_add_variable (ctx
, t
, nflags
);
5680 /* Add all of the variable and type parameters (which should have
5681 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5682 omp_firstprivatize_variable (ctx
, DECL_SIZE_UNIT (decl
));
5683 omp_firstprivatize_variable (ctx
, DECL_SIZE (decl
));
5684 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5686 /* The variable-sized variable itself is never SHARED, only some form
5687 of PRIVATE. The sharing would take place via the pointer variable
5688 which we remapped above. */
5689 if (flags
& GOVD_SHARED
)
5690 flags
= GOVD_PRIVATE
| GOVD_DEBUG_PRIVATE
5691 | (flags
& (GOVD_SEEN
| GOVD_EXPLICIT
));
5693 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5694 alloca statement we generate for the variable, so make sure it
5695 is available. This isn't automatically needed for the SHARED
5696 case, since we won't be allocating local storage then.
5697 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5698 in this case omp_notice_variable will be called later
5699 on when it is gimplified. */
5700 else if (! (flags
& (GOVD_LOCAL
| GOVD_MAP
))
5701 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl
))))
5702 omp_notice_variable (ctx
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)), true);
5704 else if ((flags
& (GOVD_MAP
| GOVD_LOCAL
)) == 0
5705 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
5707 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5709 /* Similar to the direct variable sized case above, we'll need the
5710 size of references being privatized. */
5711 if ((flags
& GOVD_SHARED
) == 0)
5713 t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
5714 if (TREE_CODE (t
) != INTEGER_CST
)
5715 omp_notice_variable (ctx
, t
, true);
5722 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, flags
);
5725 /* Notice a threadprivate variable DECL used in OMP context CTX.
5726 This just prints out diagnostics about threadprivate variable uses
5727 in untied tasks. If DECL2 is non-NULL, prevent this warning
5728 on that variable. */
5731 omp_notice_threadprivate_variable (struct gimplify_omp_ctx
*ctx
, tree decl
,
5735 struct gimplify_omp_ctx
*octx
;
5737 for (octx
= ctx
; octx
; octx
= octx
->outer_context
)
5738 if (octx
->region_type
== ORT_TARGET
)
5740 n
= splay_tree_lookup (octx
->variables
, (splay_tree_key
)decl
);
5743 error ("threadprivate variable %qE used in target region",
5745 error_at (octx
->location
, "enclosing target region");
5746 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl
, 0);
5749 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl2
, 0);
5752 if (ctx
->region_type
!= ORT_UNTIED_TASK
)
5754 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5757 error ("threadprivate variable %qE used in untied task",
5759 error_at (ctx
->location
, "enclosing task");
5760 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, 0);
5763 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl2
, 0);
5767 /* Determine outer default flags for DECL mentioned in an OMP region
5768 but not declared in an enclosing clause.
5770 ??? Some compiler-generated variables (like SAVE_EXPRs) could be
5771 remapped firstprivate instead of shared. To some extent this is
5772 addressed in omp_firstprivatize_type_sizes, but not
5776 omp_default_clause (struct gimplify_omp_ctx
*ctx
, tree decl
,
5777 bool in_code
, unsigned flags
)
5779 enum omp_clause_default_kind default_kind
= ctx
->default_kind
;
5780 enum omp_clause_default_kind kind
;
5782 kind
= lang_hooks
.decls
.omp_predetermined_sharing (decl
);
5783 if (kind
!= OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
5784 default_kind
= kind
;
5786 switch (default_kind
)
5788 case OMP_CLAUSE_DEFAULT_NONE
:
5792 if (ctx
->region_type
& ORT_PARALLEL
)
5794 else if (ctx
->region_type
& ORT_TASK
)
5796 else if (ctx
->region_type
& ORT_TEAMS
)
5801 error ("%qE not specified in enclosing %s",
5802 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)), rtype
);
5803 error_at (ctx
->location
, "enclosing %s", rtype
);
5806 case OMP_CLAUSE_DEFAULT_SHARED
:
5807 flags
|= GOVD_SHARED
;
5809 case OMP_CLAUSE_DEFAULT_PRIVATE
:
5810 flags
|= GOVD_PRIVATE
;
5812 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
5813 flags
|= GOVD_FIRSTPRIVATE
;
5815 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
5816 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
5817 gcc_assert ((ctx
->region_type
& ORT_TASK
) != 0);
5818 if (struct gimplify_omp_ctx
*octx
= ctx
->outer_context
)
5820 omp_notice_variable (octx
, decl
, in_code
);
5821 for (; octx
; octx
= octx
->outer_context
)
5825 if ((octx
->region_type
& (ORT_TARGET_DATA
| ORT_TARGET
)) != 0)
5827 n2
= splay_tree_lookup (octx
->variables
, (splay_tree_key
) decl
);
5828 if (n2
&& (n2
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
)
5830 flags
|= GOVD_FIRSTPRIVATE
;
5833 if ((octx
->region_type
& (ORT_PARALLEL
| ORT_TEAMS
)) != 0)
5835 flags
|= GOVD_SHARED
;
5841 if (TREE_CODE (decl
) == PARM_DECL
5842 || (!is_global_var (decl
)
5843 && DECL_CONTEXT (decl
) == current_function_decl
))
5844 flags
|= GOVD_FIRSTPRIVATE
;
5846 flags
|= GOVD_SHARED
;
5857 /* Record the fact that DECL was used within the OMP context CTX.
5858 IN_CODE is true when real code uses DECL, and false when we should
5859 merely emit default(none) errors. Return true if DECL is going to
5860 be remapped and thus DECL shouldn't be gimplified into its
5861 DECL_VALUE_EXPR (if any). */
5864 omp_notice_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, bool in_code
)
5867 unsigned flags
= in_code
? GOVD_SEEN
: 0;
5868 bool ret
= false, shared
;
5870 if (error_operand_p (decl
))
5873 /* Threadprivate variables are predetermined. */
5874 if (is_global_var (decl
))
5876 if (DECL_THREAD_LOCAL_P (decl
))
5877 return omp_notice_threadprivate_variable (ctx
, decl
, NULL_TREE
);
5879 if (DECL_HAS_VALUE_EXPR_P (decl
))
5881 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
5883 if (value
&& DECL_P (value
) && DECL_THREAD_LOCAL_P (value
))
5884 return omp_notice_threadprivate_variable (ctx
, decl
, value
);
5888 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5889 if (ctx
->region_type
== ORT_TARGET
)
5891 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, true);
5894 if (!lang_hooks
.types
.omp_mappable_type (TREE_TYPE (decl
)))
5896 error ("%qD referenced in target region does not have "
5897 "a mappable type", decl
);
5898 omp_add_variable (ctx
, decl
, GOVD_MAP
| GOVD_EXPLICIT
| flags
);
5901 omp_add_variable (ctx
, decl
, GOVD_MAP
| flags
);
5905 /* If nothing changed, there's nothing left to do. */
5906 if ((n
->value
& flags
) == flags
)
5915 if (ctx
->region_type
== ORT_WORKSHARE
5916 || ctx
->region_type
== ORT_SIMD
5917 || ctx
->region_type
== ORT_TARGET_DATA
)
5920 flags
= omp_default_clause (ctx
, decl
, in_code
, flags
);
5922 if ((flags
& GOVD_PRIVATE
)
5923 && lang_hooks
.decls
.omp_private_outer_ref (decl
))
5924 flags
|= GOVD_PRIVATE_OUTER_REF
;
5926 omp_add_variable (ctx
, decl
, flags
);
5928 shared
= (flags
& GOVD_SHARED
) != 0;
5929 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
5933 if ((n
->value
& (GOVD_SEEN
| GOVD_LOCAL
)) == 0
5934 && (flags
& (GOVD_SEEN
| GOVD_LOCAL
)) == GOVD_SEEN
5936 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5939 tree t
= DECL_VALUE_EXPR (decl
);
5940 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5941 t
= TREE_OPERAND (t
, 0);
5942 gcc_assert (DECL_P (t
));
5943 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
5944 n2
->value
|= GOVD_SEEN
;
5947 shared
= ((flags
| n
->value
) & GOVD_SHARED
) != 0;
5948 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
5950 /* If nothing changed, there's nothing left to do. */
5951 if ((n
->value
& flags
) == flags
)
5957 /* If the variable is private in the current context, then we don't
5958 need to propagate anything to an outer context. */
5959 if ((flags
& GOVD_PRIVATE
) && !(flags
& GOVD_PRIVATE_OUTER_REF
))
5961 if ((flags
& (GOVD_LINEAR
| GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
5962 == (GOVD_LINEAR
| GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
5964 if ((flags
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
5965 | GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
5966 == (GOVD_LASTPRIVATE
| GOVD_LINEAR_LASTPRIVATE_NO_OUTER
))
5968 if (ctx
->outer_context
5969 && omp_notice_variable (ctx
->outer_context
, decl
, in_code
))
5974 /* Verify that DECL is private within CTX. If there's specific information
5975 to the contrary in the innermost scope, generate an error. */
5978 omp_is_private (struct gimplify_omp_ctx
*ctx
, tree decl
, int simd
)
5982 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5985 if (n
->value
& GOVD_SHARED
)
5987 if (ctx
== gimplify_omp_ctxp
)
5990 error ("iteration variable %qE is predetermined linear",
5993 error ("iteration variable %qE should be private",
5995 n
->value
= GOVD_PRIVATE
;
6001 else if ((n
->value
& GOVD_EXPLICIT
) != 0
6002 && (ctx
== gimplify_omp_ctxp
6003 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6004 && gimplify_omp_ctxp
->outer_context
== ctx
)))
6006 if ((n
->value
& GOVD_FIRSTPRIVATE
) != 0)
6007 error ("iteration variable %qE should not be firstprivate",
6009 else if ((n
->value
& GOVD_REDUCTION
) != 0)
6010 error ("iteration variable %qE should not be reduction",
6012 else if (simd
== 1 && (n
->value
& GOVD_LASTPRIVATE
) != 0)
6013 error ("iteration variable %qE should not be lastprivate",
6015 else if (simd
&& (n
->value
& GOVD_PRIVATE
) != 0)
6016 error ("iteration variable %qE should not be private",
6018 else if (simd
== 2 && (n
->value
& GOVD_LINEAR
) != 0)
6019 error ("iteration variable %qE is predetermined linear",
6022 return (ctx
== gimplify_omp_ctxp
6023 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6024 && gimplify_omp_ctxp
->outer_context
== ctx
));
6027 if (ctx
->region_type
!= ORT_WORKSHARE
6028 && ctx
->region_type
!= ORT_SIMD
)
6030 else if (ctx
->outer_context
)
6031 return omp_is_private (ctx
->outer_context
, decl
, simd
);
6035 /* Return true if DECL is private within a parallel region
6036 that binds to the current construct's context or in parallel
6037 region's REDUCTION clause. */
6040 omp_check_private (struct gimplify_omp_ctx
*ctx
, tree decl
, bool copyprivate
)
6046 ctx
= ctx
->outer_context
;
6048 return !(is_global_var (decl
)
6049 /* References might be private, but might be shared too,
6050 when checking for copyprivate, assume they might be
6051 private, otherwise assume they might be shared. */
6053 && lang_hooks
.decls
.omp_privatize_by_reference (decl
)));
6055 if ((ctx
->region_type
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0)
6058 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6060 return (n
->value
& GOVD_SHARED
) == 0;
6062 while (ctx
->region_type
== ORT_WORKSHARE
6063 || ctx
->region_type
== ORT_SIMD
);
6067 /* Return true if the CTX is combined with distribute and thus
6068 lastprivate can't be supported. */
6071 omp_no_lastprivate (struct gimplify_omp_ctx
*ctx
)
6075 if (ctx
->outer_context
== NULL
)
6077 ctx
= ctx
->outer_context
;
6078 switch (ctx
->region_type
)
6081 if (!ctx
->combined_loop
)
6083 if (ctx
->distribute
)
6086 case ORT_COMBINED_PARALLEL
:
6088 case ORT_COMBINED_TEAMS
:
6097 /* Scan the OMP clauses in *LIST_P, installing mappings into a new
6098 and previous omp contexts. */
6101 gimplify_scan_omp_clauses (tree
*list_p
, gimple_seq
*pre_p
,
6102 enum omp_region_type region_type
)
6104 struct gimplify_omp_ctx
*ctx
, *outer_ctx
;
6107 ctx
= new_omp_context (region_type
);
6108 outer_ctx
= ctx
->outer_context
;
6110 while ((c
= *list_p
) != NULL
)
6112 bool remove
= false;
6113 bool notice_outer
= true;
6114 const char *check_non_private
= NULL
;
6118 switch (OMP_CLAUSE_CODE (c
))
6120 case OMP_CLAUSE_PRIVATE
:
6121 flags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
6122 if (lang_hooks
.decls
.omp_private_outer_ref (OMP_CLAUSE_DECL (c
)))
6124 flags
|= GOVD_PRIVATE_OUTER_REF
;
6125 OMP_CLAUSE_PRIVATE_OUTER_REF (c
) = 1;
6128 notice_outer
= false;
6130 case OMP_CLAUSE_SHARED
:
6131 flags
= GOVD_SHARED
| GOVD_EXPLICIT
;
6133 case OMP_CLAUSE_FIRSTPRIVATE
:
6134 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
6135 check_non_private
= "firstprivate";
6137 case OMP_CLAUSE_LASTPRIVATE
:
6138 flags
= GOVD_LASTPRIVATE
| GOVD_SEEN
| GOVD_EXPLICIT
;
6139 check_non_private
= "lastprivate";
6140 decl
= OMP_CLAUSE_DECL (c
);
6141 if (omp_no_lastprivate (ctx
))
6143 notice_outer
= false;
6144 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
6146 else if (error_operand_p (decl
))
6149 && outer_ctx
->region_type
== ORT_COMBINED_PARALLEL
6150 && splay_tree_lookup (outer_ctx
->variables
,
6151 (splay_tree_key
) decl
) == NULL
)
6152 omp_add_variable (outer_ctx
, decl
, GOVD_SHARED
| GOVD_SEEN
);
6154 && outer_ctx
->region_type
== ORT_WORKSHARE
6155 && outer_ctx
->combined_loop
6156 && splay_tree_lookup (outer_ctx
->variables
,
6157 (splay_tree_key
) decl
) == NULL
6158 && !omp_check_private (outer_ctx
, decl
, false))
6160 omp_add_variable (outer_ctx
, decl
, GOVD_LASTPRIVATE
| GOVD_SEEN
);
6161 if (outer_ctx
->outer_context
6162 && (outer_ctx
->outer_context
->region_type
6163 == ORT_COMBINED_PARALLEL
)
6164 && splay_tree_lookup (outer_ctx
->outer_context
->variables
,
6165 (splay_tree_key
) decl
) == NULL
)
6166 omp_add_variable (outer_ctx
->outer_context
, decl
,
6167 GOVD_SHARED
| GOVD_SEEN
);
6170 case OMP_CLAUSE_REDUCTION
:
6171 flags
= GOVD_REDUCTION
| GOVD_SEEN
| GOVD_EXPLICIT
;
6172 check_non_private
= "reduction";
6174 case OMP_CLAUSE_LINEAR
:
6175 if (gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
), pre_p
, NULL
,
6176 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6183 /* For combined #pragma omp parallel for simd, need to put
6184 lastprivate and perhaps firstprivate too on the
6185 parallel. Similarly for #pragma omp for simd. */
6186 struct gimplify_omp_ctx
*octx
= outer_ctx
;
6188 if (omp_no_lastprivate (ctx
))
6189 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
6192 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
6193 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
6195 decl
= OMP_CLAUSE_DECL (c
);
6196 if (error_operand_p (decl
))
6202 && octx
->region_type
== ORT_WORKSHARE
6203 && octx
->combined_loop
)
6205 if (octx
->outer_context
6206 && (octx
->outer_context
->region_type
6207 == ORT_COMBINED_PARALLEL
6208 || (octx
->outer_context
->region_type
6209 == ORT_COMBINED_TEAMS
)))
6210 octx
= octx
->outer_context
;
6211 else if (omp_check_private (octx
, decl
, false))
6216 gcc_checking_assert (splay_tree_lookup (octx
->variables
,
6220 if (!OMP_CLAUSE_LINEAR_NO_COPYIN (c
))
6221 flags
|= GOVD_FIRSTPRIVATE
;
6222 if (!OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
6223 flags
|= GOVD_LASTPRIVATE
;
6224 omp_add_variable (octx
, decl
, flags
);
6225 if (octx
->outer_context
== NULL
)
6227 octx
= octx
->outer_context
;
6232 && (!OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
6233 || !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)))
6234 omp_notice_variable (octx
, decl
, true);
6236 flags
= GOVD_LINEAR
| GOVD_EXPLICIT
;
6237 if (OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
6238 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
6240 notice_outer
= false;
6241 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
6245 case OMP_CLAUSE_MAP
:
6246 decl
= OMP_CLAUSE_DECL (c
);
6247 if (error_operand_p (decl
))
6252 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
6253 OMP_CLAUSE_SIZE (c
) = DECL_P (decl
) ? DECL_SIZE_UNIT (decl
)
6254 : TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6255 if (gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
6256 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6263 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
,
6264 NULL
, is_gimple_lvalue
, fb_lvalue
)
6272 flags
= GOVD_MAP
| GOVD_EXPLICIT
;
6275 case OMP_CLAUSE_DEPEND
:
6276 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == COMPOUND_EXPR
)
6278 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0), pre_p
,
6279 NULL
, is_gimple_val
, fb_rvalue
);
6280 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (OMP_CLAUSE_DECL (c
), 1);
6282 if (error_operand_p (OMP_CLAUSE_DECL (c
)))
6287 OMP_CLAUSE_DECL (c
) = build_fold_addr_expr (OMP_CLAUSE_DECL (c
));
6288 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
, NULL
,
6289 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6297 case OMP_CLAUSE_FROM
:
6298 case OMP_CLAUSE__CACHE_
:
6299 decl
= OMP_CLAUSE_DECL (c
);
6300 if (error_operand_p (decl
))
6305 if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
6306 OMP_CLAUSE_SIZE (c
) = DECL_P (decl
) ? DECL_SIZE_UNIT (decl
)
6307 : TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6308 if (gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
6309 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6316 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
,
6317 NULL
, is_gimple_lvalue
, fb_lvalue
)
6328 decl
= OMP_CLAUSE_DECL (c
);
6329 if (error_operand_p (decl
))
6334 omp_add_variable (ctx
, decl
, flags
);
6335 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
6336 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
6338 omp_add_variable (ctx
, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
),
6339 GOVD_LOCAL
| GOVD_SEEN
);
6340 gimplify_omp_ctxp
= ctx
;
6341 push_gimplify_context ();
6343 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
6344 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
6346 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c
),
6347 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
6348 pop_gimplify_context
6349 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
)));
6350 push_gimplify_context ();
6351 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c
),
6352 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
6353 pop_gimplify_context
6354 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
)));
6355 OMP_CLAUSE_REDUCTION_INIT (c
) = NULL_TREE
;
6356 OMP_CLAUSE_REDUCTION_MERGE (c
) = NULL_TREE
;
6358 gimplify_omp_ctxp
= outer_ctx
;
6360 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6361 && OMP_CLAUSE_LASTPRIVATE_STMT (c
))
6363 gimplify_omp_ctxp
= ctx
;
6364 push_gimplify_context ();
6365 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c
)) != BIND_EXPR
)
6367 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
6369 TREE_SIDE_EFFECTS (bind
) = 1;
6370 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LASTPRIVATE_STMT (c
);
6371 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = bind
;
6373 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c
),
6374 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6375 pop_gimplify_context
6376 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
)));
6377 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = NULL_TREE
;
6379 gimplify_omp_ctxp
= outer_ctx
;
6381 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
6382 && OMP_CLAUSE_LINEAR_STMT (c
))
6384 gimplify_omp_ctxp
= ctx
;
6385 push_gimplify_context ();
6386 if (TREE_CODE (OMP_CLAUSE_LINEAR_STMT (c
)) != BIND_EXPR
)
6388 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
6390 TREE_SIDE_EFFECTS (bind
) = 1;
6391 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LINEAR_STMT (c
);
6392 OMP_CLAUSE_LINEAR_STMT (c
) = bind
;
6394 gimplify_and_add (OMP_CLAUSE_LINEAR_STMT (c
),
6395 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
));
6396 pop_gimplify_context
6397 (gimple_seq_first_stmt (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
)));
6398 OMP_CLAUSE_LINEAR_STMT (c
) = NULL_TREE
;
6400 gimplify_omp_ctxp
= outer_ctx
;
6406 case OMP_CLAUSE_COPYIN
:
6407 case OMP_CLAUSE_COPYPRIVATE
:
6408 decl
= OMP_CLAUSE_DECL (c
);
6409 if (error_operand_p (decl
))
6414 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_COPYPRIVATE
6416 && !omp_check_private (ctx
, decl
, true))
6419 if (is_global_var (decl
))
6421 if (DECL_THREAD_LOCAL_P (decl
))
6423 else if (DECL_HAS_VALUE_EXPR_P (decl
))
6425 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
6429 && DECL_THREAD_LOCAL_P (value
))
6434 error_at (OMP_CLAUSE_LOCATION (c
),
6435 "copyprivate variable %qE is not threadprivate"
6436 " or private in outer context", DECL_NAME (decl
));
6440 omp_notice_variable (outer_ctx
, decl
, true);
6441 if (check_non_private
6442 && region_type
== ORT_WORKSHARE
6443 && omp_check_private (ctx
, decl
, false))
6445 error ("%s variable %qE is private in outer context",
6446 check_non_private
, DECL_NAME (decl
));
6451 case OMP_CLAUSE_FINAL
:
6453 OMP_CLAUSE_OPERAND (c
, 0)
6454 = gimple_boolify (OMP_CLAUSE_OPERAND (c
, 0));
6457 case OMP_CLAUSE_SCHEDULE
:
6458 case OMP_CLAUSE_NUM_THREADS
:
6459 case OMP_CLAUSE_NUM_TEAMS
:
6460 case OMP_CLAUSE_THREAD_LIMIT
:
6461 case OMP_CLAUSE_DIST_SCHEDULE
:
6462 case OMP_CLAUSE_DEVICE
:
6463 case OMP_CLAUSE__CILK_FOR_COUNT_
:
6464 case OMP_CLAUSE_ASYNC
:
6465 case OMP_CLAUSE_WAIT
:
6466 case OMP_CLAUSE_NUM_GANGS
:
6467 case OMP_CLAUSE_NUM_WORKERS
:
6468 case OMP_CLAUSE_VECTOR_LENGTH
:
6469 case OMP_CLAUSE_GANG
:
6470 case OMP_CLAUSE_WORKER
:
6471 case OMP_CLAUSE_VECTOR
:
6472 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
6473 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6475 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_GANG
6476 && gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 1), pre_p
, NULL
,
6477 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6481 case OMP_CLAUSE_DEVICE_RESIDENT
:
6482 case OMP_CLAUSE_USE_DEVICE
:
6483 case OMP_CLAUSE_INDEPENDENT
:
6487 case OMP_CLAUSE_NOWAIT
:
6488 case OMP_CLAUSE_ORDERED
:
6489 case OMP_CLAUSE_UNTIED
:
6490 case OMP_CLAUSE_COLLAPSE
:
6491 case OMP_CLAUSE_AUTO
:
6492 case OMP_CLAUSE_SEQ
:
6493 case OMP_CLAUSE_MERGEABLE
:
6494 case OMP_CLAUSE_PROC_BIND
:
6495 case OMP_CLAUSE_SAFELEN
:
6498 case OMP_CLAUSE_ALIGNED
:
6499 decl
= OMP_CLAUSE_DECL (c
);
6500 if (error_operand_p (decl
))
6505 if (gimplify_expr (&OMP_CLAUSE_ALIGNED_ALIGNMENT (c
), pre_p
, NULL
,
6506 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6511 if (!is_global_var (decl
)
6512 && TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
6513 omp_add_variable (ctx
, decl
, GOVD_ALIGNED
);
6516 case OMP_CLAUSE_DEFAULT
:
6517 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
6525 *list_p
= OMP_CLAUSE_CHAIN (c
);
6527 list_p
= &OMP_CLAUSE_CHAIN (c
);
6530 gimplify_omp_ctxp
= ctx
;
6533 struct gimplify_adjust_omp_clauses_data
6539 /* For all variables that were not actually used within the context,
6540 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
6543 gimplify_adjust_omp_clauses_1 (splay_tree_node n
, void *data
)
6545 tree
*list_p
= ((struct gimplify_adjust_omp_clauses_data
*) data
)->list_p
;
6547 = ((struct gimplify_adjust_omp_clauses_data
*) data
)->pre_p
;
6548 tree decl
= (tree
) n
->key
;
6549 unsigned flags
= n
->value
;
6550 enum omp_clause_code code
;
6554 if (flags
& (GOVD_EXPLICIT
| GOVD_LOCAL
))
6556 if ((flags
& GOVD_SEEN
) == 0)
6558 if (flags
& GOVD_DEBUG_PRIVATE
)
6560 gcc_assert ((flags
& GOVD_DATA_SHARE_CLASS
) == GOVD_PRIVATE
);
6561 private_debug
= true;
6563 else if (flags
& GOVD_MAP
)
6564 private_debug
= false;
6567 = lang_hooks
.decls
.omp_private_debug_clause (decl
,
6568 !!(flags
& GOVD_SHARED
));
6570 code
= OMP_CLAUSE_PRIVATE
;
6571 else if (flags
& GOVD_MAP
)
6572 code
= OMP_CLAUSE_MAP
;
6573 else if (flags
& GOVD_SHARED
)
6575 if (is_global_var (decl
))
6577 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
6581 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6582 if (on
&& (on
->value
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
6583 | GOVD_PRIVATE
| GOVD_REDUCTION
6584 | GOVD_LINEAR
| GOVD_MAP
)) != 0)
6586 ctx
= ctx
->outer_context
;
6591 code
= OMP_CLAUSE_SHARED
;
6593 else if (flags
& GOVD_PRIVATE
)
6594 code
= OMP_CLAUSE_PRIVATE
;
6595 else if (flags
& GOVD_FIRSTPRIVATE
)
6596 code
= OMP_CLAUSE_FIRSTPRIVATE
;
6597 else if (flags
& GOVD_LASTPRIVATE
)
6598 code
= OMP_CLAUSE_LASTPRIVATE
;
6599 else if (flags
& GOVD_ALIGNED
)
6604 clause
= build_omp_clause (input_location
, code
);
6605 OMP_CLAUSE_DECL (clause
) = decl
;
6606 OMP_CLAUSE_CHAIN (clause
) = *list_p
;
6608 OMP_CLAUSE_PRIVATE_DEBUG (clause
) = 1;
6609 else if (code
== OMP_CLAUSE_PRIVATE
&& (flags
& GOVD_PRIVATE_OUTER_REF
))
6610 OMP_CLAUSE_PRIVATE_OUTER_REF (clause
) = 1;
6611 else if (code
== OMP_CLAUSE_MAP
)
6613 OMP_CLAUSE_SET_MAP_KIND (clause
,
6614 flags
& GOVD_MAP_TO_ONLY
6617 if (DECL_SIZE (decl
)
6618 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6620 tree decl2
= DECL_VALUE_EXPR (decl
);
6621 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
6622 decl2
= TREE_OPERAND (decl2
, 0);
6623 gcc_assert (DECL_P (decl2
));
6624 tree mem
= build_simple_mem_ref (decl2
);
6625 OMP_CLAUSE_DECL (clause
) = mem
;
6626 OMP_CLAUSE_SIZE (clause
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6627 if (gimplify_omp_ctxp
->outer_context
)
6629 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
6630 omp_notice_variable (ctx
, decl2
, true);
6631 omp_notice_variable (ctx
, OMP_CLAUSE_SIZE (clause
), true);
6633 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
),
6635 OMP_CLAUSE_DECL (nc
) = decl
;
6636 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
6637 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_POINTER
);
6638 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (clause
);
6639 OMP_CLAUSE_CHAIN (clause
) = nc
;
6642 OMP_CLAUSE_SIZE (clause
) = DECL_SIZE_UNIT (decl
);
6644 if (code
== OMP_CLAUSE_FIRSTPRIVATE
&& (flags
& GOVD_LASTPRIVATE
) != 0)
6646 tree nc
= build_omp_clause (input_location
, OMP_CLAUSE_LASTPRIVATE
);
6647 OMP_CLAUSE_DECL (nc
) = decl
;
6648 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (nc
) = 1;
6649 OMP_CLAUSE_CHAIN (nc
) = *list_p
;
6650 OMP_CLAUSE_CHAIN (clause
) = nc
;
6651 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6652 gimplify_omp_ctxp
= ctx
->outer_context
;
6653 lang_hooks
.decls
.omp_finish_clause (nc
, pre_p
);
6654 gimplify_omp_ctxp
= ctx
;
6657 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6658 gimplify_omp_ctxp
= ctx
->outer_context
;
6659 lang_hooks
.decls
.omp_finish_clause (clause
, pre_p
);
6660 gimplify_omp_ctxp
= ctx
;
6665 gimplify_adjust_omp_clauses (gimple_seq
*pre_p
, tree
*list_p
)
6667 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6670 while ((c
= *list_p
) != NULL
)
6673 bool remove
= false;
6675 switch (OMP_CLAUSE_CODE (c
))
6677 case OMP_CLAUSE_PRIVATE
:
6678 case OMP_CLAUSE_SHARED
:
6679 case OMP_CLAUSE_FIRSTPRIVATE
:
6680 case OMP_CLAUSE_LINEAR
:
6681 decl
= OMP_CLAUSE_DECL (c
);
6682 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6683 remove
= !(n
->value
& GOVD_SEEN
);
6686 bool shared
= OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
;
6687 if ((n
->value
& GOVD_DEBUG_PRIVATE
)
6688 || lang_hooks
.decls
.omp_private_debug_clause (decl
, shared
))
6690 gcc_assert ((n
->value
& GOVD_DEBUG_PRIVATE
) == 0
6691 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
6693 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_PRIVATE
);
6694 OMP_CLAUSE_PRIVATE_DEBUG (c
) = 1;
6699 case OMP_CLAUSE_LASTPRIVATE
:
6700 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
6701 accurately reflect the presence of a FIRSTPRIVATE clause. */
6702 decl
= OMP_CLAUSE_DECL (c
);
6703 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6704 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
6705 = (n
->value
& GOVD_FIRSTPRIVATE
) != 0;
6706 if (omp_no_lastprivate (ctx
))
6708 if (OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
))
6711 OMP_CLAUSE_CODE (c
) = OMP_CLAUSE_PRIVATE
;
6715 case OMP_CLAUSE_ALIGNED
:
6716 decl
= OMP_CLAUSE_DECL (c
);
6717 if (!is_global_var (decl
))
6719 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6720 remove
= n
== NULL
|| !(n
->value
& GOVD_SEEN
);
6721 if (!remove
&& TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
6723 struct gimplify_omp_ctx
*octx
;
6725 && (n
->value
& (GOVD_DATA_SHARE_CLASS
6726 & ~GOVD_FIRSTPRIVATE
)))
6729 for (octx
= ctx
->outer_context
; octx
;
6730 octx
= octx
->outer_context
)
6732 n
= splay_tree_lookup (octx
->variables
,
6733 (splay_tree_key
) decl
);
6736 if (n
->value
& GOVD_LOCAL
)
6738 /* We have to avoid assigning a shared variable
6739 to itself when trying to add
6740 __builtin_assume_aligned. */
6741 if (n
->value
& GOVD_SHARED
)
6749 else if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
6751 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6752 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
6757 case OMP_CLAUSE_MAP
:
6758 decl
= OMP_CLAUSE_DECL (c
);
6761 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6762 if (ctx
->region_type
== ORT_TARGET
&& !(n
->value
& GOVD_SEEN
))
6764 else if (DECL_SIZE (decl
)
6765 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
6766 && OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_POINTER
)
6768 /* For GOMP_MAP_FORCE_DEVICEPTR, we'll never enter here, because
6769 for these, TREE_CODE (DECL_SIZE (decl)) will always be
6771 gcc_assert (OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_FORCE_DEVICEPTR
);
6773 tree decl2
= DECL_VALUE_EXPR (decl
);
6774 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
6775 decl2
= TREE_OPERAND (decl2
, 0);
6776 gcc_assert (DECL_P (decl2
));
6777 tree mem
= build_simple_mem_ref (decl2
);
6778 OMP_CLAUSE_DECL (c
) = mem
;
6779 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6780 if (ctx
->outer_context
)
6782 omp_notice_variable (ctx
->outer_context
, decl2
, true);
6783 omp_notice_variable (ctx
->outer_context
,
6784 OMP_CLAUSE_SIZE (c
), true);
6786 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
6788 OMP_CLAUSE_DECL (nc
) = decl
;
6789 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
6790 OMP_CLAUSE_SET_MAP_KIND (nc
, GOMP_MAP_POINTER
);
6791 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (c
);
6792 OMP_CLAUSE_CHAIN (c
) = nc
;
6795 else if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
6796 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
6800 case OMP_CLAUSE_FROM
:
6801 case OMP_CLAUSE__CACHE_
:
6802 decl
= OMP_CLAUSE_DECL (c
);
6805 if (DECL_SIZE (decl
)
6806 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6808 tree decl2
= DECL_VALUE_EXPR (decl
);
6809 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
6810 decl2
= TREE_OPERAND (decl2
, 0);
6811 gcc_assert (DECL_P (decl2
));
6812 tree mem
= build_simple_mem_ref (decl2
);
6813 OMP_CLAUSE_DECL (c
) = mem
;
6814 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6815 if (ctx
->outer_context
)
6817 omp_notice_variable (ctx
->outer_context
, decl2
, true);
6818 omp_notice_variable (ctx
->outer_context
,
6819 OMP_CLAUSE_SIZE (c
), true);
6822 else if (OMP_CLAUSE_SIZE (c
) == NULL_TREE
)
6823 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
6826 case OMP_CLAUSE_REDUCTION
:
6827 case OMP_CLAUSE_COPYIN
:
6828 case OMP_CLAUSE_COPYPRIVATE
:
6830 case OMP_CLAUSE_NUM_THREADS
:
6831 case OMP_CLAUSE_NUM_TEAMS
:
6832 case OMP_CLAUSE_THREAD_LIMIT
:
6833 case OMP_CLAUSE_DIST_SCHEDULE
:
6834 case OMP_CLAUSE_DEVICE
:
6835 case OMP_CLAUSE_SCHEDULE
:
6836 case OMP_CLAUSE_NOWAIT
:
6837 case OMP_CLAUSE_ORDERED
:
6838 case OMP_CLAUSE_DEFAULT
:
6839 case OMP_CLAUSE_UNTIED
:
6840 case OMP_CLAUSE_COLLAPSE
:
6841 case OMP_CLAUSE_FINAL
:
6842 case OMP_CLAUSE_MERGEABLE
:
6843 case OMP_CLAUSE_PROC_BIND
:
6844 case OMP_CLAUSE_SAFELEN
:
6845 case OMP_CLAUSE_DEPEND
:
6846 case OMP_CLAUSE__CILK_FOR_COUNT_
:
6847 case OMP_CLAUSE_ASYNC
:
6848 case OMP_CLAUSE_WAIT
:
6849 case OMP_CLAUSE_DEVICE_RESIDENT
:
6850 case OMP_CLAUSE_USE_DEVICE
:
6851 case OMP_CLAUSE_INDEPENDENT
:
6852 case OMP_CLAUSE_NUM_GANGS
:
6853 case OMP_CLAUSE_NUM_WORKERS
:
6854 case OMP_CLAUSE_VECTOR_LENGTH
:
6855 case OMP_CLAUSE_GANG
:
6856 case OMP_CLAUSE_WORKER
:
6857 case OMP_CLAUSE_VECTOR
:
6858 case OMP_CLAUSE_AUTO
:
6859 case OMP_CLAUSE_SEQ
:
6867 *list_p
= OMP_CLAUSE_CHAIN (c
);
6869 list_p
= &OMP_CLAUSE_CHAIN (c
);
6872 /* Add in any implicit data sharing. */
6873 struct gimplify_adjust_omp_clauses_data data
;
6874 data
.list_p
= list_p
;
6876 splay_tree_foreach (ctx
->variables
, gimplify_adjust_omp_clauses_1
, &data
);
6878 gimplify_omp_ctxp
= ctx
->outer_context
;
6879 delete_omp_context (ctx
);
6882 /* Gimplify OACC_CACHE. */
6885 gimplify_oacc_cache (tree
*expr_p
, gimple_seq
*pre_p
)
6887 tree expr
= *expr_p
;
6889 gimplify_scan_omp_clauses (&OACC_CACHE_CLAUSES (expr
), pre_p
, ORT_WORKSHARE
);
6890 gimplify_adjust_omp_clauses (pre_p
, &OACC_CACHE_CLAUSES (expr
));
6892 /* TODO: Do something sensible with this information. */
6894 *expr_p
= NULL_TREE
;
6897 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
6898 gimplification of the body, as well as scanning the body for used
6899 variables. We need to do this scan now, because variable-sized
6900 decls will be decomposed during gimplification. */
6903 gimplify_omp_parallel (tree
*expr_p
, gimple_seq
*pre_p
)
6905 tree expr
= *expr_p
;
6907 gimple_seq body
= NULL
;
6909 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
), pre_p
,
6910 OMP_PARALLEL_COMBINED (expr
)
6911 ? ORT_COMBINED_PARALLEL
6914 push_gimplify_context ();
6916 g
= gimplify_and_return_first (OMP_PARALLEL_BODY (expr
), &body
);
6917 if (gimple_code (g
) == GIMPLE_BIND
)
6918 pop_gimplify_context (g
);
6920 pop_gimplify_context (NULL
);
6922 gimplify_adjust_omp_clauses (pre_p
, &OMP_PARALLEL_CLAUSES (expr
));
6924 g
= gimple_build_omp_parallel (body
,
6925 OMP_PARALLEL_CLAUSES (expr
),
6926 NULL_TREE
, NULL_TREE
);
6927 if (OMP_PARALLEL_COMBINED (expr
))
6928 gimple_omp_set_subcode (g
, GF_OMP_PARALLEL_COMBINED
);
6929 gimplify_seq_add_stmt (pre_p
, g
);
6930 *expr_p
= NULL_TREE
;
6933 /* Gimplify the contents of an OMP_TASK statement. This involves
6934 gimplification of the body, as well as scanning the body for used
6935 variables. We need to do this scan now, because variable-sized
6936 decls will be decomposed during gimplification. */
6939 gimplify_omp_task (tree
*expr_p
, gimple_seq
*pre_p
)
6941 tree expr
= *expr_p
;
6943 gimple_seq body
= NULL
;
6945 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr
), pre_p
,
6946 find_omp_clause (OMP_TASK_CLAUSES (expr
),
6948 ? ORT_UNTIED_TASK
: ORT_TASK
);
6950 push_gimplify_context ();
6952 g
= gimplify_and_return_first (OMP_TASK_BODY (expr
), &body
);
6953 if (gimple_code (g
) == GIMPLE_BIND
)
6954 pop_gimplify_context (g
);
6956 pop_gimplify_context (NULL
);
6958 gimplify_adjust_omp_clauses (pre_p
, &OMP_TASK_CLAUSES (expr
));
6960 g
= gimple_build_omp_task (body
,
6961 OMP_TASK_CLAUSES (expr
),
6962 NULL_TREE
, NULL_TREE
,
6963 NULL_TREE
, NULL_TREE
, NULL_TREE
);
6964 gimplify_seq_add_stmt (pre_p
, g
);
6965 *expr_p
= NULL_TREE
;
6968 /* Helper function of gimplify_omp_for, find OMP_FOR resp. OMP_SIMD
6969 with non-NULL OMP_FOR_INIT. */
6972 find_combined_omp_for (tree
*tp
, int *walk_subtrees
, void *)
6975 switch (TREE_CODE (*tp
))
6981 if (OMP_FOR_INIT (*tp
) != NULL_TREE
)
6985 case STATEMENT_LIST
:
6995 /* Gimplify the gross structure of an OMP_FOR statement. */
6997 static enum gimplify_status
6998 gimplify_omp_for (tree
*expr_p
, gimple_seq
*pre_p
)
7000 tree for_stmt
, orig_for_stmt
, decl
, var
, t
;
7001 enum gimplify_status ret
= GS_ALL_DONE
;
7002 enum gimplify_status tret
;
7004 gimple_seq for_body
, for_pre_body
;
7007 bitmap has_decl_expr
= NULL
;
7009 orig_for_stmt
= for_stmt
= *expr_p
;
7011 switch (TREE_CODE (for_stmt
))
7015 case OMP_DISTRIBUTE
:
7027 /* Set OMP_CLAUSE_LINEAR_NO_COPYIN flag on explicit linear
7028 clause for the IV. */
7029 if (simd
&& TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
7031 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), 0);
7032 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
7033 decl
= TREE_OPERAND (t
, 0);
7034 for (tree c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
7035 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
7036 && OMP_CLAUSE_DECL (c
) == decl
)
7038 OMP_CLAUSE_LINEAR_NO_COPYIN (c
) = 1;
7043 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
), pre_p
,
7044 simd
? ORT_SIMD
: ORT_WORKSHARE
);
7045 if (TREE_CODE (for_stmt
) == OMP_DISTRIBUTE
)
7046 gimplify_omp_ctxp
->distribute
= true;
7048 /* Handle OMP_FOR_INIT. */
7049 for_pre_body
= NULL
;
7050 if (simd
&& OMP_FOR_PRE_BODY (for_stmt
))
7052 has_decl_expr
= BITMAP_ALLOC (NULL
);
7053 if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == DECL_EXPR
7054 && TREE_CODE (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt
)))
7057 t
= OMP_FOR_PRE_BODY (for_stmt
);
7058 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
7060 else if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == STATEMENT_LIST
)
7062 tree_stmt_iterator si
;
7063 for (si
= tsi_start (OMP_FOR_PRE_BODY (for_stmt
)); !tsi_end_p (si
);
7067 if (TREE_CODE (t
) == DECL_EXPR
7068 && TREE_CODE (DECL_EXPR_DECL (t
)) == VAR_DECL
)
7069 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
7073 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
7074 OMP_FOR_PRE_BODY (for_stmt
) = NULL_TREE
;
7076 if (OMP_FOR_INIT (for_stmt
) == NULL_TREE
)
7078 gcc_assert (TREE_CODE (for_stmt
) != OACC_LOOP
);
7079 for_stmt
= walk_tree (&OMP_FOR_BODY (for_stmt
), find_combined_omp_for
,
7081 gcc_assert (for_stmt
!= NULL_TREE
);
7082 gimplify_omp_ctxp
->combined_loop
= true;
7086 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
7087 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt
)));
7088 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
7089 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt
)));
7090 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
7092 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
7093 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
7094 decl
= TREE_OPERAND (t
, 0);
7095 gcc_assert (DECL_P (decl
));
7096 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl
))
7097 || POINTER_TYPE_P (TREE_TYPE (decl
)));
7099 /* Make sure the iteration variable is private. */
7101 tree c2
= NULL_TREE
;
7102 if (orig_for_stmt
!= for_stmt
)
7103 /* Do this only on innermost construct for combined ones. */;
7106 splay_tree_node n
= splay_tree_lookup (gimplify_omp_ctxp
->variables
,
7107 (splay_tree_key
)decl
);
7108 omp_is_private (gimplify_omp_ctxp
, decl
,
7109 1 + (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
7111 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
7112 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
7113 else if (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
7115 c
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
7116 OMP_CLAUSE_LINEAR_NO_COPYIN (c
) = 1;
7117 unsigned int flags
= GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
;
7119 && bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)))
7120 || omp_no_lastprivate (gimplify_omp_ctxp
))
7122 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
7123 flags
|= GOVD_LINEAR_LASTPRIVATE_NO_OUTER
;
7125 OMP_CLAUSE_DECL (c
) = decl
;
7126 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
7127 OMP_FOR_CLAUSES (for_stmt
) = c
;
7129 omp_add_variable (gimplify_omp_ctxp
, decl
, flags
);
7130 struct gimplify_omp_ctx
*outer
7131 = gimplify_omp_ctxp
->outer_context
;
7132 if (outer
&& !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
7134 if (outer
->region_type
== ORT_WORKSHARE
7135 && outer
->combined_loop
)
7137 if (outer
->outer_context
7138 && (outer
->outer_context
->region_type
7139 == ORT_COMBINED_PARALLEL
))
7140 outer
= outer
->outer_context
;
7141 else if (omp_check_private (outer
, decl
, false))
7144 else if (outer
->region_type
!= ORT_COMBINED_PARALLEL
)
7148 omp_add_variable (outer
, decl
,
7149 GOVD_LASTPRIVATE
| GOVD_SEEN
);
7150 if (outer
->outer_context
)
7151 omp_notice_variable (outer
->outer_context
, decl
, true);
7159 || !bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)))
7160 && !omp_no_lastprivate (gimplify_omp_ctxp
);
7161 struct gimplify_omp_ctx
*outer
7162 = gimplify_omp_ctxp
->outer_context
;
7163 if (outer
&& lastprivate
)
7165 if (outer
->region_type
== ORT_WORKSHARE
7166 && outer
->combined_loop
)
7168 if (outer
->outer_context
7169 && (outer
->outer_context
->region_type
7170 == ORT_COMBINED_PARALLEL
))
7171 outer
= outer
->outer_context
;
7172 else if (omp_check_private (outer
, decl
, false))
7175 else if (outer
->region_type
!= ORT_COMBINED_PARALLEL
)
7179 omp_add_variable (outer
, decl
,
7180 GOVD_LASTPRIVATE
| GOVD_SEEN
);
7181 if (outer
->outer_context
)
7182 omp_notice_variable (outer
->outer_context
, decl
, true);
7186 c
= build_omp_clause (input_location
,
7187 lastprivate
? OMP_CLAUSE_LASTPRIVATE
7188 : OMP_CLAUSE_PRIVATE
);
7189 OMP_CLAUSE_DECL (c
) = decl
;
7190 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
7191 OMP_FOR_CLAUSES (for_stmt
) = c
;
7192 omp_add_variable (gimplify_omp_ctxp
, decl
,
7193 (lastprivate
? GOVD_LASTPRIVATE
: GOVD_PRIVATE
)
7194 | GOVD_EXPLICIT
| GOVD_SEEN
);
7198 else if (omp_is_private (gimplify_omp_ctxp
, decl
, 0))
7199 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
7201 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_PRIVATE
| GOVD_SEEN
);
7203 /* If DECL is not a gimple register, create a temporary variable to act
7204 as an iteration counter. This is valid, since DECL cannot be
7205 modified in the body of the loop. Similarly for any iteration vars
7206 in simd with collapse > 1 where the iterator vars must be
7208 if (orig_for_stmt
!= for_stmt
)
7210 else if (!is_gimple_reg (decl
)
7211 || (simd
&& TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1))
7213 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
7214 TREE_OPERAND (t
, 0) = var
;
7216 gimplify_seq_add_stmt (&for_body
, gimple_build_assign (decl
, var
));
7218 if (simd
&& TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
7220 c2
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
7221 OMP_CLAUSE_LINEAR_NO_COPYIN (c2
) = 1;
7222 OMP_CLAUSE_LINEAR_NO_COPYOUT (c2
) = 1;
7223 OMP_CLAUSE_DECL (c2
) = var
;
7224 OMP_CLAUSE_CHAIN (c2
) = OMP_FOR_CLAUSES (for_stmt
);
7225 OMP_FOR_CLAUSES (for_stmt
) = c2
;
7226 omp_add_variable (gimplify_omp_ctxp
, var
,
7227 GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
);
7235 omp_add_variable (gimplify_omp_ctxp
, var
,
7236 GOVD_PRIVATE
| GOVD_SEEN
);
7241 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
7242 is_gimple_val
, fb_rvalue
);
7243 ret
= MIN (ret
, tret
);
7244 if (ret
== GS_ERROR
)
7247 /* Handle OMP_FOR_COND. */
7248 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
7249 gcc_assert (COMPARISON_CLASS_P (t
));
7250 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
7252 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
7253 is_gimple_val
, fb_rvalue
);
7254 ret
= MIN (ret
, tret
);
7256 /* Handle OMP_FOR_INCR. */
7257 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7258 switch (TREE_CODE (t
))
7260 case PREINCREMENT_EXPR
:
7261 case POSTINCREMENT_EXPR
:
7263 tree decl
= TREE_OPERAND (t
, 0);
7264 /* c_omp_for_incr_canonicalize_ptr() should have been
7265 called to massage things appropriately. */
7266 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl
)));
7268 if (orig_for_stmt
!= for_stmt
)
7270 t
= build_int_cst (TREE_TYPE (decl
), 1);
7272 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
7273 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
7274 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
7275 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
7279 case PREDECREMENT_EXPR
:
7280 case POSTDECREMENT_EXPR
:
7281 /* c_omp_for_incr_canonicalize_ptr() should have been
7282 called to massage things appropriately. */
7283 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (decl
)));
7284 if (orig_for_stmt
!= for_stmt
)
7286 t
= build_int_cst (TREE_TYPE (decl
), -1);
7288 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
7289 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
7290 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
7291 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
7295 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
7296 TREE_OPERAND (t
, 0) = var
;
7298 t
= TREE_OPERAND (t
, 1);
7299 switch (TREE_CODE (t
))
7302 if (TREE_OPERAND (t
, 1) == decl
)
7304 TREE_OPERAND (t
, 1) = TREE_OPERAND (t
, 0);
7305 TREE_OPERAND (t
, 0) = var
;
7311 case POINTER_PLUS_EXPR
:
7312 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
7313 TREE_OPERAND (t
, 0) = var
;
7319 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
7320 is_gimple_val
, fb_rvalue
);
7321 ret
= MIN (ret
, tret
);
7324 tree step
= TREE_OPERAND (t
, 1);
7325 tree stept
= TREE_TYPE (decl
);
7326 if (POINTER_TYPE_P (stept
))
7328 step
= fold_convert (stept
, step
);
7329 if (TREE_CODE (t
) == MINUS_EXPR
)
7330 step
= fold_build1 (NEGATE_EXPR
, stept
, step
);
7331 OMP_CLAUSE_LINEAR_STEP (c
) = step
;
7332 if (step
!= TREE_OPERAND (t
, 1))
7334 tret
= gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
),
7335 &for_pre_body
, NULL
,
7336 is_gimple_val
, fb_rvalue
);
7337 ret
= MIN (ret
, tret
);
7349 OMP_CLAUSE_LINEAR_STEP (c2
) = OMP_CLAUSE_LINEAR_STEP (c
);
7352 if ((var
!= decl
|| TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1)
7353 && orig_for_stmt
== for_stmt
)
7355 for (c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
7356 if (((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
7357 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) == NULL
)
7358 || (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
7359 && !OMP_CLAUSE_LINEAR_NO_COPYOUT (c
)
7360 && OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
) == NULL
))
7361 && OMP_CLAUSE_DECL (c
) == decl
)
7363 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7364 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
7365 gcc_assert (TREE_OPERAND (t
, 0) == var
);
7366 t
= TREE_OPERAND (t
, 1);
7367 gcc_assert (TREE_CODE (t
) == PLUS_EXPR
7368 || TREE_CODE (t
) == MINUS_EXPR
7369 || TREE_CODE (t
) == POINTER_PLUS_EXPR
);
7370 gcc_assert (TREE_OPERAND (t
, 0) == var
);
7371 t
= build2 (TREE_CODE (t
), TREE_TYPE (decl
), decl
,
7372 TREE_OPERAND (t
, 1));
7374 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
)
7375 seq
= &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
);
7377 seq
= &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (c
);
7378 gimplify_assign (decl
, t
, seq
);
7383 BITMAP_FREE (has_decl_expr
);
7385 gimplify_and_add (OMP_FOR_BODY (orig_for_stmt
), &for_body
);
7387 if (orig_for_stmt
!= for_stmt
)
7388 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
7390 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
7391 decl
= TREE_OPERAND (t
, 0);
7392 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
7393 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
7394 TREE_OPERAND (t
, 0) = var
;
7395 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7396 TREE_OPERAND (t
, 1) = copy_node (TREE_OPERAND (t
, 1));
7397 TREE_OPERAND (TREE_OPERAND (t
, 1), 0) = var
;
7400 gimplify_adjust_omp_clauses (pre_p
, &OMP_FOR_CLAUSES (orig_for_stmt
));
7403 switch (TREE_CODE (orig_for_stmt
))
7405 case OMP_FOR
: kind
= GF_OMP_FOR_KIND_FOR
; break;
7406 case OMP_SIMD
: kind
= GF_OMP_FOR_KIND_SIMD
; break;
7407 case CILK_SIMD
: kind
= GF_OMP_FOR_KIND_CILKSIMD
; break;
7408 case CILK_FOR
: kind
= GF_OMP_FOR_KIND_CILKFOR
; break;
7409 case OMP_DISTRIBUTE
: kind
= GF_OMP_FOR_KIND_DISTRIBUTE
; break;
7410 case OACC_LOOP
: kind
= GF_OMP_FOR_KIND_OACC_LOOP
; break;
7414 gfor
= gimple_build_omp_for (for_body
, kind
, OMP_FOR_CLAUSES (orig_for_stmt
),
7415 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)),
7417 if (orig_for_stmt
!= for_stmt
)
7418 gimple_omp_for_set_combined_p (gfor
, true);
7419 if (gimplify_omp_ctxp
7420 && (gimplify_omp_ctxp
->combined_loop
7421 || (gimplify_omp_ctxp
->region_type
== ORT_COMBINED_PARALLEL
7422 && gimplify_omp_ctxp
->outer_context
7423 && gimplify_omp_ctxp
->outer_context
->combined_loop
)))
7425 gimple_omp_for_set_combined_into_p (gfor
, true);
7426 if (gimplify_omp_ctxp
->combined_loop
)
7427 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_SIMD
);
7429 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_FOR
);
7432 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
7434 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
7435 gimple_omp_for_set_index (gfor
, i
, TREE_OPERAND (t
, 0));
7436 gimple_omp_for_set_initial (gfor
, i
, TREE_OPERAND (t
, 1));
7437 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
7438 gimple_omp_for_set_cond (gfor
, i
, TREE_CODE (t
));
7439 gimple_omp_for_set_final (gfor
, i
, TREE_OPERAND (t
, 1));
7440 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7441 gimple_omp_for_set_incr (gfor
, i
, TREE_OPERAND (t
, 1));
7444 gimplify_seq_add_stmt (pre_p
, gfor
);
7445 if (ret
!= GS_ALL_DONE
)
7447 *expr_p
= NULL_TREE
;
7451 /* Gimplify the gross structure of several OMP constructs. */
7454 gimplify_omp_workshare (tree
*expr_p
, gimple_seq
*pre_p
)
7456 tree expr
= *expr_p
;
7458 gimple_seq body
= NULL
;
7459 enum omp_region_type ort
;
7461 switch (TREE_CODE (expr
))
7465 ort
= ORT_WORKSHARE
;
7473 case OMP_TARGET_DATA
:
7474 ort
= ORT_TARGET_DATA
;
7477 ort
= OMP_TEAMS_COMBINED (expr
) ? ORT_COMBINED_TEAMS
: ORT_TEAMS
;
7482 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr
), pre_p
, ort
);
7483 if (ort
== ORT_TARGET
|| ort
== ORT_TARGET_DATA
)
7485 push_gimplify_context ();
7486 gimple g
= gimplify_and_return_first (OMP_BODY (expr
), &body
);
7487 if (gimple_code (g
) == GIMPLE_BIND
)
7488 pop_gimplify_context (g
);
7490 pop_gimplify_context (NULL
);
7491 if (ort
== ORT_TARGET_DATA
)
7493 enum built_in_function end_ix
;
7494 switch (TREE_CODE (expr
))
7497 end_ix
= BUILT_IN_GOACC_DATA_END
;
7499 case OMP_TARGET_DATA
:
7500 end_ix
= BUILT_IN_GOMP_TARGET_END_DATA
;
7505 tree fn
= builtin_decl_explicit (end_ix
);
7506 g
= gimple_build_call (fn
, 0);
7507 gimple_seq cleanup
= NULL
;
7508 gimple_seq_add_stmt (&cleanup
, g
);
7509 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
7511 gimple_seq_add_stmt (&body
, g
);
7515 gimplify_and_add (OMP_BODY (expr
), &body
);
7516 gimplify_adjust_omp_clauses (pre_p
, &OMP_CLAUSES (expr
));
7518 switch (TREE_CODE (expr
))
7521 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_DATA
,
7522 OMP_CLAUSES (expr
));
7525 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_KERNELS
,
7526 OMP_CLAUSES (expr
));
7529 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_OACC_PARALLEL
,
7530 OMP_CLAUSES (expr
));
7533 stmt
= gimple_build_omp_sections (body
, OMP_CLAUSES (expr
));
7536 stmt
= gimple_build_omp_single (body
, OMP_CLAUSES (expr
));
7539 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_REGION
,
7540 OMP_CLAUSES (expr
));
7542 case OMP_TARGET_DATA
:
7543 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_DATA
,
7544 OMP_CLAUSES (expr
));
7547 stmt
= gimple_build_omp_teams (body
, OMP_CLAUSES (expr
));
7553 gimplify_seq_add_stmt (pre_p
, stmt
);
7554 *expr_p
= NULL_TREE
;
7557 /* Gimplify the gross structure of OpenACC enter/exit data, update, and OpenMP
7558 target update constructs. */
7561 gimplify_omp_target_update (tree
*expr_p
, gimple_seq
*pre_p
)
7563 tree expr
= *expr_p
;
7567 switch (TREE_CODE (expr
))
7569 case OACC_ENTER_DATA
:
7570 kind
= GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
;
7572 case OACC_EXIT_DATA
:
7573 kind
= GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
;
7576 kind
= GF_OMP_TARGET_KIND_OACC_UPDATE
;
7578 case OMP_TARGET_UPDATE
:
7579 kind
= GF_OMP_TARGET_KIND_UPDATE
;
7584 gimplify_scan_omp_clauses (&OMP_STANDALONE_CLAUSES (expr
), pre_p
,
7586 gimplify_adjust_omp_clauses (pre_p
, &OMP_STANDALONE_CLAUSES (expr
));
7587 stmt
= gimple_build_omp_target (NULL
, kind
, OMP_STANDALONE_CLAUSES (expr
));
7589 gimplify_seq_add_stmt (pre_p
, stmt
);
7590 *expr_p
= NULL_TREE
;
7593 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
7594 stabilized the lhs of the atomic operation as *ADDR. Return true if
7595 EXPR is this stabilized form. */
7598 goa_lhs_expr_p (tree expr
, tree addr
)
7600 /* Also include casts to other type variants. The C front end is fond
7601 of adding these for e.g. volatile variables. This is like
7602 STRIP_TYPE_NOPS but includes the main variant lookup. */
7603 STRIP_USELESS_TYPE_CONVERSION (expr
);
7605 if (TREE_CODE (expr
) == INDIRECT_REF
)
7607 expr
= TREE_OPERAND (expr
, 0);
7609 && (CONVERT_EXPR_P (expr
)
7610 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
7611 && TREE_CODE (expr
) == TREE_CODE (addr
)
7612 && types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (addr
)))
7614 expr
= TREE_OPERAND (expr
, 0);
7615 addr
= TREE_OPERAND (addr
, 0);
7619 return (TREE_CODE (addr
) == ADDR_EXPR
7620 && TREE_CODE (expr
) == ADDR_EXPR
7621 && TREE_OPERAND (addr
, 0) == TREE_OPERAND (expr
, 0));
7623 if (TREE_CODE (addr
) == ADDR_EXPR
&& expr
== TREE_OPERAND (addr
, 0))
7628 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
7629 expression does not involve the lhs, evaluate it into a temporary.
7630 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
7631 or -1 if an error was encountered. */
7634 goa_stabilize_expr (tree
*expr_p
, gimple_seq
*pre_p
, tree lhs_addr
,
7637 tree expr
= *expr_p
;
7640 if (goa_lhs_expr_p (expr
, lhs_addr
))
7645 if (is_gimple_val (expr
))
7649 switch (TREE_CODE_CLASS (TREE_CODE (expr
)))
7652 case tcc_comparison
:
7653 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
, lhs_addr
,
7656 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
, lhs_addr
,
7659 case tcc_expression
:
7660 switch (TREE_CODE (expr
))
7662 case TRUTH_ANDIF_EXPR
:
7663 case TRUTH_ORIF_EXPR
:
7664 case TRUTH_AND_EXPR
:
7666 case TRUTH_XOR_EXPR
:
7667 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
,
7669 case TRUTH_NOT_EXPR
:
7670 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
7674 /* Break out any preevaluations from cp_build_modify_expr. */
7675 for (; TREE_CODE (expr
) == COMPOUND_EXPR
;
7676 expr
= TREE_OPERAND (expr
, 1))
7677 gimplify_stmt (&TREE_OPERAND (expr
, 0), pre_p
);
7679 return goa_stabilize_expr (expr_p
, pre_p
, lhs_addr
, lhs_var
);
7690 enum gimplify_status gs
;
7691 gs
= gimplify_expr (expr_p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
7692 if (gs
!= GS_ALL_DONE
)
7699 /* Gimplify an OMP_ATOMIC statement. */
7701 static enum gimplify_status
7702 gimplify_omp_atomic (tree
*expr_p
, gimple_seq
*pre_p
)
7704 tree addr
= TREE_OPERAND (*expr_p
, 0);
7705 tree rhs
= TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
7706 ? NULL
: TREE_OPERAND (*expr_p
, 1);
7707 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
7709 gomp_atomic_load
*loadstmt
;
7710 gomp_atomic_store
*storestmt
;
7712 tmp_load
= create_tmp_reg (type
);
7713 if (rhs
&& goa_stabilize_expr (&rhs
, pre_p
, addr
, tmp_load
) < 0)
7716 if (gimplify_expr (&addr
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7720 loadstmt
= gimple_build_omp_atomic_load (tmp_load
, addr
);
7721 gimplify_seq_add_stmt (pre_p
, loadstmt
);
7722 if (rhs
&& gimplify_expr (&rhs
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7726 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
)
7728 storestmt
= gimple_build_omp_atomic_store (rhs
);
7729 gimplify_seq_add_stmt (pre_p
, storestmt
);
7730 if (OMP_ATOMIC_SEQ_CST (*expr_p
))
7732 gimple_omp_atomic_set_seq_cst (loadstmt
);
7733 gimple_omp_atomic_set_seq_cst (storestmt
);
7735 switch (TREE_CODE (*expr_p
))
7737 case OMP_ATOMIC_READ
:
7738 case OMP_ATOMIC_CAPTURE_OLD
:
7740 gimple_omp_atomic_set_need_value (loadstmt
);
7742 case OMP_ATOMIC_CAPTURE_NEW
:
7744 gimple_omp_atomic_set_need_value (storestmt
);
7754 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
7755 body, and adding some EH bits. */
7757 static enum gimplify_status
7758 gimplify_transaction (tree
*expr_p
, gimple_seq
*pre_p
)
7760 tree expr
= *expr_p
, temp
, tbody
= TRANSACTION_EXPR_BODY (expr
);
7762 gtransaction
*trans_stmt
;
7763 gimple_seq body
= NULL
;
7766 /* Wrap the transaction body in a BIND_EXPR so we have a context
7767 where to put decls for OMP. */
7768 if (TREE_CODE (tbody
) != BIND_EXPR
)
7770 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, tbody
, NULL
);
7771 TREE_SIDE_EFFECTS (bind
) = 1;
7772 SET_EXPR_LOCATION (bind
, EXPR_LOCATION (tbody
));
7773 TRANSACTION_EXPR_BODY (expr
) = bind
;
7776 push_gimplify_context ();
7777 temp
= voidify_wrapper_expr (*expr_p
, NULL
);
7779 body_stmt
= gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr
), &body
);
7780 pop_gimplify_context (body_stmt
);
7782 trans_stmt
= gimple_build_transaction (body
, NULL
);
7783 if (TRANSACTION_EXPR_OUTER (expr
))
7784 subcode
= GTMA_IS_OUTER
;
7785 else if (TRANSACTION_EXPR_RELAXED (expr
))
7786 subcode
= GTMA_IS_RELAXED
;
7787 gimple_transaction_set_subcode (trans_stmt
, subcode
);
7789 gimplify_seq_add_stmt (pre_p
, trans_stmt
);
7797 *expr_p
= NULL_TREE
;
7801 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
7802 expression produces a value to be used as an operand inside a GIMPLE
7803 statement, the value will be stored back in *EXPR_P. This value will
7804 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
7805 an SSA_NAME. The corresponding sequence of GIMPLE statements is
7806 emitted in PRE_P and POST_P.
7808 Additionally, this process may overwrite parts of the input
7809 expression during gimplification. Ideally, it should be
7810 possible to do non-destructive gimplification.
7812 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
7813 the expression needs to evaluate to a value to be used as
7814 an operand in a GIMPLE statement, this value will be stored in
7815 *EXPR_P on exit. This happens when the caller specifies one
7816 of fb_lvalue or fb_rvalue fallback flags.
7818 PRE_P will contain the sequence of GIMPLE statements corresponding
7819 to the evaluation of EXPR and all the side-effects that must
7820 be executed before the main expression. On exit, the last
7821 statement of PRE_P is the core statement being gimplified. For
7822 instance, when gimplifying 'if (++a)' the last statement in
7823 PRE_P will be 'if (t.1)' where t.1 is the result of
7824 pre-incrementing 'a'.
7826 POST_P will contain the sequence of GIMPLE statements corresponding
7827 to the evaluation of all the side-effects that must be executed
7828 after the main expression. If this is NULL, the post
7829 side-effects are stored at the end of PRE_P.
7831 The reason why the output is split in two is to handle post
7832 side-effects explicitly. In some cases, an expression may have
7833 inner and outer post side-effects which need to be emitted in
7834 an order different from the one given by the recursive
7835 traversal. For instance, for the expression (*p--)++ the post
7836 side-effects of '--' must actually occur *after* the post
7837 side-effects of '++'. However, gimplification will first visit
7838 the inner expression, so if a separate POST sequence was not
7839 used, the resulting sequence would be:
7846 However, the post-decrement operation in line #2 must not be
7847 evaluated until after the store to *p at line #4, so the
7848 correct sequence should be:
7855 So, by specifying a separate post queue, it is possible
7856 to emit the post side-effects in the correct order.
7857 If POST_P is NULL, an internal queue will be used. Before
7858 returning to the caller, the sequence POST_P is appended to
7859 the main output sequence PRE_P.
7861 GIMPLE_TEST_F points to a function that takes a tree T and
7862 returns nonzero if T is in the GIMPLE form requested by the
7863 caller. The GIMPLE predicates are in gimple.c.
7865 FALLBACK tells the function what sort of a temporary we want if
7866 gimplification cannot produce an expression that complies with
7869 fb_none means that no temporary should be generated
7870 fb_rvalue means that an rvalue is OK to generate
7871 fb_lvalue means that an lvalue is OK to generate
7872 fb_either means that either is OK, but an lvalue is preferable.
7873 fb_mayfail means that gimplification may fail (in which case
7874 GS_ERROR will be returned)
7876 The return value is either GS_ERROR or GS_ALL_DONE, since this
7877 function iterates until EXPR is completely gimplified or an error
7880 enum gimplify_status
7881 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
7882 bool (*gimple_test_f
) (tree
), fallback_t fallback
)
7885 gimple_seq internal_pre
= NULL
;
7886 gimple_seq internal_post
= NULL
;
7889 location_t saved_location
;
7890 enum gimplify_status ret
;
7891 gimple_stmt_iterator pre_last_gsi
, post_last_gsi
;
7893 save_expr
= *expr_p
;
7894 if (save_expr
== NULL_TREE
)
7897 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
7898 is_statement
= gimple_test_f
== is_gimple_stmt
;
7902 /* Consistency checks. */
7903 if (gimple_test_f
== is_gimple_reg
)
7904 gcc_assert (fallback
& (fb_rvalue
| fb_lvalue
));
7905 else if (gimple_test_f
== is_gimple_val
7906 || gimple_test_f
== is_gimple_call_addr
7907 || gimple_test_f
== is_gimple_condexpr
7908 || gimple_test_f
== is_gimple_mem_rhs
7909 || gimple_test_f
== is_gimple_mem_rhs_or_call
7910 || gimple_test_f
== is_gimple_reg_rhs
7911 || gimple_test_f
== is_gimple_reg_rhs_or_call
7912 || gimple_test_f
== is_gimple_asm_val
7913 || gimple_test_f
== is_gimple_mem_ref_addr
)
7914 gcc_assert (fallback
& fb_rvalue
);
7915 else if (gimple_test_f
== is_gimple_min_lval
7916 || gimple_test_f
== is_gimple_lvalue
)
7917 gcc_assert (fallback
& fb_lvalue
);
7918 else if (gimple_test_f
== is_gimple_addressable
)
7919 gcc_assert (fallback
& fb_either
);
7920 else if (gimple_test_f
== is_gimple_stmt
)
7921 gcc_assert (fallback
== fb_none
);
7924 /* We should have recognized the GIMPLE_TEST_F predicate to
7925 know what kind of fallback to use in case a temporary is
7926 needed to hold the value or address of *EXPR_P. */
7930 /* We used to check the predicate here and return immediately if it
7931 succeeds. This is wrong; the design is for gimplification to be
7932 idempotent, and for the predicates to only test for valid forms, not
7933 whether they are fully simplified. */
7935 pre_p
= &internal_pre
;
7938 post_p
= &internal_post
;
7940 /* Remember the last statements added to PRE_P and POST_P. Every
7941 new statement added by the gimplification helpers needs to be
7942 annotated with location information. To centralize the
7943 responsibility, we remember the last statement that had been
7944 added to both queues before gimplifying *EXPR_P. If
7945 gimplification produces new statements in PRE_P and POST_P, those
7946 statements will be annotated with the same location information
7948 pre_last_gsi
= gsi_last (*pre_p
);
7949 post_last_gsi
= gsi_last (*post_p
);
7951 saved_location
= input_location
;
7952 if (save_expr
!= error_mark_node
7953 && EXPR_HAS_LOCATION (*expr_p
))
7954 input_location
= EXPR_LOCATION (*expr_p
);
7956 /* Loop over the specific gimplifiers until the toplevel node
7957 remains the same. */
7960 /* Strip away as many useless type conversions as possible
7962 STRIP_USELESS_TYPE_CONVERSION (*expr_p
);
7964 /* Remember the expr. */
7965 save_expr
= *expr_p
;
7967 /* Die, die, die, my darling. */
7968 if (save_expr
== error_mark_node
7969 || (TREE_TYPE (save_expr
)
7970 && TREE_TYPE (save_expr
) == error_mark_node
))
7976 /* Do any language-specific gimplification. */
7977 ret
= ((enum gimplify_status
)
7978 lang_hooks
.gimplify_expr (expr_p
, pre_p
, post_p
));
7981 if (*expr_p
== NULL_TREE
)
7983 if (*expr_p
!= save_expr
)
7986 else if (ret
!= GS_UNHANDLED
)
7989 /* Make sure that all the cases set 'ret' appropriately. */
7991 switch (TREE_CODE (*expr_p
))
7993 /* First deal with the special cases. */
7995 case POSTINCREMENT_EXPR
:
7996 case POSTDECREMENT_EXPR
:
7997 case PREINCREMENT_EXPR
:
7998 case PREDECREMENT_EXPR
:
7999 ret
= gimplify_self_mod_expr (expr_p
, pre_p
, post_p
,
8000 fallback
!= fb_none
,
8001 TREE_TYPE (*expr_p
));
8004 case VIEW_CONVERT_EXPR
:
8005 if (is_gimple_reg_type (TREE_TYPE (*expr_p
))
8006 && is_gimple_reg_type (TREE_TYPE (TREE_OPERAND (*expr_p
, 0))))
8008 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8009 post_p
, is_gimple_val
, fb_rvalue
);
8010 recalculate_side_effects (*expr_p
);
8016 case ARRAY_RANGE_REF
:
8020 ret
= gimplify_compound_lval (expr_p
, pre_p
, post_p
,
8021 fallback
? fallback
: fb_rvalue
);
8025 ret
= gimplify_cond_expr (expr_p
, pre_p
, fallback
);
8027 /* C99 code may assign to an array in a structure value of a
8028 conditional expression, and this has undefined behavior
8029 only on execution, so create a temporary if an lvalue is
8031 if (fallback
== fb_lvalue
)
8033 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
8034 mark_addressable (*expr_p
);
8040 ret
= gimplify_call_expr (expr_p
, pre_p
, fallback
!= fb_none
);
8042 /* C99 code may assign to an array in a structure returned
8043 from a function, and this has undefined behavior only on
8044 execution, so create a temporary if an lvalue is
8046 if (fallback
== fb_lvalue
)
8048 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
8049 mark_addressable (*expr_p
);
8058 ret
= gimplify_compound_expr (expr_p
, pre_p
, fallback
!= fb_none
);
8061 case COMPOUND_LITERAL_EXPR
:
8062 ret
= gimplify_compound_literal_expr (expr_p
, pre_p
,
8063 gimple_test_f
, fallback
);
8068 ret
= gimplify_modify_expr (expr_p
, pre_p
, post_p
,
8069 fallback
!= fb_none
);
8072 case TRUTH_ANDIF_EXPR
:
8073 case TRUTH_ORIF_EXPR
:
8075 /* Preserve the original type of the expression and the
8076 source location of the outer expression. */
8077 tree org_type
= TREE_TYPE (*expr_p
);
8078 *expr_p
= gimple_boolify (*expr_p
);
8079 *expr_p
= build3_loc (input_location
, COND_EXPR
,
8083 org_type
, boolean_true_node
),
8086 org_type
, boolean_false_node
));
8091 case TRUTH_NOT_EXPR
:
8093 tree type
= TREE_TYPE (*expr_p
);
8094 /* The parsers are careful to generate TRUTH_NOT_EXPR
8095 only with operands that are always zero or one.
8096 We do not fold here but handle the only interesting case
8097 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
8098 *expr_p
= gimple_boolify (*expr_p
);
8099 if (TYPE_PRECISION (TREE_TYPE (*expr_p
)) == 1)
8100 *expr_p
= build1_loc (input_location
, BIT_NOT_EXPR
,
8101 TREE_TYPE (*expr_p
),
8102 TREE_OPERAND (*expr_p
, 0));
8104 *expr_p
= build2_loc (input_location
, BIT_XOR_EXPR
,
8105 TREE_TYPE (*expr_p
),
8106 TREE_OPERAND (*expr_p
, 0),
8107 build_int_cst (TREE_TYPE (*expr_p
), 1));
8108 if (!useless_type_conversion_p (type
, TREE_TYPE (*expr_p
)))
8109 *expr_p
= fold_convert_loc (input_location
, type
, *expr_p
);
8115 ret
= gimplify_addr_expr (expr_p
, pre_p
, post_p
);
8120 tree cond
= TREE_OPERAND (*expr_p
, 0);
8121 tree kind
= TREE_OPERAND (*expr_p
, 1);
8122 tree type
= TREE_TYPE (cond
);
8123 if (!INTEGRAL_TYPE_P (type
))
8129 tree tmp
= create_tmp_var (type
);
8130 gimplify_arg (&cond
, pre_p
, EXPR_LOCATION (*expr_p
));
8132 = gimple_build_call_internal (IFN_ANNOTATE
, 2, cond
, kind
);
8133 gimple_call_set_lhs (call
, tmp
);
8134 gimplify_seq_add_stmt (pre_p
, call
);
8141 ret
= gimplify_va_arg_expr (expr_p
, pre_p
, post_p
);
8145 if (IS_EMPTY_STMT (*expr_p
))
8151 if (VOID_TYPE_P (TREE_TYPE (*expr_p
))
8152 || fallback
== fb_none
)
8154 /* Just strip a conversion to void (or in void context) and
8156 *expr_p
= TREE_OPERAND (*expr_p
, 0);
8161 ret
= gimplify_conversion (expr_p
);
8162 if (ret
== GS_ERROR
)
8164 if (*expr_p
!= save_expr
)
8168 case FIX_TRUNC_EXPR
:
8169 /* unary_expr: ... | '(' cast ')' val | ... */
8170 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8171 is_gimple_val
, fb_rvalue
);
8172 recalculate_side_effects (*expr_p
);
8177 bool volatilep
= TREE_THIS_VOLATILE (*expr_p
);
8178 bool notrap
= TREE_THIS_NOTRAP (*expr_p
);
8179 tree saved_ptr_type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 0));
8181 *expr_p
= fold_indirect_ref_loc (input_location
, *expr_p
);
8182 if (*expr_p
!= save_expr
)
8188 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8189 is_gimple_reg
, fb_rvalue
);
8190 if (ret
== GS_ERROR
)
8193 recalculate_side_effects (*expr_p
);
8194 *expr_p
= fold_build2_loc (input_location
, MEM_REF
,
8195 TREE_TYPE (*expr_p
),
8196 TREE_OPERAND (*expr_p
, 0),
8197 build_int_cst (saved_ptr_type
, 0));
8198 TREE_THIS_VOLATILE (*expr_p
) = volatilep
;
8199 TREE_THIS_NOTRAP (*expr_p
) = notrap
;
8204 /* We arrive here through the various re-gimplifcation paths. */
8206 /* First try re-folding the whole thing. */
8207 tmp
= fold_binary (MEM_REF
, TREE_TYPE (*expr_p
),
8208 TREE_OPERAND (*expr_p
, 0),
8209 TREE_OPERAND (*expr_p
, 1));
8213 recalculate_side_effects (*expr_p
);
8217 /* Avoid re-gimplifying the address operand if it is already
8218 in suitable form. Re-gimplifying would mark the address
8219 operand addressable. Always gimplify when not in SSA form
8220 as we still may have to gimplify decls with value-exprs. */
8221 if (!gimplify_ctxp
|| !gimplify_ctxp
->into_ssa
8222 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p
, 0)))
8224 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8225 is_gimple_mem_ref_addr
, fb_rvalue
);
8226 if (ret
== GS_ERROR
)
8229 recalculate_side_effects (*expr_p
);
8233 /* Constants need not be gimplified. */
8240 /* Drop the overflow flag on constants, we do not want
8241 that in the GIMPLE IL. */
8242 if (TREE_OVERFLOW_P (*expr_p
))
8243 *expr_p
= drop_tree_overflow (*expr_p
);
8248 /* If we require an lvalue, such as for ADDR_EXPR, retain the
8249 CONST_DECL node. Otherwise the decl is replaceable by its
8251 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
8252 if (fallback
& fb_lvalue
)
8256 *expr_p
= DECL_INITIAL (*expr_p
);
8262 ret
= gimplify_decl_expr (expr_p
, pre_p
);
8266 ret
= gimplify_bind_expr (expr_p
, pre_p
);
8270 ret
= gimplify_loop_expr (expr_p
, pre_p
);
8274 ret
= gimplify_switch_expr (expr_p
, pre_p
);
8278 ret
= gimplify_exit_expr (expr_p
);
8282 /* If the target is not LABEL, then it is a computed jump
8283 and the target needs to be gimplified. */
8284 if (TREE_CODE (GOTO_DESTINATION (*expr_p
)) != LABEL_DECL
)
8286 ret
= gimplify_expr (&GOTO_DESTINATION (*expr_p
), pre_p
,
8287 NULL
, is_gimple_val
, fb_rvalue
);
8288 if (ret
== GS_ERROR
)
8291 gimplify_seq_add_stmt (pre_p
,
8292 gimple_build_goto (GOTO_DESTINATION (*expr_p
)));
8297 gimplify_seq_add_stmt (pre_p
,
8298 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p
),
8299 PREDICT_EXPR_OUTCOME (*expr_p
)));
8305 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p
))
8306 == current_function_decl
);
8307 gimplify_seq_add_stmt (pre_p
,
8308 gimple_build_label (LABEL_EXPR_LABEL (*expr_p
)));
8311 case CASE_LABEL_EXPR
:
8312 ret
= gimplify_case_label_expr (expr_p
, pre_p
);
8316 ret
= gimplify_return_expr (*expr_p
, pre_p
);
8320 /* Don't reduce this in place; let gimplify_init_constructor work its
8321 magic. Buf if we're just elaborating this for side effects, just
8322 gimplify any element that has side-effects. */
8323 if (fallback
== fb_none
)
8325 unsigned HOST_WIDE_INT ix
;
8327 tree temp
= NULL_TREE
;
8328 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p
), ix
, val
)
8329 if (TREE_SIDE_EFFECTS (val
))
8330 append_to_statement_list (val
, &temp
);
8333 ret
= temp
? GS_OK
: GS_ALL_DONE
;
8335 /* C99 code may assign to an array in a constructed
8336 structure or union, and this has undefined behavior only
8337 on execution, so create a temporary if an lvalue is
8339 else if (fallback
== fb_lvalue
)
8341 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
8342 mark_addressable (*expr_p
);
8349 /* The following are special cases that are not handled by the
8350 original GIMPLE grammar. */
8352 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
8355 ret
= gimplify_save_expr (expr_p
, pre_p
, post_p
);
8359 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8360 post_p
, is_gimple_lvalue
, fb_either
);
8361 recalculate_side_effects (*expr_p
);
8364 case TARGET_MEM_REF
:
8366 enum gimplify_status r0
= GS_ALL_DONE
, r1
= GS_ALL_DONE
;
8368 if (TMR_BASE (*expr_p
))
8369 r0
= gimplify_expr (&TMR_BASE (*expr_p
), pre_p
,
8370 post_p
, is_gimple_mem_ref_addr
, fb_either
);
8371 if (TMR_INDEX (*expr_p
))
8372 r1
= gimplify_expr (&TMR_INDEX (*expr_p
), pre_p
,
8373 post_p
, is_gimple_val
, fb_rvalue
);
8374 if (TMR_INDEX2 (*expr_p
))
8375 r1
= gimplify_expr (&TMR_INDEX2 (*expr_p
), pre_p
,
8376 post_p
, is_gimple_val
, fb_rvalue
);
8377 /* TMR_STEP and TMR_OFFSET are always integer constants. */
8382 case NON_LVALUE_EXPR
:
8383 /* This should have been stripped above. */
8387 ret
= gimplify_asm_expr (expr_p
, pre_p
, post_p
);
8390 case TRY_FINALLY_EXPR
:
8391 case TRY_CATCH_EXPR
:
8393 gimple_seq eval
, cleanup
;
8396 /* Calls to destructors are generated automatically in FINALLY/CATCH
8397 block. They should have location as UNKNOWN_LOCATION. However,
8398 gimplify_call_expr will reset these call stmts to input_location
8399 if it finds stmt's location is unknown. To prevent resetting for
8400 destructors, we set the input_location to unknown.
8401 Note that this only affects the destructor calls in FINALLY/CATCH
8402 block, and will automatically reset to its original value by the
8403 end of gimplify_expr. */
8404 input_location
= UNKNOWN_LOCATION
;
8405 eval
= cleanup
= NULL
;
8406 gimplify_and_add (TREE_OPERAND (*expr_p
, 0), &eval
);
8407 gimplify_and_add (TREE_OPERAND (*expr_p
, 1), &cleanup
);
8408 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
8409 if (gimple_seq_empty_p (cleanup
))
8411 gimple_seq_add_seq (pre_p
, eval
);
8415 try_
= gimple_build_try (eval
, cleanup
,
8416 TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
8417 ? GIMPLE_TRY_FINALLY
8418 : GIMPLE_TRY_CATCH
);
8419 if (EXPR_HAS_LOCATION (save_expr
))
8420 gimple_set_location (try_
, EXPR_LOCATION (save_expr
));
8421 else if (LOCATION_LOCUS (saved_location
) != UNKNOWN_LOCATION
)
8422 gimple_set_location (try_
, saved_location
);
8423 if (TREE_CODE (*expr_p
) == TRY_CATCH_EXPR
)
8424 gimple_try_set_catch_is_cleanup (try_
,
8425 TRY_CATCH_IS_CLEANUP (*expr_p
));
8426 gimplify_seq_add_stmt (pre_p
, try_
);
8431 case CLEANUP_POINT_EXPR
:
8432 ret
= gimplify_cleanup_point_expr (expr_p
, pre_p
);
8436 ret
= gimplify_target_expr (expr_p
, pre_p
, post_p
);
8442 gimple_seq handler
= NULL
;
8443 gimplify_and_add (CATCH_BODY (*expr_p
), &handler
);
8444 c
= gimple_build_catch (CATCH_TYPES (*expr_p
), handler
);
8445 gimplify_seq_add_stmt (pre_p
, c
);
8450 case EH_FILTER_EXPR
:
8453 gimple_seq failure
= NULL
;
8455 gimplify_and_add (EH_FILTER_FAILURE (*expr_p
), &failure
);
8456 ehf
= gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p
), failure
);
8457 gimple_set_no_warning (ehf
, TREE_NO_WARNING (*expr_p
));
8458 gimplify_seq_add_stmt (pre_p
, ehf
);
8465 enum gimplify_status r0
, r1
;
8466 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
,
8467 post_p
, is_gimple_val
, fb_rvalue
);
8468 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
,
8469 post_p
, is_gimple_val
, fb_rvalue
);
8470 TREE_SIDE_EFFECTS (*expr_p
) = 0;
8476 /* We get here when taking the address of a label. We mark
8477 the label as "forced"; meaning it can never be removed and
8478 it is a potential target for any computed goto. */
8479 FORCED_LABEL (*expr_p
) = 1;
8483 case STATEMENT_LIST
:
8484 ret
= gimplify_statement_list (expr_p
, pre_p
);
8487 case WITH_SIZE_EXPR
:
8489 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8490 post_p
== &internal_post
? NULL
: post_p
,
8491 gimple_test_f
, fallback
);
8492 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
8493 is_gimple_val
, fb_rvalue
);
8500 ret
= gimplify_var_or_parm_decl (expr_p
);
8504 /* When within an OMP context, notice uses of variables. */
8505 if (gimplify_omp_ctxp
)
8506 omp_notice_variable (gimplify_omp_ctxp
, *expr_p
, true);
8511 /* Allow callbacks into the gimplifier during optimization. */
8516 gimplify_omp_parallel (expr_p
, pre_p
);
8521 gimplify_omp_task (expr_p
, pre_p
);
8529 case OMP_DISTRIBUTE
:
8531 ret
= gimplify_omp_for (expr_p
, pre_p
);
8535 gimplify_oacc_cache (expr_p
, pre_p
);
8539 case OACC_HOST_DATA
:
8541 sorry ("directive not yet implemented");
8546 if (OACC_KERNELS_COMBINED (*expr_p
))
8547 sorry ("directive not yet implemented");
8549 gimplify_omp_workshare (expr_p
, pre_p
);
8554 if (OACC_PARALLEL_COMBINED (*expr_p
))
8555 sorry ("directive not yet implemented");
8557 gimplify_omp_workshare (expr_p
, pre_p
);
8565 case OMP_TARGET_DATA
:
8567 gimplify_omp_workshare (expr_p
, pre_p
);
8571 case OACC_ENTER_DATA
:
8572 case OACC_EXIT_DATA
:
8574 case OMP_TARGET_UPDATE
:
8575 gimplify_omp_target_update (expr_p
, pre_p
);
8585 gimple_seq body
= NULL
;
8588 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
8589 switch (TREE_CODE (*expr_p
))
8592 g
= gimple_build_omp_section (body
);
8595 g
= gimple_build_omp_master (body
);
8599 gimple_seq cleanup
= NULL
;
8601 = builtin_decl_explicit (BUILT_IN_GOMP_TASKGROUP_END
);
8602 g
= gimple_build_call (fn
, 0);
8603 gimple_seq_add_stmt (&cleanup
, g
);
8604 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
8606 gimple_seq_add_stmt (&body
, g
);
8607 g
= gimple_build_omp_taskgroup (body
);
8611 g
= gimple_build_omp_ordered (body
);
8614 g
= gimple_build_omp_critical (body
,
8615 OMP_CRITICAL_NAME (*expr_p
));
8620 gimplify_seq_add_stmt (pre_p
, g
);
8626 case OMP_ATOMIC_READ
:
8627 case OMP_ATOMIC_CAPTURE_OLD
:
8628 case OMP_ATOMIC_CAPTURE_NEW
:
8629 ret
= gimplify_omp_atomic (expr_p
, pre_p
);
8632 case TRANSACTION_EXPR
:
8633 ret
= gimplify_transaction (expr_p
, pre_p
);
8636 case TRUTH_AND_EXPR
:
8638 case TRUTH_XOR_EXPR
:
8640 tree orig_type
= TREE_TYPE (*expr_p
);
8641 tree new_type
, xop0
, xop1
;
8642 *expr_p
= gimple_boolify (*expr_p
);
8643 new_type
= TREE_TYPE (*expr_p
);
8644 if (!useless_type_conversion_p (orig_type
, new_type
))
8646 *expr_p
= fold_convert_loc (input_location
, orig_type
, *expr_p
);
8651 /* Boolified binary truth expressions are semantically equivalent
8652 to bitwise binary expressions. Canonicalize them to the
8654 switch (TREE_CODE (*expr_p
))
8656 case TRUTH_AND_EXPR
:
8657 TREE_SET_CODE (*expr_p
, BIT_AND_EXPR
);
8660 TREE_SET_CODE (*expr_p
, BIT_IOR_EXPR
);
8662 case TRUTH_XOR_EXPR
:
8663 TREE_SET_CODE (*expr_p
, BIT_XOR_EXPR
);
8668 /* Now make sure that operands have compatible type to
8669 expression's new_type. */
8670 xop0
= TREE_OPERAND (*expr_p
, 0);
8671 xop1
= TREE_OPERAND (*expr_p
, 1);
8672 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop0
)))
8673 TREE_OPERAND (*expr_p
, 0) = fold_convert_loc (input_location
,
8676 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop1
)))
8677 TREE_OPERAND (*expr_p
, 1) = fold_convert_loc (input_location
,
8680 /* Continue classified as tcc_binary. */
8687 /* Classified as tcc_expression. */
8690 case POINTER_PLUS_EXPR
:
8692 enum gimplify_status r0
, r1
;
8693 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8694 post_p
, is_gimple_val
, fb_rvalue
);
8695 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
8696 post_p
, is_gimple_val
, fb_rvalue
);
8697 recalculate_side_effects (*expr_p
);
8702 case CILK_SYNC_STMT
:
8704 if (!fn_contains_cilk_spawn_p (cfun
))
8706 error_at (EXPR_LOCATION (*expr_p
),
8707 "expected %<_Cilk_spawn%> before %<_Cilk_sync%>");
8712 gimplify_cilk_sync (expr_p
, pre_p
);
8719 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p
)))
8721 case tcc_comparison
:
8722 /* Handle comparison of objects of non scalar mode aggregates
8723 with a call to memcmp. It would be nice to only have to do
8724 this for variable-sized objects, but then we'd have to allow
8725 the same nest of reference nodes we allow for MODIFY_EXPR and
8728 Compare scalar mode aggregates as scalar mode values. Using
8729 memcmp for them would be very inefficient at best, and is
8730 plain wrong if bitfields are involved. */
8732 tree type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 1));
8734 /* Vector comparisons need no boolification. */
8735 if (TREE_CODE (type
) == VECTOR_TYPE
)
8737 else if (!AGGREGATE_TYPE_P (type
))
8739 tree org_type
= TREE_TYPE (*expr_p
);
8740 *expr_p
= gimple_boolify (*expr_p
);
8741 if (!useless_type_conversion_p (org_type
,
8742 TREE_TYPE (*expr_p
)))
8744 *expr_p
= fold_convert_loc (input_location
,
8751 else if (TYPE_MODE (type
) != BLKmode
)
8752 ret
= gimplify_scalar_mode_aggregate_compare (expr_p
);
8754 ret
= gimplify_variable_sized_compare (expr_p
);
8759 /* If *EXPR_P does not need to be special-cased, handle it
8760 according to its class. */
8762 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8763 post_p
, is_gimple_val
, fb_rvalue
);
8769 enum gimplify_status r0
, r1
;
8771 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8772 post_p
, is_gimple_val
, fb_rvalue
);
8773 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
8774 post_p
, is_gimple_val
, fb_rvalue
);
8782 enum gimplify_status r0
, r1
, r2
;
8784 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8785 post_p
, is_gimple_val
, fb_rvalue
);
8786 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
8787 post_p
, is_gimple_val
, fb_rvalue
);
8788 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
8789 post_p
, is_gimple_val
, fb_rvalue
);
8791 ret
= MIN (MIN (r0
, r1
), r2
);
8795 case tcc_declaration
:
8798 goto dont_recalculate
;
8804 recalculate_side_effects (*expr_p
);
8810 gcc_assert (*expr_p
|| ret
!= GS_OK
);
8812 while (ret
== GS_OK
);
8814 /* If we encountered an error_mark somewhere nested inside, either
8815 stub out the statement or propagate the error back out. */
8816 if (ret
== GS_ERROR
)
8823 /* This was only valid as a return value from the langhook, which
8824 we handled. Make sure it doesn't escape from any other context. */
8825 gcc_assert (ret
!= GS_UNHANDLED
);
8827 if (fallback
== fb_none
&& *expr_p
&& !is_gimple_stmt (*expr_p
))
8829 /* We aren't looking for a value, and we don't have a valid
8830 statement. If it doesn't have side-effects, throw it away. */
8831 if (!TREE_SIDE_EFFECTS (*expr_p
))
8833 else if (!TREE_THIS_VOLATILE (*expr_p
))
8835 /* This is probably a _REF that contains something nested that
8836 has side effects. Recurse through the operands to find it. */
8837 enum tree_code code
= TREE_CODE (*expr_p
);
8844 case VIEW_CONVERT_EXPR
:
8845 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8846 gimple_test_f
, fallback
);
8850 case ARRAY_RANGE_REF
:
8851 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8852 gimple_test_f
, fallback
);
8853 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
8854 gimple_test_f
, fallback
);
8858 /* Anything else with side-effects must be converted to
8859 a valid statement before we get here. */
8865 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p
))
8866 && TYPE_MODE (TREE_TYPE (*expr_p
)) != BLKmode
)
8868 /* Historically, the compiler has treated a bare reference
8869 to a non-BLKmode volatile lvalue as forcing a load. */
8870 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p
));
8872 /* Normally, we do not want to create a temporary for a
8873 TREE_ADDRESSABLE type because such a type should not be
8874 copied by bitwise-assignment. However, we make an
8875 exception here, as all we are doing here is ensuring that
8876 we read the bytes that make up the type. We use
8877 create_tmp_var_raw because create_tmp_var will abort when
8878 given a TREE_ADDRESSABLE type. */
8879 tree tmp
= create_tmp_var_raw (type
, "vol");
8880 gimple_add_tmp_var (tmp
);
8881 gimplify_assign (tmp
, *expr_p
, pre_p
);
8885 /* We can't do anything useful with a volatile reference to
8886 an incomplete type, so just throw it away. Likewise for
8887 a BLKmode type, since any implicit inner load should
8888 already have been turned into an explicit one by the
8889 gimplification process. */
8893 /* If we are gimplifying at the statement level, we're done. Tack
8894 everything together and return. */
8895 if (fallback
== fb_none
|| is_statement
)
8897 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
8898 it out for GC to reclaim it. */
8899 *expr_p
= NULL_TREE
;
8901 if (!gimple_seq_empty_p (internal_pre
)
8902 || !gimple_seq_empty_p (internal_post
))
8904 gimplify_seq_add_seq (&internal_pre
, internal_post
);
8905 gimplify_seq_add_seq (pre_p
, internal_pre
);
8908 /* The result of gimplifying *EXPR_P is going to be the last few
8909 statements in *PRE_P and *POST_P. Add location information
8910 to all the statements that were added by the gimplification
8912 if (!gimple_seq_empty_p (*pre_p
))
8913 annotate_all_with_location_after (*pre_p
, pre_last_gsi
, input_location
);
8915 if (!gimple_seq_empty_p (*post_p
))
8916 annotate_all_with_location_after (*post_p
, post_last_gsi
,
8922 #ifdef ENABLE_GIMPLE_CHECKING
8925 enum tree_code code
= TREE_CODE (*expr_p
);
8926 /* These expressions should already be in gimple IR form. */
8927 gcc_assert (code
!= MODIFY_EXPR
8929 && code
!= BIND_EXPR
8930 && code
!= CATCH_EXPR
8931 && (code
!= COND_EXPR
|| gimplify_ctxp
->allow_rhs_cond_expr
)
8932 && code
!= EH_FILTER_EXPR
8933 && code
!= GOTO_EXPR
8934 && code
!= LABEL_EXPR
8935 && code
!= LOOP_EXPR
8936 && code
!= SWITCH_EXPR
8937 && code
!= TRY_FINALLY_EXPR
8938 && code
!= OACC_PARALLEL
8939 && code
!= OACC_KERNELS
8940 && code
!= OACC_DATA
8941 && code
!= OACC_HOST_DATA
8942 && code
!= OACC_DECLARE
8943 && code
!= OACC_UPDATE
8944 && code
!= OACC_ENTER_DATA
8945 && code
!= OACC_EXIT_DATA
8946 && code
!= OACC_CACHE
8947 && code
!= OMP_CRITICAL
8949 && code
!= OACC_LOOP
8950 && code
!= OMP_MASTER
8951 && code
!= OMP_TASKGROUP
8952 && code
!= OMP_ORDERED
8953 && code
!= OMP_PARALLEL
8954 && code
!= OMP_SECTIONS
8955 && code
!= OMP_SECTION
8956 && code
!= OMP_SINGLE
);
8960 /* Otherwise we're gimplifying a subexpression, so the resulting
8961 value is interesting. If it's a valid operand that matches
8962 GIMPLE_TEST_F, we're done. Unless we are handling some
8963 post-effects internally; if that's the case, we need to copy into
8964 a temporary before adding the post-effects to POST_P. */
8965 if (gimple_seq_empty_p (internal_post
) && (*gimple_test_f
) (*expr_p
))
8968 /* Otherwise, we need to create a new temporary for the gimplified
8971 /* We can't return an lvalue if we have an internal postqueue. The
8972 object the lvalue refers to would (probably) be modified by the
8973 postqueue; we need to copy the value out first, which means an
8975 if ((fallback
& fb_lvalue
)
8976 && gimple_seq_empty_p (internal_post
)
8977 && is_gimple_addressable (*expr_p
))
8979 /* An lvalue will do. Take the address of the expression, store it
8980 in a temporary, and replace the expression with an INDIRECT_REF of
8982 tmp
= build_fold_addr_expr_loc (input_location
, *expr_p
);
8983 gimplify_expr (&tmp
, pre_p
, post_p
, is_gimple_reg
, fb_rvalue
);
8984 *expr_p
= build_simple_mem_ref (tmp
);
8986 else if ((fallback
& fb_rvalue
) && is_gimple_reg_rhs_or_call (*expr_p
))
8988 /* An rvalue will do. Assign the gimplified expression into a
8989 new temporary TMP and replace the original expression with
8990 TMP. First, make sure that the expression has a type so that
8991 it can be assigned into a temporary. */
8992 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p
)));
8993 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
8997 #ifdef ENABLE_GIMPLE_CHECKING
8998 if (!(fallback
& fb_mayfail
))
9000 fprintf (stderr
, "gimplification failed:\n");
9001 print_generic_expr (stderr
, *expr_p
, 0);
9002 debug_tree (*expr_p
);
9003 internal_error ("gimplification failed");
9006 gcc_assert (fallback
& fb_mayfail
);
9008 /* If this is an asm statement, and the user asked for the
9009 impossible, don't die. Fail and let gimplify_asm_expr
9015 /* Make sure the temporary matches our predicate. */
9016 gcc_assert ((*gimple_test_f
) (*expr_p
));
9018 if (!gimple_seq_empty_p (internal_post
))
9020 annotate_all_with_location (internal_post
, input_location
);
9021 gimplify_seq_add_seq (pre_p
, internal_post
);
9025 input_location
= saved_location
;
9029 /* Look through TYPE for variable-sized objects and gimplify each such
9030 size that we find. Add to LIST_P any statements generated. */
9033 gimplify_type_sizes (tree type
, gimple_seq
*list_p
)
9037 if (type
== NULL
|| type
== error_mark_node
)
9040 /* We first do the main variant, then copy into any other variants. */
9041 type
= TYPE_MAIN_VARIANT (type
);
9043 /* Avoid infinite recursion. */
9044 if (TYPE_SIZES_GIMPLIFIED (type
))
9047 TYPE_SIZES_GIMPLIFIED (type
) = 1;
9049 switch (TREE_CODE (type
))
9055 case FIXED_POINT_TYPE
:
9056 gimplify_one_sizepos (&TYPE_MIN_VALUE (type
), list_p
);
9057 gimplify_one_sizepos (&TYPE_MAX_VALUE (type
), list_p
);
9059 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
9061 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (type
);
9062 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (type
);
9067 /* These types may not have declarations, so handle them here. */
9068 gimplify_type_sizes (TREE_TYPE (type
), list_p
);
9069 gimplify_type_sizes (TYPE_DOMAIN (type
), list_p
);
9070 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
9071 with assigned stack slots, for -O1+ -g they should be tracked
9073 if (!(TYPE_NAME (type
)
9074 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
9075 && DECL_IGNORED_P (TYPE_NAME (type
)))
9076 && TYPE_DOMAIN (type
)
9077 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type
)))
9079 t
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
9080 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
9081 DECL_IGNORED_P (t
) = 0;
9082 t
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
9083 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
9084 DECL_IGNORED_P (t
) = 0;
9090 case QUAL_UNION_TYPE
:
9091 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
9092 if (TREE_CODE (field
) == FIELD_DECL
)
9094 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field
), list_p
);
9095 gimplify_one_sizepos (&DECL_SIZE (field
), list_p
);
9096 gimplify_one_sizepos (&DECL_SIZE_UNIT (field
), list_p
);
9097 gimplify_type_sizes (TREE_TYPE (field
), list_p
);
9102 case REFERENCE_TYPE
:
9103 /* We used to recurse on the pointed-to type here, which turned out to
9104 be incorrect because its definition might refer to variables not
9105 yet initialized at this point if a forward declaration is involved.
9107 It was actually useful for anonymous pointed-to types to ensure
9108 that the sizes evaluation dominates every possible later use of the
9109 values. Restricting to such types here would be safe since there
9110 is no possible forward declaration around, but would introduce an
9111 undesirable middle-end semantic to anonymity. We then defer to
9112 front-ends the responsibility of ensuring that the sizes are
9113 evaluated both early and late enough, e.g. by attaching artificial
9114 type declarations to the tree. */
9121 gimplify_one_sizepos (&TYPE_SIZE (type
), list_p
);
9122 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type
), list_p
);
9124 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
9126 TYPE_SIZE (t
) = TYPE_SIZE (type
);
9127 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (type
);
9128 TYPE_SIZES_GIMPLIFIED (t
) = 1;
9132 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
9133 a size or position, has had all of its SAVE_EXPRs evaluated.
9134 We add any required statements to *STMT_P. */
9137 gimplify_one_sizepos (tree
*expr_p
, gimple_seq
*stmt_p
)
9139 tree expr
= *expr_p
;
9141 /* We don't do anything if the value isn't there, is constant, or contains
9142 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
9143 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
9144 will want to replace it with a new variable, but that will cause problems
9145 if this type is from outside the function. It's OK to have that here. */
9146 if (is_gimple_sizepos (expr
))
9149 *expr_p
= unshare_expr (expr
);
9151 gimplify_expr (expr_p
, stmt_p
, NULL
, is_gimple_val
, fb_rvalue
);
9154 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
9155 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
9156 is true, also gimplify the parameters. */
9159 gimplify_body (tree fndecl
, bool do_parms
)
9161 location_t saved_location
= input_location
;
9162 gimple_seq parm_stmts
, seq
;
9165 struct cgraph_node
*cgn
;
9167 timevar_push (TV_TREE_GIMPLIFY
);
9169 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
9171 default_rtl_profile ();
9173 gcc_assert (gimplify_ctxp
== NULL
);
9174 push_gimplify_context ();
9176 if (flag_openacc
|| flag_openmp
)
9178 gcc_assert (gimplify_omp_ctxp
== NULL
);
9179 if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (fndecl
)))
9180 gimplify_omp_ctxp
= new_omp_context (ORT_TARGET
);
9183 /* Unshare most shared trees in the body and in that of any nested functions.
9184 It would seem we don't have to do this for nested functions because
9185 they are supposed to be output and then the outer function gimplified
9186 first, but the g++ front end doesn't always do it that way. */
9187 unshare_body (fndecl
);
9188 unvisit_body (fndecl
);
9190 cgn
= cgraph_node::get (fndecl
);
9191 if (cgn
&& cgn
->origin
)
9192 nonlocal_vlas
= new hash_set
<tree
>;
9194 /* Make sure input_location isn't set to something weird. */
9195 input_location
= DECL_SOURCE_LOCATION (fndecl
);
9197 /* Resolve callee-copies. This has to be done before processing
9198 the body so that DECL_VALUE_EXPR gets processed correctly. */
9199 parm_stmts
= do_parms
? gimplify_parameters () : NULL
;
9201 /* Gimplify the function's body. */
9203 gimplify_stmt (&DECL_SAVED_TREE (fndecl
), &seq
);
9204 outer_stmt
= gimple_seq_first_stmt (seq
);
9207 outer_stmt
= gimple_build_nop ();
9208 gimplify_seq_add_stmt (&seq
, outer_stmt
);
9211 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
9212 not the case, wrap everything in a GIMPLE_BIND to make it so. */
9213 if (gimple_code (outer_stmt
) == GIMPLE_BIND
9214 && gimple_seq_first (seq
) == gimple_seq_last (seq
))
9215 outer_bind
= as_a
<gbind
*> (outer_stmt
);
9217 outer_bind
= gimple_build_bind (NULL_TREE
, seq
, NULL
);
9219 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
9221 /* If we had callee-copies statements, insert them at the beginning
9222 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
9223 if (!gimple_seq_empty_p (parm_stmts
))
9227 gimplify_seq_add_seq (&parm_stmts
, gimple_bind_body (outer_bind
));
9228 gimple_bind_set_body (outer_bind
, parm_stmts
);
9230 for (parm
= DECL_ARGUMENTS (current_function_decl
);
9231 parm
; parm
= DECL_CHAIN (parm
))
9232 if (DECL_HAS_VALUE_EXPR_P (parm
))
9234 DECL_HAS_VALUE_EXPR_P (parm
) = 0;
9235 DECL_IGNORED_P (parm
) = 0;
9241 if (nonlocal_vla_vars
)
9243 /* tree-nested.c may later on call declare_vars (..., true);
9244 which relies on BLOCK_VARS chain to be the tail of the
9245 gimple_bind_vars chain. Ensure we don't violate that
9247 if (gimple_bind_block (outer_bind
)
9248 == DECL_INITIAL (current_function_decl
))
9249 declare_vars (nonlocal_vla_vars
, outer_bind
, true);
9251 BLOCK_VARS (DECL_INITIAL (current_function_decl
))
9252 = chainon (BLOCK_VARS (DECL_INITIAL (current_function_decl
)),
9254 nonlocal_vla_vars
= NULL_TREE
;
9256 delete nonlocal_vlas
;
9257 nonlocal_vlas
= NULL
;
9260 if ((flag_openacc
|| flag_openmp
|| flag_openmp_simd
)
9261 && gimplify_omp_ctxp
)
9263 delete_omp_context (gimplify_omp_ctxp
);
9264 gimplify_omp_ctxp
= NULL
;
9267 pop_gimplify_context (outer_bind
);
9268 gcc_assert (gimplify_ctxp
== NULL
);
9270 #ifdef ENABLE_CHECKING
9272 verify_gimple_in_seq (gimple_bind_body (outer_bind
));
9275 timevar_pop (TV_TREE_GIMPLIFY
);
9276 input_location
= saved_location
;
9281 typedef char *char_p
; /* For DEF_VEC_P. */
9283 /* Return whether we should exclude FNDECL from instrumentation. */
9286 flag_instrument_functions_exclude_p (tree fndecl
)
9290 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_functions
;
9291 if (v
&& v
->length () > 0)
9297 name
= lang_hooks
.decl_printable_name (fndecl
, 0);
9298 FOR_EACH_VEC_ELT (*v
, i
, s
)
9299 if (strstr (name
, s
) != NULL
)
9303 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_files
;
9304 if (v
&& v
->length () > 0)
9310 name
= DECL_SOURCE_FILE (fndecl
);
9311 FOR_EACH_VEC_ELT (*v
, i
, s
)
9312 if (strstr (name
, s
) != NULL
)
9319 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
9320 node for the function we want to gimplify.
9322 Return the sequence of GIMPLE statements corresponding to the body
9326 gimplify_function_tree (tree fndecl
)
9332 gcc_assert (!gimple_body (fndecl
));
9334 if (DECL_STRUCT_FUNCTION (fndecl
))
9335 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
9337 push_struct_function (fndecl
);
9339 /* Tentatively set PROP_gimple_lva here, and reset it in gimplify_va_arg_expr
9341 cfun
->curr_properties
|= PROP_gimple_lva
;
9343 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
9345 /* Preliminarily mark non-addressed complex variables as eligible
9346 for promotion to gimple registers. We'll transform their uses
9348 if ((TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
9349 || TREE_CODE (TREE_TYPE (parm
)) == VECTOR_TYPE
)
9350 && !TREE_THIS_VOLATILE (parm
)
9351 && !needs_to_live_in_memory (parm
))
9352 DECL_GIMPLE_REG_P (parm
) = 1;
9355 ret
= DECL_RESULT (fndecl
);
9356 if ((TREE_CODE (TREE_TYPE (ret
)) == COMPLEX_TYPE
9357 || TREE_CODE (TREE_TYPE (ret
)) == VECTOR_TYPE
)
9358 && !needs_to_live_in_memory (ret
))
9359 DECL_GIMPLE_REG_P (ret
) = 1;
9361 bind
= gimplify_body (fndecl
, true);
9363 /* The tree body of the function is no longer needed, replace it
9364 with the new GIMPLE body. */
9366 gimple_seq_add_stmt (&seq
, bind
);
9367 gimple_set_body (fndecl
, seq
);
9369 /* If we're instrumenting function entry/exit, then prepend the call to
9370 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
9371 catch the exit hook. */
9372 /* ??? Add some way to ignore exceptions for this TFE. */
9373 if (flag_instrument_function_entry_exit
9374 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
)
9375 && !flag_instrument_functions_exclude_p (fndecl
))
9380 gimple_seq cleanup
= NULL
, body
= NULL
;
9384 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
9385 call
= gimple_build_call (x
, 1, integer_zero_node
);
9386 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
9387 gimple_call_set_lhs (call
, tmp_var
);
9388 gimplify_seq_add_stmt (&cleanup
, call
);
9389 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT
);
9390 call
= gimple_build_call (x
, 2,
9391 build_fold_addr_expr (current_function_decl
),
9393 gimplify_seq_add_stmt (&cleanup
, call
);
9394 tf
= gimple_build_try (seq
, cleanup
, GIMPLE_TRY_FINALLY
);
9396 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
9397 call
= gimple_build_call (x
, 1, integer_zero_node
);
9398 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
9399 gimple_call_set_lhs (call
, tmp_var
);
9400 gimplify_seq_add_stmt (&body
, call
);
9401 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER
);
9402 call
= gimple_build_call (x
, 2,
9403 build_fold_addr_expr (current_function_decl
),
9405 gimplify_seq_add_stmt (&body
, call
);
9406 gimplify_seq_add_stmt (&body
, tf
);
9407 new_bind
= gimple_build_bind (NULL
, body
, gimple_bind_block (bind
));
9408 /* Clear the block for BIND, since it is no longer directly inside
9409 the function, but within a try block. */
9410 gimple_bind_set_block (bind
, NULL
);
9412 /* Replace the current function body with the body
9413 wrapped in the try/finally TF. */
9415 gimple_seq_add_stmt (&seq
, new_bind
);
9416 gimple_set_body (fndecl
, seq
);
9420 if ((flag_sanitize
& SANITIZE_THREAD
) != 0
9421 && !lookup_attribute ("no_sanitize_thread", DECL_ATTRIBUTES (fndecl
)))
9423 gcall
*call
= gimple_build_call_internal (IFN_TSAN_FUNC_EXIT
, 0);
9424 gimple tf
= gimple_build_try (seq
, call
, GIMPLE_TRY_FINALLY
);
9425 gbind
*new_bind
= gimple_build_bind (NULL
, tf
, gimple_bind_block (bind
));
9426 /* Clear the block for BIND, since it is no longer directly inside
9427 the function, but within a try block. */
9428 gimple_bind_set_block (bind
, NULL
);
9429 /* Replace the current function body with the body
9430 wrapped in the try/finally TF. */
9432 gimple_seq_add_stmt (&seq
, new_bind
);
9433 gimple_set_body (fndecl
, seq
);
9436 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
9437 cfun
->curr_properties
|= PROP_gimple_any
;
9441 dump_function (TDI_generic
, fndecl
);
9444 /* Return a dummy expression of type TYPE in order to keep going after an
9448 dummy_object (tree type
)
9450 tree t
= build_int_cst (build_pointer_type (type
), 0);
9451 return build2 (MEM_REF
, type
, t
, t
);
9454 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
9455 builtin function, but a very special sort of operator. */
9457 enum gimplify_status
9458 gimplify_va_arg_expr (tree
*expr_p
, gimple_seq
*pre_p
,
9459 gimple_seq
*post_p ATTRIBUTE_UNUSED
)
9461 tree promoted_type
, have_va_type
;
9462 tree valist
= TREE_OPERAND (*expr_p
, 0);
9463 tree type
= TREE_TYPE (*expr_p
);
9465 location_t loc
= EXPR_LOCATION (*expr_p
);
9467 /* Verify that valist is of the proper type. */
9468 have_va_type
= TREE_TYPE (valist
);
9469 if (have_va_type
== error_mark_node
)
9471 have_va_type
= targetm
.canonical_va_list_type (have_va_type
);
9473 if (have_va_type
== NULL_TREE
)
9475 error_at (loc
, "first argument to %<va_arg%> not of type %<va_list%>");
9479 /* Generate a diagnostic for requesting data of a type that cannot
9480 be passed through `...' due to type promotion at the call site. */
9481 if ((promoted_type
= lang_hooks
.types
.type_promotes_to (type
))
9484 static bool gave_help
;
9487 /* Unfortunately, this is merely undefined, rather than a constraint
9488 violation, so we cannot make this an error. If this call is never
9489 executed, the program is still strictly conforming. */
9490 warned
= warning_at (loc
, 0,
9491 "%qT is promoted to %qT when passed through %<...%>",
9492 type
, promoted_type
);
9493 if (!gave_help
&& warned
)
9496 inform (loc
, "(so you should pass %qT not %qT to %<va_arg%>)",
9497 promoted_type
, type
);
9500 /* We can, however, treat "undefined" any way we please.
9501 Call abort to encourage the user to fix the program. */
9503 inform (loc
, "if this code is reached, the program will abort");
9504 /* Before the abort, allow the evaluation of the va_list
9505 expression to exit or longjmp. */
9506 gimplify_and_add (valist
, pre_p
);
9507 t
= build_call_expr_loc (loc
,
9508 builtin_decl_implicit (BUILT_IN_TRAP
), 0);
9509 gimplify_and_add (t
, pre_p
);
9511 /* This is dead code, but go ahead and finish so that the
9512 mode of the result comes out right. */
9513 *expr_p
= dummy_object (type
);
9517 tag
= build_int_cst (build_pointer_type (type
), 0);
9518 *expr_p
= build_call_expr_internal_loc (loc
, IFN_VA_ARG
, type
, 2, valist
, tag
);
9520 /* Clear the tentatively set PROP_gimple_lva, to indicate that IFN_VA_ARG
9521 needs to be expanded. */
9522 cfun
->curr_properties
&= ~PROP_gimple_lva
;
9527 /* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
9529 DST/SRC are the destination and source respectively. You can pass
9530 ungimplified trees in DST or SRC, in which case they will be
9531 converted to a gimple operand if necessary.
9533 This function returns the newly created GIMPLE_ASSIGN tuple. */
9536 gimplify_assign (tree dst
, tree src
, gimple_seq
*seq_p
)
9538 tree t
= build2 (MODIFY_EXPR
, TREE_TYPE (dst
), dst
, src
);
9539 gimplify_and_add (t
, seq_p
);
9541 return gimple_seq_last_stmt (*seq_p
);
9545 gimplify_hasher::hash (const elt_t
*p
)
9548 return iterative_hash_expr (t
, 0);
9552 gimplify_hasher::equal (const elt_t
*p1
, const elt_t
*p2
)
9556 enum tree_code code
= TREE_CODE (t1
);
9558 if (TREE_CODE (t2
) != code
9559 || TREE_TYPE (t1
) != TREE_TYPE (t2
))
9562 if (!operand_equal_p (t1
, t2
, 0))
9565 #ifdef ENABLE_CHECKING
9566 /* Only allow them to compare equal if they also hash equal; otherwise
9567 results are nondeterminate, and we fail bootstrap comparison. */
9568 gcc_assert (hash (p1
) == hash (p2
));