1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002-2013 Free Software Foundation, Inc.
4 Major work done by Sebastian Pop <s.pop@laposte.net>,
5 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
29 #include "tree-iterator.h"
30 #include "tree-inline.h"
31 #include "tree-pretty-print.h"
32 #include "langhooks.h"
40 #include "diagnostic-core.h"
42 #include "pointer-set.h"
43 #include "splay-tree.h"
47 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
48 #include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
49 #include "tree-mudflap.h"
53 enum gimplify_omp_var_data
59 GOVD_FIRSTPRIVATE
= 16,
60 GOVD_LASTPRIVATE
= 32,
64 GOVD_DEBUG_PRIVATE
= 512,
65 GOVD_PRIVATE_OUTER_REF
= 1024,
68 GOVD_MAP_TO_ONLY
= 8192,
69 GOVD_DATA_SHARE_CLASS
= (GOVD_SHARED
| GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
70 | GOVD_LASTPRIVATE
| GOVD_REDUCTION
| GOVD_LINEAR
80 ORT_COMBINED_PARALLEL
= 3,
88 struct gimplify_omp_ctx
90 struct gimplify_omp_ctx
*outer_context
;
92 struct pointer_set_t
*privatized_types
;
94 enum omp_clause_default_kind default_kind
;
95 enum omp_region_type region_type
;
99 static struct gimplify_ctx
*gimplify_ctxp
;
100 static struct gimplify_omp_ctx
*gimplify_omp_ctxp
;
103 /* Forward declaration. */
104 static enum gimplify_status
gimplify_compound_expr (tree
*, gimple_seq
*, bool);
106 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
107 form and we don't do any syntax checking. */
110 mark_addressable (tree x
)
112 while (handled_component_p (x
))
113 x
= TREE_OPERAND (x
, 0);
114 if (TREE_CODE (x
) == MEM_REF
115 && TREE_CODE (TREE_OPERAND (x
, 0)) == ADDR_EXPR
)
116 x
= TREE_OPERAND (TREE_OPERAND (x
, 0), 0);
117 if (TREE_CODE (x
) != VAR_DECL
118 && TREE_CODE (x
) != PARM_DECL
119 && TREE_CODE (x
) != RESULT_DECL
)
121 TREE_ADDRESSABLE (x
) = 1;
123 /* Also mark the artificial SSA_NAME that points to the partition of X. */
124 if (TREE_CODE (x
) == VAR_DECL
125 && !DECL_EXTERNAL (x
)
127 && cfun
->gimple_df
!= NULL
128 && cfun
->gimple_df
->decls_to_pointers
!= NULL
)
131 = pointer_map_contains (cfun
->gimple_df
->decls_to_pointers
, x
);
133 TREE_ADDRESSABLE (*(tree
*)namep
) = 1;
137 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
138 *SEQ_P is NULL, a new sequence is allocated. This function is
139 similar to gimple_seq_add_stmt, but does not scan the operands.
140 During gimplification, we need to manipulate statement sequences
141 before the def/use vectors have been constructed. */
144 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
146 gimple_stmt_iterator si
;
151 si
= gsi_last (*seq_p
);
152 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
155 /* Shorter alias name for the above function for use in gimplify.c
159 gimplify_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
161 gimple_seq_add_stmt_without_update (seq_p
, gs
);
164 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
165 NULL, a new sequence is allocated. This function is
166 similar to gimple_seq_add_seq, but does not scan the operands.
167 During gimplification, we need to manipulate statement sequences
168 before the def/use vectors have been constructed. */
171 gimplify_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
173 gimple_stmt_iterator si
;
178 si
= gsi_last (*dst_p
);
179 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
182 /* Set up a context for the gimplifier. */
185 push_gimplify_context (struct gimplify_ctx
*c
)
187 memset (c
, '\0', sizeof (*c
));
188 c
->prev_context
= gimplify_ctxp
;
192 /* Tear down a context for the gimplifier. If BODY is non-null, then
193 put the temporaries into the outer BIND_EXPR. Otherwise, put them
196 BODY is not a sequence, but the first tuple in a sequence. */
199 pop_gimplify_context (gimple body
)
201 struct gimplify_ctx
*c
= gimplify_ctxp
;
204 && (!c
->bind_expr_stack
.exists ()
205 || c
->bind_expr_stack
.is_empty ()));
206 c
->bind_expr_stack
.release ();
207 gimplify_ctxp
= c
->prev_context
;
210 declare_vars (c
->temps
, body
, false);
212 record_vars (c
->temps
);
214 if (c
->temp_htab
.is_created ())
215 c
->temp_htab
.dispose ();
218 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
221 gimple_push_bind_expr (gimple gimple_bind
)
223 gimplify_ctxp
->bind_expr_stack
.reserve (8);
224 gimplify_ctxp
->bind_expr_stack
.safe_push (gimple_bind
);
227 /* Pop the first element off the stack of bindings. */
230 gimple_pop_bind_expr (void)
232 gimplify_ctxp
->bind_expr_stack
.pop ();
235 /* Return the first element of the stack of bindings. */
238 gimple_current_bind_expr (void)
240 return gimplify_ctxp
->bind_expr_stack
.last ();
243 /* Return the stack of bindings created during gimplification. */
246 gimple_bind_expr_stack (void)
248 return gimplify_ctxp
->bind_expr_stack
;
251 /* Return true iff there is a COND_EXPR between us and the innermost
252 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
255 gimple_conditional_context (void)
257 return gimplify_ctxp
->conditions
> 0;
260 /* Note that we've entered a COND_EXPR. */
263 gimple_push_condition (void)
265 #ifdef ENABLE_GIMPLE_CHECKING
266 if (gimplify_ctxp
->conditions
== 0)
267 gcc_assert (gimple_seq_empty_p (gimplify_ctxp
->conditional_cleanups
));
269 ++(gimplify_ctxp
->conditions
);
272 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
273 now, add any conditional cleanups we've seen to the prequeue. */
276 gimple_pop_condition (gimple_seq
*pre_p
)
278 int conds
= --(gimplify_ctxp
->conditions
);
280 gcc_assert (conds
>= 0);
283 gimplify_seq_add_seq (pre_p
, gimplify_ctxp
->conditional_cleanups
);
284 gimplify_ctxp
->conditional_cleanups
= NULL
;
288 /* A stable comparison routine for use with splay trees and DECLs. */
291 splay_tree_compare_decl_uid (splay_tree_key xa
, splay_tree_key xb
)
296 return DECL_UID (a
) - DECL_UID (b
);
299 /* Create a new omp construct that deals with variable remapping. */
301 static struct gimplify_omp_ctx
*
302 new_omp_context (enum omp_region_type region_type
)
304 struct gimplify_omp_ctx
*c
;
306 c
= XCNEW (struct gimplify_omp_ctx
);
307 c
->outer_context
= gimplify_omp_ctxp
;
308 c
->variables
= splay_tree_new (splay_tree_compare_decl_uid
, 0, 0);
309 c
->privatized_types
= pointer_set_create ();
310 c
->location
= input_location
;
311 c
->region_type
= region_type
;
312 if ((region_type
& ORT_TASK
) == 0)
313 c
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
315 c
->default_kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
320 /* Destroy an omp construct that deals with variable remapping. */
323 delete_omp_context (struct gimplify_omp_ctx
*c
)
325 splay_tree_delete (c
->variables
);
326 pointer_set_destroy (c
->privatized_types
);
330 static void omp_add_variable (struct gimplify_omp_ctx
*, tree
, unsigned int);
331 static bool omp_notice_variable (struct gimplify_omp_ctx
*, tree
, bool);
333 /* Both gimplify the statement T and append it to *SEQ_P. This function
334 behaves exactly as gimplify_stmt, but you don't have to pass T as a
338 gimplify_and_add (tree t
, gimple_seq
*seq_p
)
340 gimplify_stmt (&t
, seq_p
);
343 /* Gimplify statement T into sequence *SEQ_P, and return the first
344 tuple in the sequence of generated tuples for this statement.
345 Return NULL if gimplifying T produced no tuples. */
348 gimplify_and_return_first (tree t
, gimple_seq
*seq_p
)
350 gimple_stmt_iterator last
= gsi_last (*seq_p
);
352 gimplify_and_add (t
, seq_p
);
354 if (!gsi_end_p (last
))
357 return gsi_stmt (last
);
360 return gimple_seq_first_stmt (*seq_p
);
363 /* Strip off a legitimate source ending from the input string NAME of
364 length LEN. Rather than having to know the names used by all of
365 our front ends, we strip off an ending of a period followed by
366 up to five characters. (Java uses ".class".) */
369 remove_suffix (char *name
, int len
)
373 for (i
= 2; i
< 8 && len
> i
; i
++)
375 if (name
[len
- i
] == '.')
377 name
[len
- i
] = '\0';
383 /* Create a new temporary name with PREFIX. Return an identifier. */
385 static GTY(()) unsigned int tmp_var_id_num
;
388 create_tmp_var_name (const char *prefix
)
394 char *preftmp
= ASTRDUP (prefix
);
396 remove_suffix (preftmp
, strlen (preftmp
));
397 clean_symbol_name (preftmp
);
402 ASM_FORMAT_PRIVATE_NAME (tmp_name
, prefix
? prefix
: "T", tmp_var_id_num
++);
403 return get_identifier (tmp_name
);
406 /* Create a new temporary variable declaration of type TYPE.
407 Do NOT push it into the current binding. */
410 create_tmp_var_raw (tree type
, const char *prefix
)
414 tmp_var
= build_decl (input_location
,
415 VAR_DECL
, prefix
? create_tmp_var_name (prefix
) : NULL
,
418 /* The variable was declared by the compiler. */
419 DECL_ARTIFICIAL (tmp_var
) = 1;
420 /* And we don't want debug info for it. */
421 DECL_IGNORED_P (tmp_var
) = 1;
423 /* Make the variable writable. */
424 TREE_READONLY (tmp_var
) = 0;
426 DECL_EXTERNAL (tmp_var
) = 0;
427 TREE_STATIC (tmp_var
) = 0;
428 TREE_USED (tmp_var
) = 1;
433 /* Create a new temporary variable declaration of type TYPE. DO push the
434 variable into the current binding. Further, assume that this is called
435 only from gimplification or optimization, at which point the creation of
436 certain types are bugs. */
439 create_tmp_var (tree type
, const char *prefix
)
443 /* We don't allow types that are addressable (meaning we can't make copies),
444 or incomplete. We also used to reject every variable size objects here,
445 but now support those for which a constant upper bound can be obtained.
446 The processing for variable sizes is performed in gimple_add_tmp_var,
447 point at which it really matters and possibly reached via paths not going
448 through this function, e.g. after direct calls to create_tmp_var_raw. */
449 gcc_assert (!TREE_ADDRESSABLE (type
) && COMPLETE_TYPE_P (type
));
451 tmp_var
= create_tmp_var_raw (type
, prefix
);
452 gimple_add_tmp_var (tmp_var
);
456 /* Create a new temporary variable declaration of type TYPE by calling
457 create_tmp_var and if TYPE is a vector or a complex number, mark the new
458 temporary as gimple register. */
461 create_tmp_reg (tree type
, const char *prefix
)
465 tmp
= create_tmp_var (type
, prefix
);
466 if (TREE_CODE (type
) == COMPLEX_TYPE
467 || TREE_CODE (type
) == VECTOR_TYPE
)
468 DECL_GIMPLE_REG_P (tmp
) = 1;
473 /* Returns true iff T is a valid RHS for an assignment to a renamed
474 user -- or front-end generated artificial -- variable. */
477 is_gimple_reg_rhs (tree t
)
479 return get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
;
482 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
483 LHS, or for a call argument. */
486 is_gimple_mem_rhs (tree t
)
488 /* If we're dealing with a renamable type, either source or dest must be
489 a renamed variable. */
490 if (is_gimple_reg_type (TREE_TYPE (t
)))
491 return is_gimple_val (t
);
493 return is_gimple_val (t
) || is_gimple_lvalue (t
);
496 /* Return true if T is a CALL_EXPR or an expression that can be
497 assigned to a temporary. Note that this predicate should only be
498 used during gimplification. See the rationale for this in
499 gimplify_modify_expr. */
502 is_gimple_reg_rhs_or_call (tree t
)
504 return (get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
505 || TREE_CODE (t
) == CALL_EXPR
);
508 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
509 this predicate should only be used during gimplification. See the
510 rationale for this in gimplify_modify_expr. */
513 is_gimple_mem_rhs_or_call (tree t
)
515 /* If we're dealing with a renamable type, either source or dest must be
516 a renamed variable. */
517 if (is_gimple_reg_type (TREE_TYPE (t
)))
518 return is_gimple_val (t
);
520 return (is_gimple_val (t
) || is_gimple_lvalue (t
)
521 || TREE_CODE (t
) == CALL_EXPR
);
524 /* Create a temporary with a name derived from VAL. Subroutine of
525 lookup_tmp_var; nobody else should call this function. */
528 create_tmp_from_val (tree val
, bool is_formal
)
530 /* Drop all qualifiers and address-space information from the value type. */
531 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (val
));
532 tree var
= create_tmp_var (type
, get_name (val
));
534 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
535 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
))
536 DECL_GIMPLE_REG_P (var
) = 1;
540 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
541 an existing expression temporary. */
544 lookup_tmp_var (tree val
, bool is_formal
)
548 /* If not optimizing, never really reuse a temporary. local-alloc
549 won't allocate any variable that is used in more than one basic
550 block, which means it will go into memory, causing much extra
551 work in reload and final and poorer code generation, outweighing
552 the extra memory allocation here. */
553 if (!optimize
|| !is_formal
|| TREE_SIDE_EFFECTS (val
))
554 ret
= create_tmp_from_val (val
, is_formal
);
561 if (!gimplify_ctxp
->temp_htab
.is_created ())
562 gimplify_ctxp
->temp_htab
.create (1000);
563 slot
= gimplify_ctxp
->temp_htab
.find_slot (&elt
, INSERT
);
566 elt_p
= XNEW (elt_t
);
568 elt_p
->temp
= ret
= create_tmp_from_val (val
, is_formal
);
581 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
584 internal_get_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
589 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
590 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
591 gimplify_expr (&val
, pre_p
, post_p
, is_gimple_reg_rhs_or_call
,
594 if (gimplify_ctxp
->into_ssa
595 && is_gimple_reg_type (TREE_TYPE (val
)))
596 t
= make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val
)), NULL
);
598 t
= lookup_tmp_var (val
, is_formal
);
600 mod
= build2 (INIT_EXPR
, TREE_TYPE (t
), t
, unshare_expr (val
));
602 SET_EXPR_LOCATION (mod
, EXPR_LOC_OR_HERE (val
));
604 /* gimplify_modify_expr might want to reduce this further. */
605 gimplify_and_add (mod
, pre_p
);
611 /* Return a formal temporary variable initialized with VAL. PRE_P is as
612 in gimplify_expr. Only use this function if:
614 1) The value of the unfactored expression represented by VAL will not
615 change between the initialization and use of the temporary, and
616 2) The temporary will not be otherwise modified.
618 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
619 and #2 means it is inappropriate for && temps.
621 For other cases, use get_initialized_tmp_var instead. */
624 get_formal_tmp_var (tree val
, gimple_seq
*pre_p
)
626 return internal_get_tmp_var (val
, pre_p
, NULL
, true);
629 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
630 are as in gimplify_expr. */
633 get_initialized_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
635 return internal_get_tmp_var (val
, pre_p
, post_p
, false);
638 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
639 generate debug info for them; otherwise don't. */
642 declare_vars (tree vars
, gimple scope
, bool debug_info
)
649 gcc_assert (gimple_code (scope
) == GIMPLE_BIND
);
651 temps
= nreverse (last
);
653 block
= gimple_bind_block (scope
);
654 gcc_assert (!block
|| TREE_CODE (block
) == BLOCK
);
655 if (!block
|| !debug_info
)
657 DECL_CHAIN (last
) = gimple_bind_vars (scope
);
658 gimple_bind_set_vars (scope
, temps
);
662 /* We need to attach the nodes both to the BIND_EXPR and to its
663 associated BLOCK for debugging purposes. The key point here
664 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
665 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
666 if (BLOCK_VARS (block
))
667 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), temps
);
670 gimple_bind_set_vars (scope
,
671 chainon (gimple_bind_vars (scope
), temps
));
672 BLOCK_VARS (block
) = temps
;
678 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
679 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
680 no such upper bound can be obtained. */
683 force_constant_size (tree var
)
685 /* The only attempt we make is by querying the maximum size of objects
686 of the variable's type. */
688 HOST_WIDE_INT max_size
;
690 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
692 max_size
= max_int_size_in_bytes (TREE_TYPE (var
));
694 gcc_assert (max_size
>= 0);
697 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var
)), max_size
);
699 = build_int_cst (TREE_TYPE (DECL_SIZE (var
)), max_size
* BITS_PER_UNIT
);
702 /* Push the temporary variable TMP into the current binding. */
705 gimple_add_tmp_var (tree tmp
)
707 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
709 /* Later processing assumes that the object size is constant, which might
710 not be true at this point. Force the use of a constant upper bound in
712 if (!host_integerp (DECL_SIZE_UNIT (tmp
), 1))
713 force_constant_size (tmp
);
715 DECL_CONTEXT (tmp
) = current_function_decl
;
716 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
720 DECL_CHAIN (tmp
) = gimplify_ctxp
->temps
;
721 gimplify_ctxp
->temps
= tmp
;
723 /* Mark temporaries local within the nearest enclosing parallel. */
724 if (gimplify_omp_ctxp
)
726 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
728 && (ctx
->region_type
== ORT_WORKSHARE
729 || ctx
->region_type
== ORT_SIMD
))
730 ctx
= ctx
->outer_context
;
732 omp_add_variable (ctx
, tmp
, GOVD_LOCAL
| GOVD_SEEN
);
741 /* This case is for nested functions. We need to expose the locals
743 body_seq
= gimple_body (current_function_decl
);
744 declare_vars (tmp
, gimple_seq_first_stmt (body_seq
), false);
748 /* Determine whether to assign a location to the statement GS. */
751 should_carry_location_p (gimple gs
)
753 /* Don't emit a line note for a label. We particularly don't want to
754 emit one for the break label, since it doesn't actually correspond
755 to the beginning of the loop/switch. */
756 if (gimple_code (gs
) == GIMPLE_LABEL
)
762 /* Return true if a location should not be emitted for this statement
763 by annotate_one_with_location. */
766 gimple_do_not_emit_location_p (gimple g
)
768 return gimple_plf (g
, GF_PLF_1
);
771 /* Mark statement G so a location will not be emitted by
772 annotate_one_with_location. */
775 gimple_set_do_not_emit_location (gimple g
)
777 /* The PLF flags are initialized to 0 when a new tuple is created,
778 so no need to initialize it anywhere. */
779 gimple_set_plf (g
, GF_PLF_1
, true);
782 /* Set the location for gimple statement GS to LOCATION. */
785 annotate_one_with_location (gimple gs
, location_t location
)
787 if (!gimple_has_location (gs
)
788 && !gimple_do_not_emit_location_p (gs
)
789 && should_carry_location_p (gs
))
790 gimple_set_location (gs
, location
);
793 /* Set LOCATION for all the statements after iterator GSI in sequence
794 SEQ. If GSI is pointing to the end of the sequence, start with the
795 first statement in SEQ. */
798 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
802 gsi
= gsi_start (seq
);
806 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
807 annotate_one_with_location (gsi_stmt (gsi
), location
);
810 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
813 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
815 gimple_stmt_iterator i
;
817 if (gimple_seq_empty_p (stmt_p
))
820 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
822 gimple gs
= gsi_stmt (i
);
823 annotate_one_with_location (gs
, location
);
827 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
828 nodes that are referenced more than once in GENERIC functions. This is
829 necessary because gimplification (translation into GIMPLE) is performed
830 by modifying tree nodes in-place, so gimplication of a shared node in a
831 first context could generate an invalid GIMPLE form in a second context.
833 This is achieved with a simple mark/copy/unmark algorithm that walks the
834 GENERIC representation top-down, marks nodes with TREE_VISITED the first
835 time it encounters them, duplicates them if they already have TREE_VISITED
836 set, and finally removes the TREE_VISITED marks it has set.
838 The algorithm works only at the function level, i.e. it generates a GENERIC
839 representation of a function with no nodes shared within the function when
840 passed a GENERIC function (except for nodes that are allowed to be shared).
842 At the global level, it is also necessary to unshare tree nodes that are
843 referenced in more than one function, for the same aforementioned reason.
844 This requires some cooperation from the front-end. There are 2 strategies:
846 1. Manual unsharing. The front-end needs to call unshare_expr on every
847 expression that might end up being shared across functions.
849 2. Deep unsharing. This is an extension of regular unsharing. Instead
850 of calling unshare_expr on expressions that might be shared across
851 functions, the front-end pre-marks them with TREE_VISITED. This will
852 ensure that they are unshared on the first reference within functions
853 when the regular unsharing algorithm runs. The counterpart is that
854 this algorithm must look deeper than for manual unsharing, which is
855 specified by LANG_HOOKS_DEEP_UNSHARING.
857 If there are only few specific cases of node sharing across functions, it is
858 probably easier for a front-end to unshare the expressions manually. On the
859 contrary, if the expressions generated at the global level are as widespread
860 as expressions generated within functions, deep unsharing is very likely the
863 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
864 These nodes model computations that must be done once. If we were to
865 unshare something like SAVE_EXPR(i++), the gimplification process would
866 create wrong code. However, if DATA is non-null, it must hold a pointer
867 set that is used to unshare the subtrees of these nodes. */
870 mostly_copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
873 enum tree_code code
= TREE_CODE (t
);
875 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
876 copy their subtrees if we can make sure to do it only once. */
877 if (code
== SAVE_EXPR
|| code
== TARGET_EXPR
|| code
== BIND_EXPR
)
879 if (data
&& !pointer_set_insert ((struct pointer_set_t
*)data
, t
))
885 /* Stop at types, decls, constants like copy_tree_r. */
886 else if (TREE_CODE_CLASS (code
) == tcc_type
887 || TREE_CODE_CLASS (code
) == tcc_declaration
888 || TREE_CODE_CLASS (code
) == tcc_constant
889 /* We can't do anything sensible with a BLOCK used as an
890 expression, but we also can't just die when we see it
891 because of non-expression uses. So we avert our eyes
892 and cross our fingers. Silly Java. */
896 /* Cope with the statement expression extension. */
897 else if (code
== STATEMENT_LIST
)
900 /* Leave the bulk of the work to copy_tree_r itself. */
902 copy_tree_r (tp
, walk_subtrees
, NULL
);
907 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
908 If *TP has been visited already, then *TP is deeply copied by calling
909 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
912 copy_if_shared_r (tree
*tp
, int *walk_subtrees
, void *data
)
915 enum tree_code code
= TREE_CODE (t
);
917 /* Skip types, decls, and constants. But we do want to look at their
918 types and the bounds of types. Mark them as visited so we properly
919 unmark their subtrees on the unmark pass. If we've already seen them,
920 don't look down further. */
921 if (TREE_CODE_CLASS (code
) == tcc_type
922 || TREE_CODE_CLASS (code
) == tcc_declaration
923 || TREE_CODE_CLASS (code
) == tcc_constant
)
925 if (TREE_VISITED (t
))
928 TREE_VISITED (t
) = 1;
931 /* If this node has been visited already, unshare it and don't look
933 else if (TREE_VISITED (t
))
935 walk_tree (tp
, mostly_copy_tree_r
, data
, NULL
);
939 /* Otherwise, mark the node as visited and keep looking. */
941 TREE_VISITED (t
) = 1;
946 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
947 copy_if_shared_r callback unmodified. */
950 copy_if_shared (tree
*tp
, void *data
)
952 walk_tree (tp
, copy_if_shared_r
, data
, NULL
);
955 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
956 any nested functions. */
959 unshare_body (tree fndecl
)
961 struct cgraph_node
*cgn
= cgraph_get_node (fndecl
);
962 /* If the language requires deep unsharing, we need a pointer set to make
963 sure we don't repeatedly unshare subtrees of unshareable nodes. */
964 struct pointer_set_t
*visited
965 = lang_hooks
.deep_unsharing
? pointer_set_create () : NULL
;
967 copy_if_shared (&DECL_SAVED_TREE (fndecl
), visited
);
968 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl
)), visited
);
969 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)), visited
);
972 pointer_set_destroy (visited
);
975 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
976 unshare_body (cgn
->symbol
.decl
);
979 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
980 Subtrees are walked until the first unvisited node is encountered. */
983 unmark_visited_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
987 /* If this node has been visited, unmark it and keep looking. */
988 if (TREE_VISITED (t
))
989 TREE_VISITED (t
) = 0;
991 /* Otherwise, don't look any deeper. */
998 /* Unmark the visited trees rooted at *TP. */
1001 unmark_visited (tree
*tp
)
1003 walk_tree (tp
, unmark_visited_r
, NULL
, NULL
);
1006 /* Likewise, but mark all trees as not visited. */
1009 unvisit_body (tree fndecl
)
1011 struct cgraph_node
*cgn
= cgraph_get_node (fndecl
);
1013 unmark_visited (&DECL_SAVED_TREE (fndecl
));
1014 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl
)));
1015 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)));
1018 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
1019 unvisit_body (cgn
->symbol
.decl
);
1022 /* Unconditionally make an unshared copy of EXPR. This is used when using
1023 stored expressions which span multiple functions, such as BINFO_VTABLE,
1024 as the normal unsharing process can't tell that they're shared. */
1027 unshare_expr (tree expr
)
1029 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
1033 /* Worker for unshare_expr_without_location. */
1036 prune_expr_location (tree
*tp
, int *walk_subtrees
, void *)
1039 SET_EXPR_LOCATION (*tp
, UNKNOWN_LOCATION
);
1045 /* Similar to unshare_expr but also prune all expression locations
1049 unshare_expr_without_location (tree expr
)
1051 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
1053 walk_tree (&expr
, prune_expr_location
, NULL
, NULL
);
1057 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1058 contain statements and have a value. Assign its value to a temporary
1059 and give it void_type_node. Return the temporary, or NULL_TREE if
1060 WRAPPER was already void. */
1063 voidify_wrapper_expr (tree wrapper
, tree temp
)
1065 tree type
= TREE_TYPE (wrapper
);
1066 if (type
&& !VOID_TYPE_P (type
))
1070 /* Set p to point to the body of the wrapper. Loop until we find
1071 something that isn't a wrapper. */
1072 for (p
= &wrapper
; p
&& *p
; )
1074 switch (TREE_CODE (*p
))
1077 TREE_SIDE_EFFECTS (*p
) = 1;
1078 TREE_TYPE (*p
) = void_type_node
;
1079 /* For a BIND_EXPR, the body is operand 1. */
1080 p
= &BIND_EXPR_BODY (*p
);
1083 case CLEANUP_POINT_EXPR
:
1084 case TRY_FINALLY_EXPR
:
1085 case TRY_CATCH_EXPR
:
1086 TREE_SIDE_EFFECTS (*p
) = 1;
1087 TREE_TYPE (*p
) = void_type_node
;
1088 p
= &TREE_OPERAND (*p
, 0);
1091 case STATEMENT_LIST
:
1093 tree_stmt_iterator i
= tsi_last (*p
);
1094 TREE_SIDE_EFFECTS (*p
) = 1;
1095 TREE_TYPE (*p
) = void_type_node
;
1096 p
= tsi_end_p (i
) ? NULL
: tsi_stmt_ptr (i
);
1101 /* Advance to the last statement. Set all container types to
1103 for (; TREE_CODE (*p
) == COMPOUND_EXPR
; p
= &TREE_OPERAND (*p
, 1))
1105 TREE_SIDE_EFFECTS (*p
) = 1;
1106 TREE_TYPE (*p
) = void_type_node
;
1110 case TRANSACTION_EXPR
:
1111 TREE_SIDE_EFFECTS (*p
) = 1;
1112 TREE_TYPE (*p
) = void_type_node
;
1113 p
= &TRANSACTION_EXPR_BODY (*p
);
1117 /* Assume that any tree upon which voidify_wrapper_expr is
1118 directly called is a wrapper, and that its body is op0. */
1121 TREE_SIDE_EFFECTS (*p
) = 1;
1122 TREE_TYPE (*p
) = void_type_node
;
1123 p
= &TREE_OPERAND (*p
, 0);
1131 if (p
== NULL
|| IS_EMPTY_STMT (*p
))
1135 /* The wrapper is on the RHS of an assignment that we're pushing
1137 gcc_assert (TREE_CODE (temp
) == INIT_EXPR
1138 || TREE_CODE (temp
) == MODIFY_EXPR
);
1139 TREE_OPERAND (temp
, 1) = *p
;
1144 temp
= create_tmp_var (type
, "retval");
1145 *p
= build2 (INIT_EXPR
, type
, temp
, *p
);
1154 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1155 a temporary through which they communicate. */
1158 build_stack_save_restore (gimple
*save
, gimple
*restore
)
1162 *save
= gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE
), 0);
1163 tmp_var
= create_tmp_var (ptr_type_node
, "saved_stack");
1164 gimple_call_set_lhs (*save
, tmp_var
);
1167 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE
),
1171 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1173 static enum gimplify_status
1174 gimplify_bind_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1176 tree bind_expr
= *expr_p
;
1177 bool old_save_stack
= gimplify_ctxp
->save_stack
;
1180 gimple_seq body
, cleanup
;
1183 tree temp
= voidify_wrapper_expr (bind_expr
, NULL
);
1185 /* Mark variables seen in this bind expr. */
1186 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1188 if (TREE_CODE (t
) == VAR_DECL
)
1190 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1192 /* Mark variable as local. */
1193 if (ctx
&& !DECL_EXTERNAL (t
)
1194 && (! DECL_SEEN_IN_BIND_EXPR_P (t
)
1195 || splay_tree_lookup (ctx
->variables
,
1196 (splay_tree_key
) t
) == NULL
))
1197 omp_add_variable (gimplify_omp_ctxp
, t
, GOVD_LOCAL
| GOVD_SEEN
);
1199 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
1201 if (DECL_HARD_REGISTER (t
) && !is_global_var (t
) && cfun
)
1202 cfun
->has_local_explicit_reg_vars
= true;
1205 /* Preliminarily mark non-addressed complex variables as eligible
1206 for promotion to gimple registers. We'll transform their uses
1208 if ((TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
1209 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1210 && !TREE_THIS_VOLATILE (t
)
1211 && (TREE_CODE (t
) == VAR_DECL
&& !DECL_HARD_REGISTER (t
))
1212 && !needs_to_live_in_memory (t
))
1213 DECL_GIMPLE_REG_P (t
) = 1;
1216 gimple_bind
= gimple_build_bind (BIND_EXPR_VARS (bind_expr
), NULL
,
1217 BIND_EXPR_BLOCK (bind_expr
));
1218 gimple_push_bind_expr (gimple_bind
);
1220 gimplify_ctxp
->save_stack
= false;
1222 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1224 gimplify_stmt (&BIND_EXPR_BODY (bind_expr
), &body
);
1225 gimple_bind_set_body (gimple_bind
, body
);
1229 if (gimplify_ctxp
->save_stack
)
1231 gimple stack_restore
;
1233 /* Save stack on entry and restore it on exit. Add a try_finally
1234 block to achieve this. Note that mudflap depends on the
1235 format of the emitted code: see mx_register_decls(). */
1236 build_stack_save_restore (&stack_save
, &stack_restore
);
1238 gimplify_seq_add_stmt (&cleanup
, stack_restore
);
1241 /* Add clobbers for all variables that go out of scope. */
1242 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1244 if (TREE_CODE (t
) == VAR_DECL
1245 && !is_global_var (t
)
1246 && DECL_CONTEXT (t
) == current_function_decl
1247 && !DECL_HARD_REGISTER (t
)
1248 && !TREE_THIS_VOLATILE (t
)
1249 && !DECL_HAS_VALUE_EXPR_P (t
)
1250 /* Only care for variables that have to be in memory. Others
1251 will be rewritten into SSA names, hence moved to the top-level. */
1252 && !is_gimple_reg (t
)
1253 && flag_stack_reuse
!= SR_NONE
)
1255 tree clobber
= build_constructor (TREE_TYPE (t
),
1257 TREE_THIS_VOLATILE (clobber
) = 1;
1258 gimplify_seq_add_stmt (&cleanup
, gimple_build_assign (t
, clobber
));
1265 gimple_seq new_body
;
1268 gs
= gimple_build_try (gimple_bind_body (gimple_bind
), cleanup
,
1269 GIMPLE_TRY_FINALLY
);
1272 gimplify_seq_add_stmt (&new_body
, stack_save
);
1273 gimplify_seq_add_stmt (&new_body
, gs
);
1274 gimple_bind_set_body (gimple_bind
, new_body
);
1277 gimplify_ctxp
->save_stack
= old_save_stack
;
1278 gimple_pop_bind_expr ();
1280 gimplify_seq_add_stmt (pre_p
, gimple_bind
);
1288 *expr_p
= NULL_TREE
;
1292 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1293 GIMPLE value, it is assigned to a new temporary and the statement is
1294 re-written to return the temporary.
1296 PRE_P points to the sequence where side effects that must happen before
1297 STMT should be stored. */
1299 static enum gimplify_status
1300 gimplify_return_expr (tree stmt
, gimple_seq
*pre_p
)
1303 tree ret_expr
= TREE_OPERAND (stmt
, 0);
1304 tree result_decl
, result
;
1306 if (ret_expr
== error_mark_node
)
1310 || TREE_CODE (ret_expr
) == RESULT_DECL
1311 || ret_expr
== error_mark_node
)
1313 gimple ret
= gimple_build_return (ret_expr
);
1314 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1315 gimplify_seq_add_stmt (pre_p
, ret
);
1319 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1320 result_decl
= NULL_TREE
;
1323 result_decl
= TREE_OPERAND (ret_expr
, 0);
1325 /* See through a return by reference. */
1326 if (TREE_CODE (result_decl
) == INDIRECT_REF
)
1327 result_decl
= TREE_OPERAND (result_decl
, 0);
1329 gcc_assert ((TREE_CODE (ret_expr
) == MODIFY_EXPR
1330 || TREE_CODE (ret_expr
) == INIT_EXPR
)
1331 && TREE_CODE (result_decl
) == RESULT_DECL
);
1334 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1335 Recall that aggregate_value_p is FALSE for any aggregate type that is
1336 returned in registers. If we're returning values in registers, then
1337 we don't want to extend the lifetime of the RESULT_DECL, particularly
1338 across another call. In addition, for those aggregates for which
1339 hard_function_value generates a PARALLEL, we'll die during normal
1340 expansion of structure assignments; there's special code in expand_return
1341 to handle this case that does not exist in expand_expr. */
1344 else if (aggregate_value_p (result_decl
, TREE_TYPE (current_function_decl
)))
1346 if (TREE_CODE (DECL_SIZE (result_decl
)) != INTEGER_CST
)
1348 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl
)))
1349 gimplify_type_sizes (TREE_TYPE (result_decl
), pre_p
);
1350 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1351 should be effectively allocated by the caller, i.e. all calls to
1352 this function must be subject to the Return Slot Optimization. */
1353 gimplify_one_sizepos (&DECL_SIZE (result_decl
), pre_p
);
1354 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl
), pre_p
);
1356 result
= result_decl
;
1358 else if (gimplify_ctxp
->return_temp
)
1359 result
= gimplify_ctxp
->return_temp
;
1362 result
= create_tmp_reg (TREE_TYPE (result_decl
), NULL
);
1364 /* ??? With complex control flow (usually involving abnormal edges),
1365 we can wind up warning about an uninitialized value for this. Due
1366 to how this variable is constructed and initialized, this is never
1367 true. Give up and never warn. */
1368 TREE_NO_WARNING (result
) = 1;
1370 gimplify_ctxp
->return_temp
= result
;
1373 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1374 Then gimplify the whole thing. */
1375 if (result
!= result_decl
)
1376 TREE_OPERAND (ret_expr
, 0) = result
;
1378 gimplify_and_add (TREE_OPERAND (stmt
, 0), pre_p
);
1380 ret
= gimple_build_return (result
);
1381 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1382 gimplify_seq_add_stmt (pre_p
, ret
);
1387 /* Gimplify a variable-length array DECL. */
1390 gimplify_vla_decl (tree decl
, gimple_seq
*seq_p
)
1392 /* This is a variable-sized decl. Simplify its size and mark it
1393 for deferred expansion. Note that mudflap depends on the format
1394 of the emitted code: see mx_register_decls(). */
1395 tree t
, addr
, ptr_type
;
1397 gimplify_one_sizepos (&DECL_SIZE (decl
), seq_p
);
1398 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl
), seq_p
);
1400 /* Don't mess with a DECL_VALUE_EXPR set by the front-end. */
1401 if (DECL_HAS_VALUE_EXPR_P (decl
))
1404 /* All occurrences of this decl in final gimplified code will be
1405 replaced by indirection. Setting DECL_VALUE_EXPR does two
1406 things: First, it lets the rest of the gimplifier know what
1407 replacement to use. Second, it lets the debug info know
1408 where to find the value. */
1409 ptr_type
= build_pointer_type (TREE_TYPE (decl
));
1410 addr
= create_tmp_var (ptr_type
, get_name (decl
));
1411 DECL_IGNORED_P (addr
) = 0;
1412 t
= build_fold_indirect_ref (addr
);
1413 TREE_THIS_NOTRAP (t
) = 1;
1414 SET_DECL_VALUE_EXPR (decl
, t
);
1415 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1417 t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
1418 t
= build_call_expr (t
, 2, DECL_SIZE_UNIT (decl
),
1419 size_int (DECL_ALIGN (decl
)));
1420 /* The call has been built for a variable-sized object. */
1421 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
1422 t
= fold_convert (ptr_type
, t
);
1423 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
1425 gimplify_and_add (t
, seq_p
);
1427 /* Indicate that we need to restore the stack level when the
1428 enclosing BIND_EXPR is exited. */
1429 gimplify_ctxp
->save_stack
= true;
1432 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1433 and initialization explicit. */
1435 static enum gimplify_status
1436 gimplify_decl_expr (tree
*stmt_p
, gimple_seq
*seq_p
)
1438 tree stmt
= *stmt_p
;
1439 tree decl
= DECL_EXPR_DECL (stmt
);
1441 *stmt_p
= NULL_TREE
;
1443 if (TREE_TYPE (decl
) == error_mark_node
)
1446 if ((TREE_CODE (decl
) == TYPE_DECL
1447 || TREE_CODE (decl
) == VAR_DECL
)
1448 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl
)))
1449 gimplify_type_sizes (TREE_TYPE (decl
), seq_p
);
1451 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1452 in case its size expressions contain problematic nodes like CALL_EXPR. */
1453 if (TREE_CODE (decl
) == TYPE_DECL
1454 && DECL_ORIGINAL_TYPE (decl
)
1455 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl
)))
1456 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl
), seq_p
);
1458 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1460 tree init
= DECL_INITIAL (decl
);
1462 if (TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1463 || (!TREE_STATIC (decl
)
1464 && flag_stack_check
== GENERIC_STACK_CHECK
1465 && compare_tree_int (DECL_SIZE_UNIT (decl
),
1466 STACK_CHECK_MAX_VAR_SIZE
) > 0))
1467 gimplify_vla_decl (decl
, seq_p
);
1469 /* Some front ends do not explicitly declare all anonymous
1470 artificial variables. We compensate here by declaring the
1471 variables, though it would be better if the front ends would
1472 explicitly declare them. */
1473 if (!DECL_SEEN_IN_BIND_EXPR_P (decl
)
1474 && DECL_ARTIFICIAL (decl
) && DECL_NAME (decl
) == NULL_TREE
)
1475 gimple_add_tmp_var (decl
);
1477 if (init
&& init
!= error_mark_node
)
1479 if (!TREE_STATIC (decl
))
1481 DECL_INITIAL (decl
) = NULL_TREE
;
1482 init
= build2 (INIT_EXPR
, void_type_node
, decl
, init
);
1483 gimplify_and_add (init
, seq_p
);
1487 /* We must still examine initializers for static variables
1488 as they may contain a label address. */
1489 walk_tree (&init
, force_labels_r
, NULL
, NULL
);
1496 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1497 and replacing the LOOP_EXPR with goto, but if the loop contains an
1498 EXIT_EXPR, we need to append a label for it to jump to. */
1500 static enum gimplify_status
1501 gimplify_loop_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1503 tree saved_label
= gimplify_ctxp
->exit_label
;
1504 tree start_label
= create_artificial_label (UNKNOWN_LOCATION
);
1506 gimplify_seq_add_stmt (pre_p
, gimple_build_label (start_label
));
1508 gimplify_ctxp
->exit_label
= NULL_TREE
;
1510 gimplify_and_add (LOOP_EXPR_BODY (*expr_p
), pre_p
);
1512 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (start_label
));
1514 if (gimplify_ctxp
->exit_label
)
1515 gimplify_seq_add_stmt (pre_p
,
1516 gimple_build_label (gimplify_ctxp
->exit_label
));
1518 gimplify_ctxp
->exit_label
= saved_label
;
1524 /* Gimplify a statement list onto a sequence. These may be created either
1525 by an enlightened front-end, or by shortcut_cond_expr. */
1527 static enum gimplify_status
1528 gimplify_statement_list (tree
*expr_p
, gimple_seq
*pre_p
)
1530 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
1532 tree_stmt_iterator i
= tsi_start (*expr_p
);
1534 while (!tsi_end_p (i
))
1536 gimplify_stmt (tsi_stmt_ptr (i
), pre_p
);
1549 /* Compare two case labels. Because the front end should already have
1550 made sure that case ranges do not overlap, it is enough to only compare
1551 the CASE_LOW values of each case label. */
1554 compare_case_labels (const void *p1
, const void *p2
)
1556 const_tree
const case1
= *(const_tree
const*)p1
;
1557 const_tree
const case2
= *(const_tree
const*)p2
;
1559 /* The 'default' case label always goes first. */
1560 if (!CASE_LOW (case1
))
1562 else if (!CASE_LOW (case2
))
1565 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
1568 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1571 sort_case_labels (vec
<tree
> label_vec
)
1573 label_vec
.qsort (compare_case_labels
);
1576 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
1578 LABELS is a vector that contains all case labels to look at.
1580 INDEX_TYPE is the type of the switch index expression. Case labels
1581 in LABELS are discarded if their values are not in the value range
1582 covered by INDEX_TYPE. The remaining case label values are folded
1585 If a default case exists in LABELS, it is removed from LABELS and
1586 returned in DEFAULT_CASEP. If no default case exists, but the
1587 case labels already cover the whole range of INDEX_TYPE, a default
1588 case is returned pointing to one of the existing case labels.
1589 Otherwise DEFAULT_CASEP is set to NULL_TREE.
1591 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
1592 apply and no action is taken regardless of whether a default case is
1596 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
1598 tree
*default_casep
)
1600 tree min_value
, max_value
;
1601 tree default_case
= NULL_TREE
;
1605 min_value
= TYPE_MIN_VALUE (index_type
);
1606 max_value
= TYPE_MAX_VALUE (index_type
);
1607 while (i
< labels
.length ())
1609 tree elt
= labels
[i
];
1610 tree low
= CASE_LOW (elt
);
1611 tree high
= CASE_HIGH (elt
);
1612 bool remove_element
= FALSE
;
1616 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
1617 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
1619 /* This is a non-default case label, i.e. it has a value.
1621 See if the case label is reachable within the range of
1622 the index type. Remove out-of-range case values. Turn
1623 case ranges into a canonical form (high > low strictly)
1624 and convert the case label values to the index type.
1626 NB: The type of gimple_switch_index() may be the promoted
1627 type, but the case labels retain the original type. */
1631 /* This is a case range. Discard empty ranges.
1632 If the bounds or the range are equal, turn this
1633 into a simple (one-value) case. */
1634 int cmp
= tree_int_cst_compare (high
, low
);
1636 remove_element
= TRUE
;
1643 /* If the simple case value is unreachable, ignore it. */
1644 if ((TREE_CODE (min_value
) == INTEGER_CST
1645 && tree_int_cst_compare (low
, min_value
) < 0)
1646 || (TREE_CODE (max_value
) == INTEGER_CST
1647 && tree_int_cst_compare (low
, max_value
) > 0))
1648 remove_element
= TRUE
;
1650 low
= fold_convert (index_type
, low
);
1654 /* If the entire case range is unreachable, ignore it. */
1655 if ((TREE_CODE (min_value
) == INTEGER_CST
1656 && tree_int_cst_compare (high
, min_value
) < 0)
1657 || (TREE_CODE (max_value
) == INTEGER_CST
1658 && tree_int_cst_compare (low
, max_value
) > 0))
1659 remove_element
= TRUE
;
1662 /* If the lower bound is less than the index type's
1663 minimum value, truncate the range bounds. */
1664 if (TREE_CODE (min_value
) == INTEGER_CST
1665 && tree_int_cst_compare (low
, min_value
) < 0)
1667 low
= fold_convert (index_type
, low
);
1669 /* If the upper bound is greater than the index type's
1670 maximum value, truncate the range bounds. */
1671 if (TREE_CODE (max_value
) == INTEGER_CST
1672 && tree_int_cst_compare (high
, max_value
) > 0)
1674 high
= fold_convert (index_type
, high
);
1676 /* We may have folded a case range to a one-value case. */
1677 if (tree_int_cst_equal (low
, high
))
1682 CASE_LOW (elt
) = low
;
1683 CASE_HIGH (elt
) = high
;
1687 gcc_assert (!default_case
);
1689 /* The default case must be passed separately to the
1690 gimple_build_switch routine. But if DEFAULT_CASEP
1691 is NULL, we do not remove the default case (it would
1692 be completely lost). */
1694 remove_element
= TRUE
;
1698 labels
.ordered_remove (i
);
1704 if (!labels
.is_empty ())
1705 sort_case_labels (labels
);
1707 if (default_casep
&& !default_case
)
1709 /* If the switch has no default label, add one, so that we jump
1710 around the switch body. If the labels already cover the whole
1711 range of the switch index_type, add the default label pointing
1712 to one of the existing labels. */
1714 && TYPE_MIN_VALUE (index_type
)
1715 && TYPE_MAX_VALUE (index_type
)
1716 && tree_int_cst_equal (CASE_LOW (labels
[0]),
1717 TYPE_MIN_VALUE (index_type
)))
1719 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
1721 high
= CASE_LOW (labels
[len
- 1]);
1722 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
1724 for (i
= 1; i
< len
; i
++)
1726 high
= CASE_LOW (labels
[i
]);
1727 low
= CASE_HIGH (labels
[i
- 1]);
1729 low
= CASE_LOW (labels
[i
- 1]);
1730 if ((TREE_INT_CST_LOW (low
) + 1
1731 != TREE_INT_CST_LOW (high
))
1732 || (TREE_INT_CST_HIGH (low
)
1733 + (TREE_INT_CST_LOW (high
) == 0)
1734 != TREE_INT_CST_HIGH (high
)))
1739 tree label
= CASE_LABEL (labels
[0]);
1740 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
1748 *default_casep
= default_case
;
1751 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
1754 static enum gimplify_status
1755 gimplify_switch_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1757 tree switch_expr
= *expr_p
;
1758 gimple_seq switch_body_seq
= NULL
;
1759 enum gimplify_status ret
;
1760 tree index_type
= TREE_TYPE (switch_expr
);
1761 if (index_type
== NULL_TREE
)
1762 index_type
= TREE_TYPE (SWITCH_COND (switch_expr
));
1764 ret
= gimplify_expr (&SWITCH_COND (switch_expr
), pre_p
, NULL
, is_gimple_val
,
1766 if (ret
== GS_ERROR
|| ret
== GS_UNHANDLED
)
1769 if (SWITCH_BODY (switch_expr
))
1772 vec
<tree
> saved_labels
;
1773 tree default_case
= NULL_TREE
;
1774 gimple gimple_switch
;
1776 /* If someone can be bothered to fill in the labels, they can
1777 be bothered to null out the body too. */
1778 gcc_assert (!SWITCH_LABELS (switch_expr
));
1780 /* Save old labels, get new ones from body, then restore the old
1781 labels. Save all the things from the switch body to append after. */
1782 saved_labels
= gimplify_ctxp
->case_labels
;
1783 gimplify_ctxp
->case_labels
.create (8);
1785 gimplify_stmt (&SWITCH_BODY (switch_expr
), &switch_body_seq
);
1786 labels
= gimplify_ctxp
->case_labels
;
1787 gimplify_ctxp
->case_labels
= saved_labels
;
1789 preprocess_case_label_vec_for_gimple (labels
, index_type
,
1797 = build_case_label (NULL_TREE
, NULL_TREE
,
1798 create_artificial_label (UNKNOWN_LOCATION
));
1799 new_default
= gimple_build_label (CASE_LABEL (default_case
));
1800 gimplify_seq_add_stmt (&switch_body_seq
, new_default
);
1803 gimple_switch
= gimple_build_switch (SWITCH_COND (switch_expr
),
1804 default_case
, labels
);
1805 gimplify_seq_add_stmt (pre_p
, gimple_switch
);
1806 gimplify_seq_add_seq (pre_p
, switch_body_seq
);
1810 gcc_assert (SWITCH_LABELS (switch_expr
));
1815 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
1817 static enum gimplify_status
1818 gimplify_case_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1820 struct gimplify_ctx
*ctxp
;
1821 gimple gimple_label
;
1823 /* Invalid OpenMP programs can play Duff's Device type games with
1824 #pragma omp parallel. At least in the C front end, we don't
1825 detect such invalid branches until after gimplification. */
1826 for (ctxp
= gimplify_ctxp
; ; ctxp
= ctxp
->prev_context
)
1827 if (ctxp
->case_labels
.exists ())
1830 gimple_label
= gimple_build_label (CASE_LABEL (*expr_p
));
1831 ctxp
->case_labels
.safe_push (*expr_p
);
1832 gimplify_seq_add_stmt (pre_p
, gimple_label
);
1837 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1841 build_and_jump (tree
*label_p
)
1843 if (label_p
== NULL
)
1844 /* If there's nowhere to jump, just fall through. */
1847 if (*label_p
== NULL_TREE
)
1849 tree label
= create_artificial_label (UNKNOWN_LOCATION
);
1853 return build1 (GOTO_EXPR
, void_type_node
, *label_p
);
1856 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1857 This also involves building a label to jump to and communicating it to
1858 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1860 static enum gimplify_status
1861 gimplify_exit_expr (tree
*expr_p
)
1863 tree cond
= TREE_OPERAND (*expr_p
, 0);
1866 expr
= build_and_jump (&gimplify_ctxp
->exit_label
);
1867 expr
= build3 (COND_EXPR
, void_type_node
, cond
, expr
, NULL_TREE
);
1873 /* A helper function to be called via walk_tree. Mark all labels under *TP
1874 as being forced. To be called for DECL_INITIAL of static variables. */
1877 force_labels_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1881 if (TREE_CODE (*tp
) == LABEL_DECL
)
1882 FORCED_LABEL (*tp
) = 1;
1887 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1888 different from its canonical type, wrap the whole thing inside a
1889 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1892 The canonical type of a COMPONENT_REF is the type of the field being
1893 referenced--unless the field is a bit-field which can be read directly
1894 in a smaller mode, in which case the canonical type is the
1895 sign-appropriate type corresponding to that mode. */
1898 canonicalize_component_ref (tree
*expr_p
)
1900 tree expr
= *expr_p
;
1903 gcc_assert (TREE_CODE (expr
) == COMPONENT_REF
);
1905 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
1906 type
= TREE_TYPE (get_unwidened (expr
, NULL_TREE
));
1908 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
1910 /* One could argue that all the stuff below is not necessary for
1911 the non-bitfield case and declare it a FE error if type
1912 adjustment would be needed. */
1913 if (TREE_TYPE (expr
) != type
)
1915 #ifdef ENABLE_TYPES_CHECKING
1916 tree old_type
= TREE_TYPE (expr
);
1920 /* We need to preserve qualifiers and propagate them from
1922 type_quals
= TYPE_QUALS (type
)
1923 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1924 if (TYPE_QUALS (type
) != type_quals
)
1925 type
= build_qualified_type (TYPE_MAIN_VARIANT (type
), type_quals
);
1927 /* Set the type of the COMPONENT_REF to the underlying type. */
1928 TREE_TYPE (expr
) = type
;
1930 #ifdef ENABLE_TYPES_CHECKING
1931 /* It is now a FE error, if the conversion from the canonical
1932 type to the original expression type is not useless. */
1933 gcc_assert (useless_type_conversion_p (old_type
, type
));
1938 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1939 to foo, embed that change in the ADDR_EXPR by converting
1944 where L is the lower bound. For simplicity, only do this for constant
1946 The constraint is that the type of &array[L] is trivially convertible
1950 canonicalize_addr_expr (tree
*expr_p
)
1952 tree expr
= *expr_p
;
1953 tree addr_expr
= TREE_OPERAND (expr
, 0);
1954 tree datype
, ddatype
, pddatype
;
1956 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1957 if (!POINTER_TYPE_P (TREE_TYPE (expr
))
1958 || TREE_CODE (addr_expr
) != ADDR_EXPR
)
1961 /* The addr_expr type should be a pointer to an array. */
1962 datype
= TREE_TYPE (TREE_TYPE (addr_expr
));
1963 if (TREE_CODE (datype
) != ARRAY_TYPE
)
1966 /* The pointer to element type shall be trivially convertible to
1967 the expression pointer type. */
1968 ddatype
= TREE_TYPE (datype
);
1969 pddatype
= build_pointer_type (ddatype
);
1970 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)),
1974 /* The lower bound and element sizes must be constant. */
1975 if (!TYPE_SIZE_UNIT (ddatype
)
1976 || TREE_CODE (TYPE_SIZE_UNIT (ddatype
)) != INTEGER_CST
1977 || !TYPE_DOMAIN (datype
) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))
1978 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))) != INTEGER_CST
)
1981 /* All checks succeeded. Build a new node to merge the cast. */
1982 *expr_p
= build4 (ARRAY_REF
, ddatype
, TREE_OPERAND (addr_expr
, 0),
1983 TYPE_MIN_VALUE (TYPE_DOMAIN (datype
)),
1984 NULL_TREE
, NULL_TREE
);
1985 *expr_p
= build1 (ADDR_EXPR
, pddatype
, *expr_p
);
1987 /* We can have stripped a required restrict qualifier above. */
1988 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
1989 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
1992 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1993 underneath as appropriate. */
1995 static enum gimplify_status
1996 gimplify_conversion (tree
*expr_p
)
1998 location_t loc
= EXPR_LOCATION (*expr_p
);
1999 gcc_assert (CONVERT_EXPR_P (*expr_p
));
2001 /* Then strip away all but the outermost conversion. */
2002 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p
, 0));
2004 /* And remove the outermost conversion if it's useless. */
2005 if (tree_ssa_useless_type_conversion (*expr_p
))
2006 *expr_p
= TREE_OPERAND (*expr_p
, 0);
2008 /* If we still have a conversion at the toplevel,
2009 then canonicalize some constructs. */
2010 if (CONVERT_EXPR_P (*expr_p
))
2012 tree sub
= TREE_OPERAND (*expr_p
, 0);
2014 /* If a NOP conversion is changing the type of a COMPONENT_REF
2015 expression, then canonicalize its type now in order to expose more
2016 redundant conversions. */
2017 if (TREE_CODE (sub
) == COMPONENT_REF
)
2018 canonicalize_component_ref (&TREE_OPERAND (*expr_p
, 0));
2020 /* If a NOP conversion is changing a pointer to array of foo
2021 to a pointer to foo, embed that change in the ADDR_EXPR. */
2022 else if (TREE_CODE (sub
) == ADDR_EXPR
)
2023 canonicalize_addr_expr (expr_p
);
2026 /* If we have a conversion to a non-register type force the
2027 use of a VIEW_CONVERT_EXPR instead. */
2028 if (CONVERT_EXPR_P (*expr_p
) && !is_gimple_reg_type (TREE_TYPE (*expr_p
)))
2029 *expr_p
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (*expr_p
),
2030 TREE_OPERAND (*expr_p
, 0));
2035 /* Nonlocal VLAs seen in the current function. */
2036 static struct pointer_set_t
*nonlocal_vlas
;
2038 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
2039 DECL_VALUE_EXPR, and it's worth re-examining things. */
2041 static enum gimplify_status
2042 gimplify_var_or_parm_decl (tree
*expr_p
)
2044 tree decl
= *expr_p
;
2046 /* ??? If this is a local variable, and it has not been seen in any
2047 outer BIND_EXPR, then it's probably the result of a duplicate
2048 declaration, for which we've already issued an error. It would
2049 be really nice if the front end wouldn't leak these at all.
2050 Currently the only known culprit is C++ destructors, as seen
2051 in g++.old-deja/g++.jason/binding.C. */
2052 if (TREE_CODE (decl
) == VAR_DECL
2053 && !DECL_SEEN_IN_BIND_EXPR_P (decl
)
2054 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)
2055 && decl_function_context (decl
) == current_function_decl
)
2057 gcc_assert (seen_error ());
2061 /* When within an OpenMP context, notice uses of variables. */
2062 if (gimplify_omp_ctxp
&& omp_notice_variable (gimplify_omp_ctxp
, decl
, true))
2065 /* If the decl is an alias for another expression, substitute it now. */
2066 if (DECL_HAS_VALUE_EXPR_P (decl
))
2068 tree value_expr
= DECL_VALUE_EXPR (decl
);
2070 /* For referenced nonlocal VLAs add a decl for debugging purposes
2071 to the current function. */
2072 if (TREE_CODE (decl
) == VAR_DECL
2073 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
2074 && nonlocal_vlas
!= NULL
2075 && TREE_CODE (value_expr
) == INDIRECT_REF
2076 && TREE_CODE (TREE_OPERAND (value_expr
, 0)) == VAR_DECL
2077 && decl_function_context (decl
) != current_function_decl
)
2079 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
2081 && (ctx
->region_type
== ORT_WORKSHARE
2082 || ctx
->region_type
== ORT_SIMD
))
2083 ctx
= ctx
->outer_context
;
2084 if (!ctx
&& !pointer_set_insert (nonlocal_vlas
, decl
))
2086 tree copy
= copy_node (decl
), block
;
2088 lang_hooks
.dup_lang_specific_decl (copy
);
2089 SET_DECL_RTL (copy
, 0);
2090 TREE_USED (copy
) = 1;
2091 block
= DECL_INITIAL (current_function_decl
);
2092 DECL_CHAIN (copy
) = BLOCK_VARS (block
);
2093 BLOCK_VARS (block
) = copy
;
2094 SET_DECL_VALUE_EXPR (copy
, unshare_expr (value_expr
));
2095 DECL_HAS_VALUE_EXPR_P (copy
) = 1;
2099 *expr_p
= unshare_expr (value_expr
);
2106 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
2110 : min_lval '[' val ']'
2112 | compound_lval '[' val ']'
2113 | compound_lval '.' ID
2115 This is not part of the original SIMPLE definition, which separates
2116 array and member references, but it seems reasonable to handle them
2117 together. Also, this way we don't run into problems with union
2118 aliasing; gcc requires that for accesses through a union to alias, the
2119 union reference must be explicit, which was not always the case when we
2120 were splitting up array and member refs.
2122 PRE_P points to the sequence where side effects that must happen before
2123 *EXPR_P should be stored.
2125 POST_P points to the sequence where side effects that must happen after
2126 *EXPR_P should be stored. */
2128 static enum gimplify_status
2129 gimplify_compound_lval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2130 fallback_t fallback
)
2133 vec
<tree
> expr_stack
;
2134 enum gimplify_status ret
= GS_ALL_DONE
, tret
;
2136 location_t loc
= EXPR_LOCATION (*expr_p
);
2137 tree expr
= *expr_p
;
2139 /* Create a stack of the subexpressions so later we can walk them in
2140 order from inner to outer. */
2141 expr_stack
.create (10);
2143 /* We can handle anything that get_inner_reference can deal with. */
2144 for (p
= expr_p
; ; p
= &TREE_OPERAND (*p
, 0))
2147 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2148 if (TREE_CODE (*p
) == INDIRECT_REF
)
2149 *p
= fold_indirect_ref_loc (loc
, *p
);
2151 if (handled_component_p (*p
))
2153 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2154 additional COMPONENT_REFs. */
2155 else if ((TREE_CODE (*p
) == VAR_DECL
|| TREE_CODE (*p
) == PARM_DECL
)
2156 && gimplify_var_or_parm_decl (p
) == GS_OK
)
2161 expr_stack
.safe_push (*p
);
2164 gcc_assert (expr_stack
.length ());
2166 /* Now EXPR_STACK is a stack of pointers to all the refs we've
2167 walked through and P points to the innermost expression.
2169 Java requires that we elaborated nodes in source order. That
2170 means we must gimplify the inner expression followed by each of
2171 the indices, in order. But we can't gimplify the inner
2172 expression until we deal with any variable bounds, sizes, or
2173 positions in order to deal with PLACEHOLDER_EXPRs.
2175 So we do this in three steps. First we deal with the annotations
2176 for any variables in the components, then we gimplify the base,
2177 then we gimplify any indices, from left to right. */
2178 for (i
= expr_stack
.length () - 1; i
>= 0; i
--)
2180 tree t
= expr_stack
[i
];
2182 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2184 /* Gimplify the low bound and element type size and put them into
2185 the ARRAY_REF. If these values are set, they have already been
2187 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2189 tree low
= unshare_expr (array_ref_low_bound (t
));
2190 if (!is_gimple_min_invariant (low
))
2192 TREE_OPERAND (t
, 2) = low
;
2193 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2194 post_p
, is_gimple_reg
,
2196 ret
= MIN (ret
, tret
);
2201 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2202 is_gimple_reg
, fb_rvalue
);
2203 ret
= MIN (ret
, tret
);
2206 if (TREE_OPERAND (t
, 3) == NULL_TREE
)
2208 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0)));
2209 tree elmt_size
= unshare_expr (array_ref_element_size (t
));
2210 tree factor
= size_int (TYPE_ALIGN_UNIT (elmt_type
));
2212 /* Divide the element size by the alignment of the element
2215 = size_binop_loc (loc
, EXACT_DIV_EXPR
, elmt_size
, factor
);
2217 if (!is_gimple_min_invariant (elmt_size
))
2219 TREE_OPERAND (t
, 3) = elmt_size
;
2220 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
,
2221 post_p
, is_gimple_reg
,
2223 ret
= MIN (ret
, tret
);
2228 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
, post_p
,
2229 is_gimple_reg
, fb_rvalue
);
2230 ret
= MIN (ret
, tret
);
2233 else if (TREE_CODE (t
) == COMPONENT_REF
)
2235 /* Set the field offset into T and gimplify it. */
2236 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2238 tree offset
= unshare_expr (component_ref_field_offset (t
));
2239 tree field
= TREE_OPERAND (t
, 1);
2241 = size_int (DECL_OFFSET_ALIGN (field
) / BITS_PER_UNIT
);
2243 /* Divide the offset by its alignment. */
2244 offset
= size_binop_loc (loc
, EXACT_DIV_EXPR
, offset
, factor
);
2246 if (!is_gimple_min_invariant (offset
))
2248 TREE_OPERAND (t
, 2) = offset
;
2249 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2250 post_p
, is_gimple_reg
,
2252 ret
= MIN (ret
, tret
);
2257 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2258 is_gimple_reg
, fb_rvalue
);
2259 ret
= MIN (ret
, tret
);
2264 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2265 so as to match the min_lval predicate. Failure to do so may result
2266 in the creation of large aggregate temporaries. */
2267 tret
= gimplify_expr (p
, pre_p
, post_p
, is_gimple_min_lval
,
2268 fallback
| fb_lvalue
);
2269 ret
= MIN (ret
, tret
);
2271 /* And finally, the indices and operands of ARRAY_REF. During this
2272 loop we also remove any useless conversions. */
2273 for (; expr_stack
.length () > 0; )
2275 tree t
= expr_stack
.pop ();
2277 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2279 /* Gimplify the dimension. */
2280 if (!is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
2282 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2283 is_gimple_val
, fb_rvalue
);
2284 ret
= MIN (ret
, tret
);
2288 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t
, 0));
2290 /* The innermost expression P may have originally had
2291 TREE_SIDE_EFFECTS set which would have caused all the outer
2292 expressions in *EXPR_P leading to P to also have had
2293 TREE_SIDE_EFFECTS set. */
2294 recalculate_side_effects (t
);
2297 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2298 if ((fallback
& fb_rvalue
) && TREE_CODE (*expr_p
) == COMPONENT_REF
)
2300 canonicalize_component_ref (expr_p
);
2303 expr_stack
.release ();
2305 gcc_assert (*expr_p
== expr
|| ret
!= GS_ALL_DONE
);
2310 /* Gimplify the self modifying expression pointed to by EXPR_P
2313 PRE_P points to the list where side effects that must happen before
2314 *EXPR_P should be stored.
2316 POST_P points to the list where side effects that must happen after
2317 *EXPR_P should be stored.
2319 WANT_VALUE is nonzero iff we want to use the value of this expression
2320 in another expression.
2322 ARITH_TYPE is the type the computation should be performed in. */
2324 enum gimplify_status
2325 gimplify_self_mod_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2326 bool want_value
, tree arith_type
)
2328 enum tree_code code
;
2329 tree lhs
, lvalue
, rhs
, t1
;
2330 gimple_seq post
= NULL
, *orig_post_p
= post_p
;
2332 enum tree_code arith_code
;
2333 enum gimplify_status ret
;
2334 location_t loc
= EXPR_LOCATION (*expr_p
);
2336 code
= TREE_CODE (*expr_p
);
2338 gcc_assert (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
2339 || code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
);
2341 /* Prefix or postfix? */
2342 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
2343 /* Faster to treat as prefix if result is not used. */
2344 postfix
= want_value
;
2348 /* For postfix, make sure the inner expression's post side effects
2349 are executed after side effects from this expression. */
2353 /* Add or subtract? */
2354 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2355 arith_code
= PLUS_EXPR
;
2357 arith_code
= MINUS_EXPR
;
2359 /* Gimplify the LHS into a GIMPLE lvalue. */
2360 lvalue
= TREE_OPERAND (*expr_p
, 0);
2361 ret
= gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
2362 if (ret
== GS_ERROR
)
2365 /* Extract the operands to the arithmetic operation. */
2367 rhs
= TREE_OPERAND (*expr_p
, 1);
2369 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2370 that as the result value and in the postqueue operation. */
2373 ret
= gimplify_expr (&lhs
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
2374 if (ret
== GS_ERROR
)
2377 lhs
= get_initialized_tmp_var (lhs
, pre_p
, NULL
);
2380 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2381 if (POINTER_TYPE_P (TREE_TYPE (lhs
)))
2383 rhs
= convert_to_ptrofftype_loc (loc
, rhs
);
2384 if (arith_code
== MINUS_EXPR
)
2385 rhs
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
2386 t1
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (*expr_p
), lhs
, rhs
);
2389 t1
= fold_convert (TREE_TYPE (*expr_p
),
2390 fold_build2 (arith_code
, arith_type
,
2391 fold_convert (arith_type
, lhs
),
2392 fold_convert (arith_type
, rhs
)));
2396 gimplify_assign (lvalue
, t1
, pre_p
);
2397 gimplify_seq_add_seq (orig_post_p
, post
);
2403 *expr_p
= build2 (MODIFY_EXPR
, TREE_TYPE (lvalue
), lvalue
, t1
);
2408 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2411 maybe_with_size_expr (tree
*expr_p
)
2413 tree expr
= *expr_p
;
2414 tree type
= TREE_TYPE (expr
);
2417 /* If we've already wrapped this or the type is error_mark_node, we can't do
2419 if (TREE_CODE (expr
) == WITH_SIZE_EXPR
2420 || type
== error_mark_node
)
2423 /* If the size isn't known or is a constant, we have nothing to do. */
2424 size
= TYPE_SIZE_UNIT (type
);
2425 if (!size
|| TREE_CODE (size
) == INTEGER_CST
)
2428 /* Otherwise, make a WITH_SIZE_EXPR. */
2429 size
= unshare_expr (size
);
2430 size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (size
, expr
);
2431 *expr_p
= build2 (WITH_SIZE_EXPR
, type
, expr
, size
);
2434 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2435 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2438 static enum gimplify_status
2439 gimplify_arg (tree
*arg_p
, gimple_seq
*pre_p
, location_t call_location
)
2441 bool (*test
) (tree
);
2444 /* In general, we allow lvalues for function arguments to avoid
2445 extra overhead of copying large aggregates out of even larger
2446 aggregates into temporaries only to copy the temporaries to
2447 the argument list. Make optimizers happy by pulling out to
2448 temporaries those types that fit in registers. */
2449 if (is_gimple_reg_type (TREE_TYPE (*arg_p
)))
2450 test
= is_gimple_val
, fb
= fb_rvalue
;
2453 test
= is_gimple_lvalue
, fb
= fb_either
;
2454 /* Also strip a TARGET_EXPR that would force an extra copy. */
2455 if (TREE_CODE (*arg_p
) == TARGET_EXPR
)
2457 tree init
= TARGET_EXPR_INITIAL (*arg_p
);
2459 && !VOID_TYPE_P (TREE_TYPE (init
)))
2464 /* If this is a variable sized type, we must remember the size. */
2465 maybe_with_size_expr (arg_p
);
2467 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2468 /* Make sure arguments have the same location as the function call
2470 protected_set_expr_location (*arg_p
, call_location
);
2472 /* There is a sequence point before a function call. Side effects in
2473 the argument list must occur before the actual call. So, when
2474 gimplifying arguments, force gimplify_expr to use an internal
2475 post queue which is then appended to the end of PRE_P. */
2476 return gimplify_expr (arg_p
, pre_p
, NULL
, test
, fb
);
2479 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2480 WANT_VALUE is true if the result of the call is desired. */
2482 static enum gimplify_status
2483 gimplify_call_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
2485 tree fndecl
, parms
, p
, fnptrtype
;
2486 enum gimplify_status ret
;
2489 bool builtin_va_start_p
= FALSE
;
2490 location_t loc
= EXPR_LOCATION (*expr_p
);
2492 gcc_assert (TREE_CODE (*expr_p
) == CALL_EXPR
);
2494 /* For reliable diagnostics during inlining, it is necessary that
2495 every call_expr be annotated with file and line. */
2496 if (! EXPR_HAS_LOCATION (*expr_p
))
2497 SET_EXPR_LOCATION (*expr_p
, input_location
);
2499 /* This may be a call to a builtin function.
2501 Builtin function calls may be transformed into different
2502 (and more efficient) builtin function calls under certain
2503 circumstances. Unfortunately, gimplification can muck things
2504 up enough that the builtin expanders are not aware that certain
2505 transformations are still valid.
2507 So we attempt transformation/gimplification of the call before
2508 we gimplify the CALL_EXPR. At this time we do not manage to
2509 transform all calls in the same manner as the expanders do, but
2510 we do transform most of them. */
2511 fndecl
= get_callee_fndecl (*expr_p
);
2513 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
2514 switch (DECL_FUNCTION_CODE (fndecl
))
2516 case BUILT_IN_VA_START
:
2518 builtin_va_start_p
= TRUE
;
2519 if (call_expr_nargs (*expr_p
) < 2)
2521 error ("too few arguments to function %<va_start%>");
2522 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2526 if (fold_builtin_next_arg (*expr_p
, true))
2528 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2535 expanded_location loc
= expand_location (EXPR_LOCATION (*expr_p
));
2536 *expr_p
= build_int_cst (TREE_TYPE (*expr_p
), loc
.line
);
2541 expanded_location loc
= expand_location (EXPR_LOCATION (*expr_p
));
2542 *expr_p
= build_string_literal (strlen (loc
.file
) + 1, loc
.file
);
2545 case BUILT_IN_FUNCTION
:
2547 const char *function
;
2548 function
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
2549 *expr_p
= build_string_literal (strlen (function
) + 1, function
);
2555 if (fndecl
&& DECL_BUILT_IN (fndecl
))
2557 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2558 if (new_tree
&& new_tree
!= *expr_p
)
2560 /* There was a transformation of this call which computes the
2561 same value, but in a more efficient way. Return and try
2568 /* Remember the original function pointer type. */
2569 fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*expr_p
));
2571 /* There is a sequence point before the call, so any side effects in
2572 the calling expression must occur before the actual call. Force
2573 gimplify_expr to use an internal post queue. */
2574 ret
= gimplify_expr (&CALL_EXPR_FN (*expr_p
), pre_p
, NULL
,
2575 is_gimple_call_addr
, fb_rvalue
);
2577 nargs
= call_expr_nargs (*expr_p
);
2579 /* Get argument types for verification. */
2580 fndecl
= get_callee_fndecl (*expr_p
);
2583 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2584 else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p
))))
2585 parms
= TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p
))));
2587 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
2588 p
= DECL_ARGUMENTS (fndecl
);
2593 for (i
= 0; i
< nargs
&& p
; i
++, p
= TREE_CHAIN (p
))
2596 /* If the last argument is __builtin_va_arg_pack () and it is not
2597 passed as a named argument, decrease the number of CALL_EXPR
2598 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2601 && TREE_CODE (CALL_EXPR_ARG (*expr_p
, nargs
- 1)) == CALL_EXPR
)
2603 tree last_arg
= CALL_EXPR_ARG (*expr_p
, nargs
- 1);
2604 tree last_arg_fndecl
= get_callee_fndecl (last_arg
);
2607 && TREE_CODE (last_arg_fndecl
) == FUNCTION_DECL
2608 && DECL_BUILT_IN_CLASS (last_arg_fndecl
) == BUILT_IN_NORMAL
2609 && DECL_FUNCTION_CODE (last_arg_fndecl
) == BUILT_IN_VA_ARG_PACK
)
2611 tree call
= *expr_p
;
2614 *expr_p
= build_call_array_loc (loc
, TREE_TYPE (call
),
2615 CALL_EXPR_FN (call
),
2616 nargs
, CALL_EXPR_ARGP (call
));
2618 /* Copy all CALL_EXPR flags, location and block, except
2619 CALL_EXPR_VA_ARG_PACK flag. */
2620 CALL_EXPR_STATIC_CHAIN (*expr_p
) = CALL_EXPR_STATIC_CHAIN (call
);
2621 CALL_EXPR_TAILCALL (*expr_p
) = CALL_EXPR_TAILCALL (call
);
2622 CALL_EXPR_RETURN_SLOT_OPT (*expr_p
)
2623 = CALL_EXPR_RETURN_SLOT_OPT (call
);
2624 CALL_FROM_THUNK_P (*expr_p
) = CALL_FROM_THUNK_P (call
);
2625 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (call
));
2627 /* Set CALL_EXPR_VA_ARG_PACK. */
2628 CALL_EXPR_VA_ARG_PACK (*expr_p
) = 1;
2632 /* Finally, gimplify the function arguments. */
2635 for (i
= (PUSH_ARGS_REVERSED
? nargs
- 1 : 0);
2636 PUSH_ARGS_REVERSED
? i
>= 0 : i
< nargs
;
2637 PUSH_ARGS_REVERSED
? i
-- : i
++)
2639 enum gimplify_status t
;
2641 /* Avoid gimplifying the second argument to va_start, which needs to
2642 be the plain PARM_DECL. */
2643 if ((i
!= 1) || !builtin_va_start_p
)
2645 t
= gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
2646 EXPR_LOCATION (*expr_p
));
2654 /* Verify the function result. */
2655 if (want_value
&& fndecl
2656 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype
))))
2658 error_at (loc
, "using result of function returning %<void%>");
2662 /* Try this again in case gimplification exposed something. */
2663 if (ret
!= GS_ERROR
)
2665 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2667 if (new_tree
&& new_tree
!= *expr_p
)
2669 /* There was a transformation of this call which computes the
2670 same value, but in a more efficient way. Return and try
2678 *expr_p
= error_mark_node
;
2682 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2683 decl. This allows us to eliminate redundant or useless
2684 calls to "const" functions. */
2685 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
2687 int flags
= call_expr_flags (*expr_p
);
2688 if (flags
& (ECF_CONST
| ECF_PURE
)
2689 /* An infinite loop is considered a side effect. */
2690 && !(flags
& (ECF_LOOPING_CONST_OR_PURE
)))
2691 TREE_SIDE_EFFECTS (*expr_p
) = 0;
2694 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2695 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2696 form and delegate the creation of a GIMPLE_CALL to
2697 gimplify_modify_expr. This is always possible because when
2698 WANT_VALUE is true, the caller wants the result of this call into
2699 a temporary, which means that we will emit an INIT_EXPR in
2700 internal_get_tmp_var which will then be handled by
2701 gimplify_modify_expr. */
2704 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2705 have to do is replicate it as a GIMPLE_CALL tuple. */
2706 gimple_stmt_iterator gsi
;
2707 call
= gimple_build_call_from_tree (*expr_p
);
2708 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
2709 notice_special_calls (call
);
2710 gimplify_seq_add_stmt (pre_p
, call
);
2711 gsi
= gsi_last (*pre_p
);
2712 /* Don't fold stmts inside of target construct. We'll do it
2713 during omplower pass instead. */
2714 struct gimplify_omp_ctx
*ctx
;
2715 for (ctx
= gimplify_omp_ctxp
; ctx
; ctx
= ctx
->outer_context
)
2716 if (ctx
->region_type
== ORT_TARGET
)
2720 *expr_p
= NULL_TREE
;
2723 /* Remember the original function type. */
2724 CALL_EXPR_FN (*expr_p
) = build1 (NOP_EXPR
, fnptrtype
,
2725 CALL_EXPR_FN (*expr_p
));
2730 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2731 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2733 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2734 condition is true or false, respectively. If null, we should generate
2735 our own to skip over the evaluation of this specific expression.
2737 LOCUS is the source location of the COND_EXPR.
2739 This function is the tree equivalent of do_jump.
2741 shortcut_cond_r should only be called by shortcut_cond_expr. */
2744 shortcut_cond_r (tree pred
, tree
*true_label_p
, tree
*false_label_p
,
2747 tree local_label
= NULL_TREE
;
2748 tree t
, expr
= NULL
;
2750 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2751 retain the shortcut semantics. Just insert the gotos here;
2752 shortcut_cond_expr will append the real blocks later. */
2753 if (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2755 location_t new_locus
;
2757 /* Turn if (a && b) into
2759 if (a); else goto no;
2760 if (b) goto yes; else goto no;
2763 if (false_label_p
== NULL
)
2764 false_label_p
= &local_label
;
2766 /* Keep the original source location on the first 'if'. */
2767 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), NULL
, false_label_p
, locus
);
2768 append_to_statement_list (t
, &expr
);
2770 /* Set the source location of the && on the second 'if'. */
2771 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2772 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2774 append_to_statement_list (t
, &expr
);
2776 else if (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2778 location_t new_locus
;
2780 /* Turn if (a || b) into
2783 if (b) goto yes; else goto no;
2786 if (true_label_p
== NULL
)
2787 true_label_p
= &local_label
;
2789 /* Keep the original source location on the first 'if'. */
2790 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), true_label_p
, NULL
, locus
);
2791 append_to_statement_list (t
, &expr
);
2793 /* Set the source location of the || on the second 'if'. */
2794 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2795 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2797 append_to_statement_list (t
, &expr
);
2799 else if (TREE_CODE (pred
) == COND_EXPR
2800 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 1)))
2801 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 2))))
2803 location_t new_locus
;
2805 /* As long as we're messing with gotos, turn if (a ? b : c) into
2807 if (b) goto yes; else goto no;
2809 if (c) goto yes; else goto no;
2811 Don't do this if one of the arms has void type, which can happen
2812 in C++ when the arm is throw. */
2814 /* Keep the original source location on the first 'if'. Set the source
2815 location of the ? on the second 'if'. */
2816 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2817 expr
= build3 (COND_EXPR
, void_type_node
, TREE_OPERAND (pred
, 0),
2818 shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
,
2819 false_label_p
, locus
),
2820 shortcut_cond_r (TREE_OPERAND (pred
, 2), true_label_p
,
2821 false_label_p
, new_locus
));
2825 expr
= build3 (COND_EXPR
, void_type_node
, pred
,
2826 build_and_jump (true_label_p
),
2827 build_and_jump (false_label_p
));
2828 SET_EXPR_LOCATION (expr
, locus
);
2833 t
= build1 (LABEL_EXPR
, void_type_node
, local_label
);
2834 append_to_statement_list (t
, &expr
);
2840 /* Given a conditional expression EXPR with short-circuit boolean
2841 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2842 predicate apart into the equivalent sequence of conditionals. */
2845 shortcut_cond_expr (tree expr
)
2847 tree pred
= TREE_OPERAND (expr
, 0);
2848 tree then_
= TREE_OPERAND (expr
, 1);
2849 tree else_
= TREE_OPERAND (expr
, 2);
2850 tree true_label
, false_label
, end_label
, t
;
2852 tree
*false_label_p
;
2853 bool emit_end
, emit_false
, jump_over_else
;
2854 bool then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2855 bool else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2857 /* First do simple transformations. */
2860 /* If there is no 'else', turn
2863 if (a) if (b) then c. */
2864 while (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2866 /* Keep the original source location on the first 'if'. */
2867 location_t locus
= EXPR_LOC_OR_HERE (expr
);
2868 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2869 /* Set the source location of the && on the second 'if'. */
2870 if (EXPR_HAS_LOCATION (pred
))
2871 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2872 then_
= shortcut_cond_expr (expr
);
2873 then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2874 pred
= TREE_OPERAND (pred
, 0);
2875 expr
= build3 (COND_EXPR
, void_type_node
, pred
, then_
, NULL_TREE
);
2876 SET_EXPR_LOCATION (expr
, locus
);
2882 /* If there is no 'then', turn
2885 if (a); else if (b); else d. */
2886 while (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2888 /* Keep the original source location on the first 'if'. */
2889 location_t locus
= EXPR_LOC_OR_HERE (expr
);
2890 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2891 /* Set the source location of the || on the second 'if'. */
2892 if (EXPR_HAS_LOCATION (pred
))
2893 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2894 else_
= shortcut_cond_expr (expr
);
2895 else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2896 pred
= TREE_OPERAND (pred
, 0);
2897 expr
= build3 (COND_EXPR
, void_type_node
, pred
, NULL_TREE
, else_
);
2898 SET_EXPR_LOCATION (expr
, locus
);
2902 /* If we're done, great. */
2903 if (TREE_CODE (pred
) != TRUTH_ANDIF_EXPR
2904 && TREE_CODE (pred
) != TRUTH_ORIF_EXPR
)
2907 /* Otherwise we need to mess with gotos. Change
2910 if (a); else goto no;
2913 and recursively gimplify the condition. */
2915 true_label
= false_label
= end_label
= NULL_TREE
;
2917 /* If our arms just jump somewhere, hijack those labels so we don't
2918 generate jumps to jumps. */
2921 && TREE_CODE (then_
) == GOTO_EXPR
2922 && TREE_CODE (GOTO_DESTINATION (then_
)) == LABEL_DECL
)
2924 true_label
= GOTO_DESTINATION (then_
);
2930 && TREE_CODE (else_
) == GOTO_EXPR
2931 && TREE_CODE (GOTO_DESTINATION (else_
)) == LABEL_DECL
)
2933 false_label
= GOTO_DESTINATION (else_
);
2938 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2940 true_label_p
= &true_label
;
2942 true_label_p
= NULL
;
2944 /* The 'else' branch also needs a label if it contains interesting code. */
2945 if (false_label
|| else_se
)
2946 false_label_p
= &false_label
;
2948 false_label_p
= NULL
;
2950 /* If there was nothing else in our arms, just forward the label(s). */
2951 if (!then_se
&& !else_se
)
2952 return shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2953 EXPR_LOC_OR_HERE (expr
));
2955 /* If our last subexpression already has a terminal label, reuse it. */
2957 t
= expr_last (else_
);
2959 t
= expr_last (then_
);
2962 if (t
&& TREE_CODE (t
) == LABEL_EXPR
)
2963 end_label
= LABEL_EXPR_LABEL (t
);
2965 /* If we don't care about jumping to the 'else' branch, jump to the end
2966 if the condition is false. */
2968 false_label_p
= &end_label
;
2970 /* We only want to emit these labels if we aren't hijacking them. */
2971 emit_end
= (end_label
== NULL_TREE
);
2972 emit_false
= (false_label
== NULL_TREE
);
2974 /* We only emit the jump over the else clause if we have to--if the
2975 then clause may fall through. Otherwise we can wind up with a
2976 useless jump and a useless label at the end of gimplified code,
2977 which will cause us to think that this conditional as a whole
2978 falls through even if it doesn't. If we then inline a function
2979 which ends with such a condition, that can cause us to issue an
2980 inappropriate warning about control reaching the end of a
2981 non-void function. */
2982 jump_over_else
= block_may_fallthru (then_
);
2984 pred
= shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2985 EXPR_LOC_OR_HERE (expr
));
2988 append_to_statement_list (pred
, &expr
);
2990 append_to_statement_list (then_
, &expr
);
2995 tree last
= expr_last (expr
);
2996 t
= build_and_jump (&end_label
);
2997 if (EXPR_HAS_LOCATION (last
))
2998 SET_EXPR_LOCATION (t
, EXPR_LOCATION (last
));
2999 append_to_statement_list (t
, &expr
);
3003 t
= build1 (LABEL_EXPR
, void_type_node
, false_label
);
3004 append_to_statement_list (t
, &expr
);
3006 append_to_statement_list (else_
, &expr
);
3008 if (emit_end
&& end_label
)
3010 t
= build1 (LABEL_EXPR
, void_type_node
, end_label
);
3011 append_to_statement_list (t
, &expr
);
3017 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
3020 gimple_boolify (tree expr
)
3022 tree type
= TREE_TYPE (expr
);
3023 location_t loc
= EXPR_LOCATION (expr
);
3025 if (TREE_CODE (expr
) == NE_EXPR
3026 && TREE_CODE (TREE_OPERAND (expr
, 0)) == CALL_EXPR
3027 && integer_zerop (TREE_OPERAND (expr
, 1)))
3029 tree call
= TREE_OPERAND (expr
, 0);
3030 tree fn
= get_callee_fndecl (call
);
3032 /* For __builtin_expect ((long) (x), y) recurse into x as well
3033 if x is truth_value_p. */
3035 && DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
3036 && DECL_FUNCTION_CODE (fn
) == BUILT_IN_EXPECT
3037 && call_expr_nargs (call
) == 2)
3039 tree arg
= CALL_EXPR_ARG (call
, 0);
3042 if (TREE_CODE (arg
) == NOP_EXPR
3043 && TREE_TYPE (arg
) == TREE_TYPE (call
))
3044 arg
= TREE_OPERAND (arg
, 0);
3045 if (truth_value_p (TREE_CODE (arg
)))
3047 arg
= gimple_boolify (arg
);
3048 CALL_EXPR_ARG (call
, 0)
3049 = fold_convert_loc (loc
, TREE_TYPE (call
), arg
);
3055 switch (TREE_CODE (expr
))
3057 case TRUTH_AND_EXPR
:
3059 case TRUTH_XOR_EXPR
:
3060 case TRUTH_ANDIF_EXPR
:
3061 case TRUTH_ORIF_EXPR
:
3062 /* Also boolify the arguments of truth exprs. */
3063 TREE_OPERAND (expr
, 1) = gimple_boolify (TREE_OPERAND (expr
, 1));
3066 case TRUTH_NOT_EXPR
:
3067 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3069 /* These expressions always produce boolean results. */
3070 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3071 TREE_TYPE (expr
) = boolean_type_node
;
3075 if (COMPARISON_CLASS_P (expr
))
3077 /* There expressions always prduce boolean results. */
3078 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3079 TREE_TYPE (expr
) = boolean_type_node
;
3082 /* Other expressions that get here must have boolean values, but
3083 might need to be converted to the appropriate mode. */
3084 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
3086 return fold_convert_loc (loc
, boolean_type_node
, expr
);
3090 /* Given a conditional expression *EXPR_P without side effects, gimplify
3091 its operands. New statements are inserted to PRE_P. */
3093 static enum gimplify_status
3094 gimplify_pure_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
)
3096 tree expr
= *expr_p
, cond
;
3097 enum gimplify_status ret
, tret
;
3098 enum tree_code code
;
3100 cond
= gimple_boolify (COND_EXPR_COND (expr
));
3102 /* We need to handle && and || specially, as their gimplification
3103 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
3104 code
= TREE_CODE (cond
);
3105 if (code
== TRUTH_ANDIF_EXPR
)
3106 TREE_SET_CODE (cond
, TRUTH_AND_EXPR
);
3107 else if (code
== TRUTH_ORIF_EXPR
)
3108 TREE_SET_CODE (cond
, TRUTH_OR_EXPR
);
3109 ret
= gimplify_expr (&cond
, pre_p
, NULL
, is_gimple_condexpr
, fb_rvalue
);
3110 COND_EXPR_COND (*expr_p
) = cond
;
3112 tret
= gimplify_expr (&COND_EXPR_THEN (expr
), pre_p
, NULL
,
3113 is_gimple_val
, fb_rvalue
);
3114 ret
= MIN (ret
, tret
);
3115 tret
= gimplify_expr (&COND_EXPR_ELSE (expr
), pre_p
, NULL
,
3116 is_gimple_val
, fb_rvalue
);
3118 return MIN (ret
, tret
);
3121 /* Return true if evaluating EXPR could trap.
3122 EXPR is GENERIC, while tree_could_trap_p can be called
3126 generic_expr_could_trap_p (tree expr
)
3130 if (!expr
|| is_gimple_val (expr
))
3133 if (!EXPR_P (expr
) || tree_could_trap_p (expr
))
3136 n
= TREE_OPERAND_LENGTH (expr
);
3137 for (i
= 0; i
< n
; i
++)
3138 if (generic_expr_could_trap_p (TREE_OPERAND (expr
, i
)))
3144 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3153 The second form is used when *EXPR_P is of type void.
3155 PRE_P points to the list where side effects that must happen before
3156 *EXPR_P should be stored. */
3158 static enum gimplify_status
3159 gimplify_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
, fallback_t fallback
)
3161 tree expr
= *expr_p
;
3162 tree type
= TREE_TYPE (expr
);
3163 location_t loc
= EXPR_LOCATION (expr
);
3164 tree tmp
, arm1
, arm2
;
3165 enum gimplify_status ret
;
3166 tree label_true
, label_false
, label_cont
;
3167 bool have_then_clause_p
, have_else_clause_p
;
3169 enum tree_code pred_code
;
3170 gimple_seq seq
= NULL
;
3172 /* If this COND_EXPR has a value, copy the values into a temporary within
3174 if (!VOID_TYPE_P (type
))
3176 tree then_
= TREE_OPERAND (expr
, 1), else_
= TREE_OPERAND (expr
, 2);
3179 /* If either an rvalue is ok or we do not require an lvalue, create the
3180 temporary. But we cannot do that if the type is addressable. */
3181 if (((fallback
& fb_rvalue
) || !(fallback
& fb_lvalue
))
3182 && !TREE_ADDRESSABLE (type
))
3184 if (gimplify_ctxp
->allow_rhs_cond_expr
3185 /* If either branch has side effects or could trap, it can't be
3186 evaluated unconditionally. */
3187 && !TREE_SIDE_EFFECTS (then_
)
3188 && !generic_expr_could_trap_p (then_
)
3189 && !TREE_SIDE_EFFECTS (else_
)
3190 && !generic_expr_could_trap_p (else_
))
3191 return gimplify_pure_cond_expr (expr_p
, pre_p
);
3193 tmp
= create_tmp_var (type
, "iftmp");
3197 /* Otherwise, only create and copy references to the values. */
3200 type
= build_pointer_type (type
);
3202 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3203 then_
= build_fold_addr_expr_loc (loc
, then_
);
3205 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3206 else_
= build_fold_addr_expr_loc (loc
, else_
);
3209 = build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0), then_
, else_
);
3211 tmp
= create_tmp_var (type
, "iftmp");
3212 result
= build_simple_mem_ref_loc (loc
, tmp
);
3215 /* Build the new then clause, `tmp = then_;'. But don't build the
3216 assignment if the value is void; in C++ it can be if it's a throw. */
3217 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3218 TREE_OPERAND (expr
, 1) = build2 (MODIFY_EXPR
, type
, tmp
, then_
);
3220 /* Similarly, build the new else clause, `tmp = else_;'. */
3221 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3222 TREE_OPERAND (expr
, 2) = build2 (MODIFY_EXPR
, type
, tmp
, else_
);
3224 TREE_TYPE (expr
) = void_type_node
;
3225 recalculate_side_effects (expr
);
3227 /* Move the COND_EXPR to the prequeue. */
3228 gimplify_stmt (&expr
, pre_p
);
3234 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
3235 STRIP_TYPE_NOPS (TREE_OPERAND (expr
, 0));
3236 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == COMPOUND_EXPR
)
3237 gimplify_compound_expr (&TREE_OPERAND (expr
, 0), pre_p
, true);
3239 /* Make sure the condition has BOOLEAN_TYPE. */
3240 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3242 /* Break apart && and || conditions. */
3243 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ANDIF_EXPR
3244 || TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ORIF_EXPR
)
3246 expr
= shortcut_cond_expr (expr
);
3248 if (expr
!= *expr_p
)
3252 /* We can't rely on gimplify_expr to re-gimplify the expanded
3253 form properly, as cleanups might cause the target labels to be
3254 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3255 set up a conditional context. */
3256 gimple_push_condition ();
3257 gimplify_stmt (expr_p
, &seq
);
3258 gimple_pop_condition (pre_p
);
3259 gimple_seq_add_seq (pre_p
, seq
);
3265 /* Now do the normal gimplification. */
3267 /* Gimplify condition. */
3268 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, NULL
, is_gimple_condexpr
,
3270 if (ret
== GS_ERROR
)
3272 gcc_assert (TREE_OPERAND (expr
, 0) != NULL_TREE
);
3274 gimple_push_condition ();
3276 have_then_clause_p
= have_else_clause_p
= false;
3277 if (TREE_OPERAND (expr
, 1) != NULL
3278 && TREE_CODE (TREE_OPERAND (expr
, 1)) == GOTO_EXPR
3279 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 1))) == LABEL_DECL
3280 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 1)))
3281 == current_function_decl
)
3282 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3283 have different locations, otherwise we end up with incorrect
3284 location information on the branches. */
3286 || !EXPR_HAS_LOCATION (expr
)
3287 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 1))
3288 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 1))))
3290 label_true
= GOTO_DESTINATION (TREE_OPERAND (expr
, 1));
3291 have_then_clause_p
= true;
3294 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
3295 if (TREE_OPERAND (expr
, 2) != NULL
3296 && TREE_CODE (TREE_OPERAND (expr
, 2)) == GOTO_EXPR
3297 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 2))) == LABEL_DECL
3298 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 2)))
3299 == current_function_decl
)
3300 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3301 have different locations, otherwise we end up with incorrect
3302 location information on the branches. */
3304 || !EXPR_HAS_LOCATION (expr
)
3305 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 2))
3306 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 2))))
3308 label_false
= GOTO_DESTINATION (TREE_OPERAND (expr
, 2));
3309 have_else_clause_p
= true;
3312 label_false
= create_artificial_label (UNKNOWN_LOCATION
);
3314 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr
), &pred_code
, &arm1
,
3317 gimple_cond
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
,
3320 gimplify_seq_add_stmt (&seq
, gimple_cond
);
3321 label_cont
= NULL_TREE
;
3322 if (!have_then_clause_p
)
3324 /* For if (...) {} else { code; } put label_true after
3326 if (TREE_OPERAND (expr
, 1) == NULL_TREE
3327 && !have_else_clause_p
3328 && TREE_OPERAND (expr
, 2) != NULL_TREE
)
3329 label_cont
= label_true
;
3332 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_true
));
3333 have_then_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 1), &seq
);
3334 /* For if (...) { code; } else {} or
3335 if (...) { code; } else goto label; or
3336 if (...) { code; return; } else { ... }
3337 label_cont isn't needed. */
3338 if (!have_else_clause_p
3339 && TREE_OPERAND (expr
, 2) != NULL_TREE
3340 && gimple_seq_may_fallthru (seq
))
3343 label_cont
= create_artificial_label (UNKNOWN_LOCATION
);
3345 g
= gimple_build_goto (label_cont
);
3347 /* GIMPLE_COND's are very low level; they have embedded
3348 gotos. This particular embedded goto should not be marked
3349 with the location of the original COND_EXPR, as it would
3350 correspond to the COND_EXPR's condition, not the ELSE or the
3351 THEN arms. To avoid marking it with the wrong location, flag
3352 it as "no location". */
3353 gimple_set_do_not_emit_location (g
);
3355 gimplify_seq_add_stmt (&seq
, g
);
3359 if (!have_else_clause_p
)
3361 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_false
));
3362 have_else_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 2), &seq
);
3365 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_cont
));
3367 gimple_pop_condition (pre_p
);
3368 gimple_seq_add_seq (pre_p
, seq
);
3370 if (ret
== GS_ERROR
)
3372 else if (have_then_clause_p
|| have_else_clause_p
)
3376 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3377 expr
= TREE_OPERAND (expr
, 0);
3378 gimplify_stmt (&expr
, pre_p
);
3385 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3386 to be marked addressable.
3388 We cannot rely on such an expression being directly markable if a temporary
3389 has been created by the gimplification. In this case, we create another
3390 temporary and initialize it with a copy, which will become a store after we
3391 mark it addressable. This can happen if the front-end passed us something
3392 that it could not mark addressable yet, like a Fortran pass-by-reference
3393 parameter (int) floatvar. */
3396 prepare_gimple_addressable (tree
*expr_p
, gimple_seq
*seq_p
)
3398 while (handled_component_p (*expr_p
))
3399 expr_p
= &TREE_OPERAND (*expr_p
, 0);
3400 if (is_gimple_reg (*expr_p
))
3401 *expr_p
= get_initialized_tmp_var (*expr_p
, seq_p
, NULL
);
3404 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3405 a call to __builtin_memcpy. */
3407 static enum gimplify_status
3408 gimplify_modify_expr_to_memcpy (tree
*expr_p
, tree size
, bool want_value
,
3411 tree t
, to
, to_ptr
, from
, from_ptr
;
3413 location_t loc
= EXPR_LOCATION (*expr_p
);
3415 to
= TREE_OPERAND (*expr_p
, 0);
3416 from
= TREE_OPERAND (*expr_p
, 1);
3418 /* Mark the RHS addressable. Beware that it may not be possible to do so
3419 directly if a temporary has been created by the gimplification. */
3420 prepare_gimple_addressable (&from
, seq_p
);
3422 mark_addressable (from
);
3423 from_ptr
= build_fold_addr_expr_loc (loc
, from
);
3424 gimplify_arg (&from_ptr
, seq_p
, loc
);
3426 mark_addressable (to
);
3427 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3428 gimplify_arg (&to_ptr
, seq_p
, loc
);
3430 t
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3432 gs
= gimple_build_call (t
, 3, to_ptr
, from_ptr
, size
);
3436 /* tmp = memcpy() */
3437 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3438 gimple_call_set_lhs (gs
, t
);
3439 gimplify_seq_add_stmt (seq_p
, gs
);
3441 *expr_p
= build_simple_mem_ref (t
);
3445 gimplify_seq_add_stmt (seq_p
, gs
);
3450 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3451 a call to __builtin_memset. In this case we know that the RHS is
3452 a CONSTRUCTOR with an empty element list. */
3454 static enum gimplify_status
3455 gimplify_modify_expr_to_memset (tree
*expr_p
, tree size
, bool want_value
,
3458 tree t
, from
, to
, to_ptr
;
3460 location_t loc
= EXPR_LOCATION (*expr_p
);
3462 /* Assert our assumptions, to abort instead of producing wrong code
3463 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3464 not be immediately exposed. */
3465 from
= TREE_OPERAND (*expr_p
, 1);
3466 if (TREE_CODE (from
) == WITH_SIZE_EXPR
)
3467 from
= TREE_OPERAND (from
, 0);
3469 gcc_assert (TREE_CODE (from
) == CONSTRUCTOR
3470 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from
)));
3473 to
= TREE_OPERAND (*expr_p
, 0);
3475 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3476 gimplify_arg (&to_ptr
, seq_p
, loc
);
3477 t
= builtin_decl_implicit (BUILT_IN_MEMSET
);
3479 gs
= gimple_build_call (t
, 3, to_ptr
, integer_zero_node
, size
);
3483 /* tmp = memset() */
3484 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3485 gimple_call_set_lhs (gs
, t
);
3486 gimplify_seq_add_stmt (seq_p
, gs
);
3488 *expr_p
= build1 (INDIRECT_REF
, TREE_TYPE (to
), t
);
3492 gimplify_seq_add_stmt (seq_p
, gs
);
3497 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3498 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3499 assignment. Return non-null if we detect a potential overlap. */
3501 struct gimplify_init_ctor_preeval_data
3503 /* The base decl of the lhs object. May be NULL, in which case we
3504 have to assume the lhs is indirect. */
3507 /* The alias set of the lhs object. */
3508 alias_set_type lhs_alias_set
;
3512 gimplify_init_ctor_preeval_1 (tree
*tp
, int *walk_subtrees
, void *xdata
)
3514 struct gimplify_init_ctor_preeval_data
*data
3515 = (struct gimplify_init_ctor_preeval_data
*) xdata
;
3518 /* If we find the base object, obviously we have overlap. */
3519 if (data
->lhs_base_decl
== t
)
3522 /* If the constructor component is indirect, determine if we have a
3523 potential overlap with the lhs. The only bits of information we
3524 have to go on at this point are addressability and alias sets. */
3525 if ((INDIRECT_REF_P (t
)
3526 || TREE_CODE (t
) == MEM_REF
)
3527 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3528 && alias_sets_conflict_p (data
->lhs_alias_set
, get_alias_set (t
)))
3531 /* If the constructor component is a call, determine if it can hide a
3532 potential overlap with the lhs through an INDIRECT_REF like above.
3533 ??? Ugh - this is completely broken. In fact this whole analysis
3534 doesn't look conservative. */
3535 if (TREE_CODE (t
) == CALL_EXPR
)
3537 tree type
, fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t
)));
3539 for (type
= TYPE_ARG_TYPES (fntype
); type
; type
= TREE_CHAIN (type
))
3540 if (POINTER_TYPE_P (TREE_VALUE (type
))
3541 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3542 && alias_sets_conflict_p (data
->lhs_alias_set
,
3544 (TREE_TYPE (TREE_VALUE (type
)))))
3548 if (IS_TYPE_OR_DECL_P (t
))
3553 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3554 force values that overlap with the lhs (as described by *DATA)
3555 into temporaries. */
3558 gimplify_init_ctor_preeval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3559 struct gimplify_init_ctor_preeval_data
*data
)
3561 enum gimplify_status one
;
3563 /* If the value is constant, then there's nothing to pre-evaluate. */
3564 if (TREE_CONSTANT (*expr_p
))
3566 /* Ensure it does not have side effects, it might contain a reference to
3567 the object we're initializing. */
3568 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p
));
3572 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3573 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p
)))
3576 /* Recurse for nested constructors. */
3577 if (TREE_CODE (*expr_p
) == CONSTRUCTOR
)
3579 unsigned HOST_WIDE_INT ix
;
3580 constructor_elt
*ce
;
3581 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (*expr_p
);
3583 FOR_EACH_VEC_SAFE_ELT (v
, ix
, ce
)
3584 gimplify_init_ctor_preeval (&ce
->value
, pre_p
, post_p
, data
);
3589 /* If this is a variable sized type, we must remember the size. */
3590 maybe_with_size_expr (expr_p
);
3592 /* Gimplify the constructor element to something appropriate for the rhs
3593 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3594 the gimplifier will consider this a store to memory. Doing this
3595 gimplification now means that we won't have to deal with complicated
3596 language-specific trees, nor trees like SAVE_EXPR that can induce
3597 exponential search behavior. */
3598 one
= gimplify_expr (expr_p
, pre_p
, post_p
, is_gimple_mem_rhs
, fb_rvalue
);
3599 if (one
== GS_ERROR
)
3605 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3606 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3607 always be true for all scalars, since is_gimple_mem_rhs insists on a
3608 temporary variable for them. */
3609 if (DECL_P (*expr_p
))
3612 /* If this is of variable size, we have no choice but to assume it doesn't
3613 overlap since we can't make a temporary for it. */
3614 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p
))) != INTEGER_CST
)
3617 /* Otherwise, we must search for overlap ... */
3618 if (!walk_tree (expr_p
, gimplify_init_ctor_preeval_1
, data
, NULL
))
3621 /* ... and if found, force the value into a temporary. */
3622 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
3625 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3626 a RANGE_EXPR in a CONSTRUCTOR for an array.
3630 object[var] = value;
3637 We increment var _after_ the loop exit check because we might otherwise
3638 fail if upper == TYPE_MAX_VALUE (type for upper).
3640 Note that we never have to deal with SAVE_EXPRs here, because this has
3641 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3643 static void gimplify_init_ctor_eval (tree
, vec
<constructor_elt
, va_gc
> *,
3644 gimple_seq
*, bool);
3647 gimplify_init_ctor_eval_range (tree object
, tree lower
, tree upper
,
3648 tree value
, tree array_elt_type
,
3649 gimple_seq
*pre_p
, bool cleared
)
3651 tree loop_entry_label
, loop_exit_label
, fall_thru_label
;
3652 tree var
, var_type
, cref
, tmp
;
3654 loop_entry_label
= create_artificial_label (UNKNOWN_LOCATION
);
3655 loop_exit_label
= create_artificial_label (UNKNOWN_LOCATION
);
3656 fall_thru_label
= create_artificial_label (UNKNOWN_LOCATION
);
3658 /* Create and initialize the index variable. */
3659 var_type
= TREE_TYPE (upper
);
3660 var
= create_tmp_var (var_type
, NULL
);
3661 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, lower
));
3663 /* Add the loop entry label. */
3664 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_entry_label
));
3666 /* Build the reference. */
3667 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3668 var
, NULL_TREE
, NULL_TREE
);
3670 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3671 the store. Otherwise just assign value to the reference. */
3673 if (TREE_CODE (value
) == CONSTRUCTOR
)
3674 /* NB we might have to call ourself recursively through
3675 gimplify_init_ctor_eval if the value is a constructor. */
3676 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3679 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (cref
, value
));
3681 /* We exit the loop when the index var is equal to the upper bound. */
3682 gimplify_seq_add_stmt (pre_p
,
3683 gimple_build_cond (EQ_EXPR
, var
, upper
,
3684 loop_exit_label
, fall_thru_label
));
3686 gimplify_seq_add_stmt (pre_p
, gimple_build_label (fall_thru_label
));
3688 /* Otherwise, increment the index var... */
3689 tmp
= build2 (PLUS_EXPR
, var_type
, var
,
3690 fold_convert (var_type
, integer_one_node
));
3691 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, tmp
));
3693 /* ...and jump back to the loop entry. */
3694 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (loop_entry_label
));
3696 /* Add the loop exit label. */
3697 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_exit_label
));
3700 /* Return true if FDECL is accessing a field that is zero sized. */
3703 zero_sized_field_decl (const_tree fdecl
)
3705 if (TREE_CODE (fdecl
) == FIELD_DECL
&& DECL_SIZE (fdecl
)
3706 && integer_zerop (DECL_SIZE (fdecl
)))
3711 /* Return true if TYPE is zero sized. */
3714 zero_sized_type (const_tree type
)
3716 if (AGGREGATE_TYPE_P (type
) && TYPE_SIZE (type
)
3717 && integer_zerop (TYPE_SIZE (type
)))
3722 /* A subroutine of gimplify_init_constructor. Generate individual
3723 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3724 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3725 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3729 gimplify_init_ctor_eval (tree object
, vec
<constructor_elt
, va_gc
> *elts
,
3730 gimple_seq
*pre_p
, bool cleared
)
3732 tree array_elt_type
= NULL
;
3733 unsigned HOST_WIDE_INT ix
;
3734 tree purpose
, value
;
3736 if (TREE_CODE (TREE_TYPE (object
)) == ARRAY_TYPE
)
3737 array_elt_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object
)));
3739 FOR_EACH_CONSTRUCTOR_ELT (elts
, ix
, purpose
, value
)
3743 /* NULL values are created above for gimplification errors. */
3747 if (cleared
&& initializer_zerop (value
))
3750 /* ??? Here's to hoping the front end fills in all of the indices,
3751 so we don't have to figure out what's missing ourselves. */
3752 gcc_assert (purpose
);
3754 /* Skip zero-sized fields, unless value has side-effects. This can
3755 happen with calls to functions returning a zero-sized type, which
3756 we shouldn't discard. As a number of downstream passes don't
3757 expect sets of zero-sized fields, we rely on the gimplification of
3758 the MODIFY_EXPR we make below to drop the assignment statement. */
3759 if (! TREE_SIDE_EFFECTS (value
) && zero_sized_field_decl (purpose
))
3762 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3764 if (TREE_CODE (purpose
) == RANGE_EXPR
)
3766 tree lower
= TREE_OPERAND (purpose
, 0);
3767 tree upper
= TREE_OPERAND (purpose
, 1);
3769 /* If the lower bound is equal to upper, just treat it as if
3770 upper was the index. */
3771 if (simple_cst_equal (lower
, upper
))
3775 gimplify_init_ctor_eval_range (object
, lower
, upper
, value
,
3776 array_elt_type
, pre_p
, cleared
);
3783 /* Do not use bitsizetype for ARRAY_REF indices. */
3784 if (TYPE_DOMAIN (TREE_TYPE (object
)))
3786 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object
))),
3788 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3789 purpose
, NULL_TREE
, NULL_TREE
);
3793 gcc_assert (TREE_CODE (purpose
) == FIELD_DECL
);
3794 cref
= build3 (COMPONENT_REF
, TREE_TYPE (purpose
),
3795 unshare_expr (object
), purpose
, NULL_TREE
);
3798 if (TREE_CODE (value
) == CONSTRUCTOR
3799 && TREE_CODE (TREE_TYPE (value
)) != VECTOR_TYPE
)
3800 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3804 tree init
= build2 (INIT_EXPR
, TREE_TYPE (cref
), cref
, value
);
3805 gimplify_and_add (init
, pre_p
);
3811 /* Return the appropriate RHS predicate for this LHS. */
3814 rhs_predicate_for (tree lhs
)
3816 if (is_gimple_reg (lhs
))
3817 return is_gimple_reg_rhs_or_call
;
3819 return is_gimple_mem_rhs_or_call
;
3822 /* Gimplify a C99 compound literal expression. This just means adding
3823 the DECL_EXPR before the current statement and using its anonymous
3826 static enum gimplify_status
3827 gimplify_compound_literal_expr (tree
*expr_p
, gimple_seq
*pre_p
,
3828 bool (*gimple_test_f
) (tree
),
3829 fallback_t fallback
)
3831 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p
);
3832 tree decl
= DECL_EXPR_DECL (decl_s
);
3833 tree init
= DECL_INITIAL (decl
);
3834 /* Mark the decl as addressable if the compound literal
3835 expression is addressable now, otherwise it is marked too late
3836 after we gimplify the initialization expression. */
3837 if (TREE_ADDRESSABLE (*expr_p
))
3838 TREE_ADDRESSABLE (decl
) = 1;
3839 /* Otherwise, if we don't need an lvalue and have a literal directly
3840 substitute it. Check if it matches the gimple predicate, as
3841 otherwise we'd generate a new temporary, and we can as well just
3842 use the decl we already have. */
3843 else if (!TREE_ADDRESSABLE (decl
)
3845 && (fallback
& fb_lvalue
) == 0
3846 && gimple_test_f (init
))
3852 /* Preliminarily mark non-addressed complex variables as eligible
3853 for promotion to gimple registers. We'll transform their uses
3855 if ((TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
3856 || TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
)
3857 && !TREE_THIS_VOLATILE (decl
)
3858 && !needs_to_live_in_memory (decl
))
3859 DECL_GIMPLE_REG_P (decl
) = 1;
3861 /* If the decl is not addressable, then it is being used in some
3862 expression or on the right hand side of a statement, and it can
3863 be put into a readonly data section. */
3864 if (!TREE_ADDRESSABLE (decl
) && (fallback
& fb_lvalue
) == 0)
3865 TREE_READONLY (decl
) = 1;
3867 /* This decl isn't mentioned in the enclosing block, so add it to the
3868 list of temps. FIXME it seems a bit of a kludge to say that
3869 anonymous artificial vars aren't pushed, but everything else is. */
3870 if (DECL_NAME (decl
) == NULL_TREE
&& !DECL_SEEN_IN_BIND_EXPR_P (decl
))
3871 gimple_add_tmp_var (decl
);
3873 gimplify_and_add (decl_s
, pre_p
);
3878 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3879 return a new CONSTRUCTOR if something changed. */
3882 optimize_compound_literals_in_ctor (tree orig_ctor
)
3884 tree ctor
= orig_ctor
;
3885 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
3886 unsigned int idx
, num
= vec_safe_length (elts
);
3888 for (idx
= 0; idx
< num
; idx
++)
3890 tree value
= (*elts
)[idx
].value
;
3891 tree newval
= value
;
3892 if (TREE_CODE (value
) == CONSTRUCTOR
)
3893 newval
= optimize_compound_literals_in_ctor (value
);
3894 else if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
3896 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (value
);
3897 tree decl
= DECL_EXPR_DECL (decl_s
);
3898 tree init
= DECL_INITIAL (decl
);
3900 if (!TREE_ADDRESSABLE (value
)
3901 && !TREE_ADDRESSABLE (decl
)
3903 && TREE_CODE (init
) == CONSTRUCTOR
)
3904 newval
= optimize_compound_literals_in_ctor (init
);
3906 if (newval
== value
)
3909 if (ctor
== orig_ctor
)
3911 ctor
= copy_node (orig_ctor
);
3912 CONSTRUCTOR_ELTS (ctor
) = vec_safe_copy (elts
);
3913 elts
= CONSTRUCTOR_ELTS (ctor
);
3915 (*elts
)[idx
].value
= newval
;
3920 /* A subroutine of gimplify_modify_expr. Break out elements of a
3921 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3923 Note that we still need to clear any elements that don't have explicit
3924 initializers, so if not all elements are initialized we keep the
3925 original MODIFY_EXPR, we just remove all of the constructor elements.
3927 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3928 GS_ERROR if we would have to create a temporary when gimplifying
3929 this constructor. Otherwise, return GS_OK.
3931 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3933 static enum gimplify_status
3934 gimplify_init_constructor (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3935 bool want_value
, bool notify_temp_creation
)
3937 tree object
, ctor
, type
;
3938 enum gimplify_status ret
;
3939 vec
<constructor_elt
, va_gc
> *elts
;
3941 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == CONSTRUCTOR
);
3943 if (!notify_temp_creation
)
3945 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
3946 is_gimple_lvalue
, fb_lvalue
);
3947 if (ret
== GS_ERROR
)
3951 object
= TREE_OPERAND (*expr_p
, 0);
3952 ctor
= TREE_OPERAND (*expr_p
, 1) =
3953 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p
, 1));
3954 type
= TREE_TYPE (ctor
);
3955 elts
= CONSTRUCTOR_ELTS (ctor
);
3958 switch (TREE_CODE (type
))
3962 case QUAL_UNION_TYPE
:
3965 struct gimplify_init_ctor_preeval_data preeval_data
;
3966 HOST_WIDE_INT num_ctor_elements
, num_nonzero_elements
;
3967 bool cleared
, complete_p
, valid_const_initializer
;
3969 /* Aggregate types must lower constructors to initialization of
3970 individual elements. The exception is that a CONSTRUCTOR node
3971 with no elements indicates zero-initialization of the whole. */
3972 if (vec_safe_is_empty (elts
))
3974 if (notify_temp_creation
)
3979 /* Fetch information about the constructor to direct later processing.
3980 We might want to make static versions of it in various cases, and
3981 can only do so if it known to be a valid constant initializer. */
3982 valid_const_initializer
3983 = categorize_ctor_elements (ctor
, &num_nonzero_elements
,
3984 &num_ctor_elements
, &complete_p
);
3986 /* If a const aggregate variable is being initialized, then it
3987 should never be a lose to promote the variable to be static. */
3988 if (valid_const_initializer
3989 && num_nonzero_elements
> 1
3990 && TREE_READONLY (object
)
3991 && TREE_CODE (object
) == VAR_DECL
3992 && (flag_merge_constants
>= 2 || !TREE_ADDRESSABLE (object
)))
3994 if (notify_temp_creation
)
3996 DECL_INITIAL (object
) = ctor
;
3997 TREE_STATIC (object
) = 1;
3998 if (!DECL_NAME (object
))
3999 DECL_NAME (object
) = create_tmp_var_name ("C");
4000 walk_tree (&DECL_INITIAL (object
), force_labels_r
, NULL
, NULL
);
4002 /* ??? C++ doesn't automatically append a .<number> to the
4003 assembler name, and even when it does, it looks at FE private
4004 data structures to figure out what that number should be,
4005 which are not set for this variable. I suppose this is
4006 important for local statics for inline functions, which aren't
4007 "local" in the object file sense. So in order to get a unique
4008 TU-local symbol, we must invoke the lhd version now. */
4009 lhd_set_decl_assembler_name (object
);
4011 *expr_p
= NULL_TREE
;
4015 /* If there are "lots" of initialized elements, even discounting
4016 those that are not address constants (and thus *must* be
4017 computed at runtime), then partition the constructor into
4018 constant and non-constant parts. Block copy the constant
4019 parts in, then generate code for the non-constant parts. */
4020 /* TODO. There's code in cp/typeck.c to do this. */
4022 if (int_size_in_bytes (TREE_TYPE (ctor
)) < 0)
4023 /* store_constructor will ignore the clearing of variable-sized
4024 objects. Initializers for such objects must explicitly set
4025 every field that needs to be set. */
4027 else if (!complete_p
)
4028 /* If the constructor isn't complete, clear the whole object
4031 ??? This ought not to be needed. For any element not present
4032 in the initializer, we should simply set them to zero. Except
4033 we'd need to *find* the elements that are not present, and that
4034 requires trickery to avoid quadratic compile-time behavior in
4035 large cases or excessive memory use in small cases. */
4037 else if (num_ctor_elements
- num_nonzero_elements
4038 > CLEAR_RATIO (optimize_function_for_speed_p (cfun
))
4039 && num_nonzero_elements
< num_ctor_elements
/ 4)
4040 /* If there are "lots" of zeros, it's more efficient to clear
4041 the memory and then set the nonzero elements. */
4046 /* If there are "lots" of initialized elements, and all of them
4047 are valid address constants, then the entire initializer can
4048 be dropped to memory, and then memcpy'd out. Don't do this
4049 for sparse arrays, though, as it's more efficient to follow
4050 the standard CONSTRUCTOR behavior of memset followed by
4051 individual element initialization. Also don't do this for small
4052 all-zero initializers (which aren't big enough to merit
4053 clearing), and don't try to make bitwise copies of
4054 TREE_ADDRESSABLE types. */
4055 if (valid_const_initializer
4056 && !(cleared
|| num_nonzero_elements
== 0)
4057 && !TREE_ADDRESSABLE (type
))
4059 HOST_WIDE_INT size
= int_size_in_bytes (type
);
4062 /* ??? We can still get unbounded array types, at least
4063 from the C++ front end. This seems wrong, but attempt
4064 to work around it for now. */
4067 size
= int_size_in_bytes (TREE_TYPE (object
));
4069 TREE_TYPE (ctor
) = type
= TREE_TYPE (object
);
4072 /* Find the maximum alignment we can assume for the object. */
4073 /* ??? Make use of DECL_OFFSET_ALIGN. */
4074 if (DECL_P (object
))
4075 align
= DECL_ALIGN (object
);
4077 align
= TYPE_ALIGN (type
);
4079 /* Do a block move either if the size is so small as to make
4080 each individual move a sub-unit move on average, or if it
4081 is so large as to make individual moves inefficient. */
4083 && num_nonzero_elements
> 1
4084 && (size
< num_nonzero_elements
4085 || !can_move_by_pieces (size
, align
)))
4087 if (notify_temp_creation
)
4090 walk_tree (&ctor
, force_labels_r
, NULL
, NULL
);
4091 ctor
= tree_output_constant_def (ctor
);
4092 if (!useless_type_conversion_p (type
, TREE_TYPE (ctor
)))
4093 ctor
= build1 (VIEW_CONVERT_EXPR
, type
, ctor
);
4094 TREE_OPERAND (*expr_p
, 1) = ctor
;
4096 /* This is no longer an assignment of a CONSTRUCTOR, but
4097 we still may have processing to do on the LHS. So
4098 pretend we didn't do anything here to let that happen. */
4099 return GS_UNHANDLED
;
4103 /* If the target is volatile, we have non-zero elements and more than
4104 one field to assign, initialize the target from a temporary. */
4105 if (TREE_THIS_VOLATILE (object
)
4106 && !TREE_ADDRESSABLE (type
)
4107 && num_nonzero_elements
> 0
4108 && vec_safe_length (elts
) > 1)
4110 tree temp
= create_tmp_var (TYPE_MAIN_VARIANT (type
), NULL
);
4111 TREE_OPERAND (*expr_p
, 0) = temp
;
4112 *expr_p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*expr_p
),
4114 build2 (MODIFY_EXPR
, void_type_node
,
4119 if (notify_temp_creation
)
4122 /* If there are nonzero elements and if needed, pre-evaluate to capture
4123 elements overlapping with the lhs into temporaries. We must do this
4124 before clearing to fetch the values before they are zeroed-out. */
4125 if (num_nonzero_elements
> 0 && TREE_CODE (*expr_p
) != INIT_EXPR
)
4127 preeval_data
.lhs_base_decl
= get_base_address (object
);
4128 if (!DECL_P (preeval_data
.lhs_base_decl
))
4129 preeval_data
.lhs_base_decl
= NULL
;
4130 preeval_data
.lhs_alias_set
= get_alias_set (object
);
4132 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p
, 1),
4133 pre_p
, post_p
, &preeval_data
);
4138 /* Zap the CONSTRUCTOR element list, which simplifies this case.
4139 Note that we still have to gimplify, in order to handle the
4140 case of variable sized types. Avoid shared tree structures. */
4141 CONSTRUCTOR_ELTS (ctor
) = NULL
;
4142 TREE_SIDE_EFFECTS (ctor
) = 0;
4143 object
= unshare_expr (object
);
4144 gimplify_stmt (expr_p
, pre_p
);
4147 /* If we have not block cleared the object, or if there are nonzero
4148 elements in the constructor, add assignments to the individual
4149 scalar fields of the object. */
4150 if (!cleared
|| num_nonzero_elements
> 0)
4151 gimplify_init_ctor_eval (object
, elts
, pre_p
, cleared
);
4153 *expr_p
= NULL_TREE
;
4161 if (notify_temp_creation
)
4164 /* Extract the real and imaginary parts out of the ctor. */
4165 gcc_assert (elts
->length () == 2);
4166 r
= (*elts
)[0].value
;
4167 i
= (*elts
)[1].value
;
4168 if (r
== NULL
|| i
== NULL
)
4170 tree zero
= build_zero_cst (TREE_TYPE (type
));
4177 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
4178 represent creation of a complex value. */
4179 if (TREE_CONSTANT (r
) && TREE_CONSTANT (i
))
4181 ctor
= build_complex (type
, r
, i
);
4182 TREE_OPERAND (*expr_p
, 1) = ctor
;
4186 ctor
= build2 (COMPLEX_EXPR
, type
, r
, i
);
4187 TREE_OPERAND (*expr_p
, 1) = ctor
;
4188 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1),
4191 rhs_predicate_for (TREE_OPERAND (*expr_p
, 0)),
4199 unsigned HOST_WIDE_INT ix
;
4200 constructor_elt
*ce
;
4202 if (notify_temp_creation
)
4205 /* Go ahead and simplify constant constructors to VECTOR_CST. */
4206 if (TREE_CONSTANT (ctor
))
4208 bool constant_p
= true;
4211 /* Even when ctor is constant, it might contain non-*_CST
4212 elements, such as addresses or trapping values like
4213 1.0/0.0 - 1.0/0.0. Such expressions don't belong
4214 in VECTOR_CST nodes. */
4215 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
4216 if (!CONSTANT_CLASS_P (value
))
4224 TREE_OPERAND (*expr_p
, 1) = build_vector_from_ctor (type
, elts
);
4228 /* Don't reduce an initializer constant even if we can't
4229 make a VECTOR_CST. It won't do anything for us, and it'll
4230 prevent us from representing it as a single constant. */
4231 if (initializer_constant_valid_p (ctor
, type
))
4234 TREE_CONSTANT (ctor
) = 0;
4237 /* Vector types use CONSTRUCTOR all the way through gimple
4238 compilation as a general initializer. */
4239 FOR_EACH_VEC_SAFE_ELT (elts
, ix
, ce
)
4241 enum gimplify_status tret
;
4242 tret
= gimplify_expr (&ce
->value
, pre_p
, post_p
, is_gimple_val
,
4244 if (tret
== GS_ERROR
)
4247 if (!is_gimple_reg (TREE_OPERAND (*expr_p
, 0)))
4248 TREE_OPERAND (*expr_p
, 1) = get_formal_tmp_var (ctor
, pre_p
);
4253 /* So how did we get a CONSTRUCTOR for a scalar type? */
4257 if (ret
== GS_ERROR
)
4259 else if (want_value
)
4266 /* If we have gimplified both sides of the initializer but have
4267 not emitted an assignment, do so now. */
4270 tree lhs
= TREE_OPERAND (*expr_p
, 0);
4271 tree rhs
= TREE_OPERAND (*expr_p
, 1);
4272 gimple init
= gimple_build_assign (lhs
, rhs
);
4273 gimplify_seq_add_stmt (pre_p
, init
);
4281 /* Given a pointer value OP0, return a simplified version of an
4282 indirection through OP0, or NULL_TREE if no simplification is
4283 possible. This may only be applied to a rhs of an expression.
4284 Note that the resulting type may be different from the type pointed
4285 to in the sense that it is still compatible from the langhooks
4289 gimple_fold_indirect_ref_rhs (tree t
)
4291 return gimple_fold_indirect_ref (t
);
4294 /* Subroutine of gimplify_modify_expr to do simplifications of
4295 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4296 something changes. */
4298 static enum gimplify_status
4299 gimplify_modify_expr_rhs (tree
*expr_p
, tree
*from_p
, tree
*to_p
,
4300 gimple_seq
*pre_p
, gimple_seq
*post_p
,
4303 enum gimplify_status ret
= GS_UNHANDLED
;
4309 switch (TREE_CODE (*from_p
))
4312 /* If we're assigning from a read-only variable initialized with
4313 a constructor, do the direct assignment from the constructor,
4314 but only if neither source nor target are volatile since this
4315 latter assignment might end up being done on a per-field basis. */
4316 if (DECL_INITIAL (*from_p
)
4317 && TREE_READONLY (*from_p
)
4318 && !TREE_THIS_VOLATILE (*from_p
)
4319 && !TREE_THIS_VOLATILE (*to_p
)
4320 && TREE_CODE (DECL_INITIAL (*from_p
)) == CONSTRUCTOR
)
4322 tree old_from
= *from_p
;
4323 enum gimplify_status subret
;
4325 /* Move the constructor into the RHS. */
4326 *from_p
= unshare_expr (DECL_INITIAL (*from_p
));
4328 /* Let's see if gimplify_init_constructor will need to put
4330 subret
= gimplify_init_constructor (expr_p
, NULL
, NULL
,
4332 if (subret
== GS_ERROR
)
4334 /* If so, revert the change. */
4346 /* If we have code like
4350 where the type of "x" is a (possibly cv-qualified variant
4351 of "A"), treat the entire expression as identical to "x".
4352 This kind of code arises in C++ when an object is bound
4353 to a const reference, and if "x" is a TARGET_EXPR we want
4354 to take advantage of the optimization below. */
4355 bool volatile_p
= TREE_THIS_VOLATILE (*from_p
);
4356 tree t
= gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p
, 0));
4359 if (TREE_THIS_VOLATILE (t
) != volatile_p
)
4361 if (TREE_CODE_CLASS (TREE_CODE (t
)) == tcc_declaration
)
4362 t
= build_simple_mem_ref_loc (EXPR_LOCATION (*from_p
),
4363 build_fold_addr_expr (t
));
4364 if (REFERENCE_CLASS_P (t
))
4365 TREE_THIS_VOLATILE (t
) = volatile_p
;
4376 /* If we are initializing something from a TARGET_EXPR, strip the
4377 TARGET_EXPR and initialize it directly, if possible. This can't
4378 be done if the initializer is void, since that implies that the
4379 temporary is set in some non-trivial way.
4381 ??? What about code that pulls out the temp and uses it
4382 elsewhere? I think that such code never uses the TARGET_EXPR as
4383 an initializer. If I'm wrong, we'll die because the temp won't
4384 have any RTL. In that case, I guess we'll need to replace
4385 references somehow. */
4386 tree init
= TARGET_EXPR_INITIAL (*from_p
);
4389 && !VOID_TYPE_P (TREE_TYPE (init
)))
4399 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4401 gimplify_compound_expr (from_p
, pre_p
, true);
4407 /* If we already made some changes, let the front end have a
4408 crack at this before we break it down. */
4409 if (ret
!= GS_UNHANDLED
)
4411 /* If we're initializing from a CONSTRUCTOR, break this into
4412 individual MODIFY_EXPRs. */
4413 return gimplify_init_constructor (expr_p
, pre_p
, post_p
, want_value
,
4417 /* If we're assigning to a non-register type, push the assignment
4418 down into the branches. This is mandatory for ADDRESSABLE types,
4419 since we cannot generate temporaries for such, but it saves a
4420 copy in other cases as well. */
4421 if (!is_gimple_reg_type (TREE_TYPE (*from_p
)))
4423 /* This code should mirror the code in gimplify_cond_expr. */
4424 enum tree_code code
= TREE_CODE (*expr_p
);
4425 tree cond
= *from_p
;
4426 tree result
= *to_p
;
4428 ret
= gimplify_expr (&result
, pre_p
, post_p
,
4429 is_gimple_lvalue
, fb_lvalue
);
4430 if (ret
!= GS_ERROR
)
4433 if (TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
)
4434 TREE_OPERAND (cond
, 1)
4435 = build2 (code
, void_type_node
, result
,
4436 TREE_OPERAND (cond
, 1));
4437 if (TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
4438 TREE_OPERAND (cond
, 2)
4439 = build2 (code
, void_type_node
, unshare_expr (result
),
4440 TREE_OPERAND (cond
, 2));
4442 TREE_TYPE (cond
) = void_type_node
;
4443 recalculate_side_effects (cond
);
4447 gimplify_and_add (cond
, pre_p
);
4448 *expr_p
= unshare_expr (result
);
4457 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4458 return slot so that we don't generate a temporary. */
4459 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p
)
4460 && aggregate_value_p (*from_p
, *from_p
))
4464 if (!(rhs_predicate_for (*to_p
))(*from_p
))
4465 /* If we need a temporary, *to_p isn't accurate. */
4467 /* It's OK to use the return slot directly unless it's an NRV. */
4468 else if (TREE_CODE (*to_p
) == RESULT_DECL
4469 && DECL_NAME (*to_p
) == NULL_TREE
4470 && needs_to_live_in_memory (*to_p
))
4472 else if (is_gimple_reg_type (TREE_TYPE (*to_p
))
4473 || (DECL_P (*to_p
) && DECL_REGISTER (*to_p
)))
4474 /* Don't force regs into memory. */
4476 else if (TREE_CODE (*expr_p
) == INIT_EXPR
)
4477 /* It's OK to use the target directly if it's being
4480 else if (variably_modified_type_p (TREE_TYPE (*to_p
), NULL_TREE
))
4481 /* Always use the target and thus RSO for variable-sized types.
4482 GIMPLE cannot deal with a variable-sized assignment
4483 embedded in a call statement. */
4485 else if (TREE_CODE (*to_p
) != SSA_NAME
4486 && (!is_gimple_variable (*to_p
)
4487 || needs_to_live_in_memory (*to_p
)))
4488 /* Don't use the original target if it's already addressable;
4489 if its address escapes, and the called function uses the
4490 NRV optimization, a conforming program could see *to_p
4491 change before the called function returns; see c++/19317.
4492 When optimizing, the return_slot pass marks more functions
4493 as safe after we have escape info. */
4500 CALL_EXPR_RETURN_SLOT_OPT (*from_p
) = 1;
4501 mark_addressable (*to_p
);
4506 case WITH_SIZE_EXPR
:
4507 /* Likewise for calls that return an aggregate of non-constant size,
4508 since we would not be able to generate a temporary at all. */
4509 if (TREE_CODE (TREE_OPERAND (*from_p
, 0)) == CALL_EXPR
)
4511 *from_p
= TREE_OPERAND (*from_p
, 0);
4512 /* We don't change ret in this case because the
4513 WITH_SIZE_EXPR might have been added in
4514 gimplify_modify_expr, so returning GS_OK would lead to an
4520 /* If we're initializing from a container, push the initialization
4522 case CLEANUP_POINT_EXPR
:
4524 case STATEMENT_LIST
:
4526 tree wrap
= *from_p
;
4529 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_min_lval
,
4531 if (ret
!= GS_ERROR
)
4534 t
= voidify_wrapper_expr (wrap
, *expr_p
);
4535 gcc_assert (t
== *expr_p
);
4539 gimplify_and_add (wrap
, pre_p
);
4540 *expr_p
= unshare_expr (*to_p
);
4547 case COMPOUND_LITERAL_EXPR
:
4549 tree complit
= TREE_OPERAND (*expr_p
, 1);
4550 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (complit
);
4551 tree decl
= DECL_EXPR_DECL (decl_s
);
4552 tree init
= DECL_INITIAL (decl
);
4554 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4555 into struct T x = { 0, 1, 2 } if the address of the
4556 compound literal has never been taken. */
4557 if (!TREE_ADDRESSABLE (complit
)
4558 && !TREE_ADDRESSABLE (decl
)
4561 *expr_p
= copy_node (*expr_p
);
4562 TREE_OPERAND (*expr_p
, 1) = init
;
4577 /* Return true if T looks like a valid GIMPLE statement. */
4580 is_gimple_stmt (tree t
)
4582 const enum tree_code code
= TREE_CODE (t
);
4587 /* The only valid NOP_EXPR is the empty statement. */
4588 return IS_EMPTY_STMT (t
);
4592 /* These are only valid if they're void. */
4593 return TREE_TYPE (t
) == NULL
|| VOID_TYPE_P (TREE_TYPE (t
));
4599 case CASE_LABEL_EXPR
:
4600 case TRY_CATCH_EXPR
:
4601 case TRY_FINALLY_EXPR
:
4602 case EH_FILTER_EXPR
:
4605 case STATEMENT_LIST
:
4609 case OMP_DISTRIBUTE
:
4618 /* These are always void. */
4624 /* These are valid regardless of their type. */
4633 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4634 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4635 DECL_GIMPLE_REG_P set.
4637 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4638 other, unmodified part of the complex object just before the total store.
4639 As a consequence, if the object is still uninitialized, an undefined value
4640 will be loaded into a register, which may result in a spurious exception
4641 if the register is floating-point and the value happens to be a signaling
4642 NaN for example. Then the fully-fledged complex operations lowering pass
4643 followed by a DCE pass are necessary in order to fix things up. */
4645 static enum gimplify_status
4646 gimplify_modify_expr_complex_part (tree
*expr_p
, gimple_seq
*pre_p
,
4649 enum tree_code code
, ocode
;
4650 tree lhs
, rhs
, new_rhs
, other
, realpart
, imagpart
;
4652 lhs
= TREE_OPERAND (*expr_p
, 0);
4653 rhs
= TREE_OPERAND (*expr_p
, 1);
4654 code
= TREE_CODE (lhs
);
4655 lhs
= TREE_OPERAND (lhs
, 0);
4657 ocode
= code
== REALPART_EXPR
? IMAGPART_EXPR
: REALPART_EXPR
;
4658 other
= build1 (ocode
, TREE_TYPE (rhs
), lhs
);
4659 TREE_NO_WARNING (other
) = 1;
4660 other
= get_formal_tmp_var (other
, pre_p
);
4662 realpart
= code
== REALPART_EXPR
? rhs
: other
;
4663 imagpart
= code
== REALPART_EXPR
? other
: rhs
;
4665 if (TREE_CONSTANT (realpart
) && TREE_CONSTANT (imagpart
))
4666 new_rhs
= build_complex (TREE_TYPE (lhs
), realpart
, imagpart
);
4668 new_rhs
= build2 (COMPLEX_EXPR
, TREE_TYPE (lhs
), realpart
, imagpart
);
4670 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (lhs
, new_rhs
));
4671 *expr_p
= (want_value
) ? rhs
: NULL_TREE
;
4676 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4682 PRE_P points to the list where side effects that must happen before
4683 *EXPR_P should be stored.
4685 POST_P points to the list where side effects that must happen after
4686 *EXPR_P should be stored.
4688 WANT_VALUE is nonzero iff we want to use the value of this expression
4689 in another expression. */
4691 static enum gimplify_status
4692 gimplify_modify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4695 tree
*from_p
= &TREE_OPERAND (*expr_p
, 1);
4696 tree
*to_p
= &TREE_OPERAND (*expr_p
, 0);
4697 enum gimplify_status ret
= GS_UNHANDLED
;
4699 location_t loc
= EXPR_LOCATION (*expr_p
);
4700 gimple_stmt_iterator gsi
;
4702 gcc_assert (TREE_CODE (*expr_p
) == MODIFY_EXPR
4703 || TREE_CODE (*expr_p
) == INIT_EXPR
);
4705 /* Trying to simplify a clobber using normal logic doesn't work,
4706 so handle it here. */
4707 if (TREE_CLOBBER_P (*from_p
))
4709 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4710 if (ret
== GS_ERROR
)
4712 gcc_assert (!want_value
4713 && (TREE_CODE (*to_p
) == VAR_DECL
4714 || TREE_CODE (*to_p
) == MEM_REF
));
4715 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (*to_p
, *from_p
));
4720 /* Insert pointer conversions required by the middle-end that are not
4721 required by the frontend. This fixes middle-end type checking for
4722 for example gcc.dg/redecl-6.c. */
4723 if (POINTER_TYPE_P (TREE_TYPE (*to_p
)))
4725 STRIP_USELESS_TYPE_CONVERSION (*from_p
);
4726 if (!useless_type_conversion_p (TREE_TYPE (*to_p
), TREE_TYPE (*from_p
)))
4727 *from_p
= fold_convert_loc (loc
, TREE_TYPE (*to_p
), *from_p
);
4730 /* See if any simplifications can be done based on what the RHS is. */
4731 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4733 if (ret
!= GS_UNHANDLED
)
4736 /* For zero sized types only gimplify the left hand side and right hand
4737 side as statements and throw away the assignment. Do this after
4738 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4740 if (zero_sized_type (TREE_TYPE (*from_p
)) && !want_value
)
4742 gimplify_stmt (from_p
, pre_p
);
4743 gimplify_stmt (to_p
, pre_p
);
4744 *expr_p
= NULL_TREE
;
4748 /* If the value being copied is of variable width, compute the length
4749 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4750 before gimplifying any of the operands so that we can resolve any
4751 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4752 the size of the expression to be copied, not of the destination, so
4753 that is what we must do here. */
4754 maybe_with_size_expr (from_p
);
4756 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4757 if (ret
== GS_ERROR
)
4760 /* As a special case, we have to temporarily allow for assignments
4761 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4762 a toplevel statement, when gimplifying the GENERIC expression
4763 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4764 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4766 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4767 prevent gimplify_expr from trying to create a new temporary for
4768 foo's LHS, we tell it that it should only gimplify until it
4769 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4770 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4771 and all we need to do here is set 'a' to be its LHS. */
4772 ret
= gimplify_expr (from_p
, pre_p
, post_p
, rhs_predicate_for (*to_p
),
4774 if (ret
== GS_ERROR
)
4777 /* Now see if the above changed *from_p to something we handle specially. */
4778 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4780 if (ret
!= GS_UNHANDLED
)
4783 /* If we've got a variable sized assignment between two lvalues (i.e. does
4784 not involve a call), then we can make things a bit more straightforward
4785 by converting the assignment to memcpy or memset. */
4786 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
4788 tree from
= TREE_OPERAND (*from_p
, 0);
4789 tree size
= TREE_OPERAND (*from_p
, 1);
4791 if (TREE_CODE (from
) == CONSTRUCTOR
)
4792 return gimplify_modify_expr_to_memset (expr_p
, size
, want_value
, pre_p
);
4794 if (is_gimple_addressable (from
))
4797 return gimplify_modify_expr_to_memcpy (expr_p
, size
, want_value
,
4802 /* Transform partial stores to non-addressable complex variables into
4803 total stores. This allows us to use real instead of virtual operands
4804 for these variables, which improves optimization. */
4805 if ((TREE_CODE (*to_p
) == REALPART_EXPR
4806 || TREE_CODE (*to_p
) == IMAGPART_EXPR
)
4807 && is_gimple_reg (TREE_OPERAND (*to_p
, 0)))
4808 return gimplify_modify_expr_complex_part (expr_p
, pre_p
, want_value
);
4810 /* Try to alleviate the effects of the gimplification creating artificial
4811 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
4812 if (!gimplify_ctxp
->into_ssa
4813 && TREE_CODE (*from_p
) == VAR_DECL
4814 && DECL_IGNORED_P (*from_p
)
4816 && !DECL_IGNORED_P (*to_p
))
4818 if (!DECL_NAME (*from_p
) && DECL_NAME (*to_p
))
4820 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p
)));
4821 DECL_HAS_DEBUG_EXPR_P (*from_p
) = 1;
4822 SET_DECL_DEBUG_EXPR (*from_p
, *to_p
);
4825 if (want_value
&& TREE_THIS_VOLATILE (*to_p
))
4826 *from_p
= get_initialized_tmp_var (*from_p
, pre_p
, post_p
);
4828 if (TREE_CODE (*from_p
) == CALL_EXPR
)
4830 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4831 instead of a GIMPLE_ASSIGN. */
4832 tree fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*from_p
));
4833 CALL_EXPR_FN (*from_p
) = TREE_OPERAND (CALL_EXPR_FN (*from_p
), 0);
4834 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p
));
4835 assign
= gimple_build_call_from_tree (*from_p
);
4836 gimple_call_set_fntype (assign
, TREE_TYPE (fnptrtype
));
4837 notice_special_calls (assign
);
4838 if (!gimple_call_noreturn_p (assign
))
4839 gimple_call_set_lhs (assign
, *to_p
);
4843 assign
= gimple_build_assign (*to_p
, *from_p
);
4844 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
4847 if (gimplify_ctxp
->into_ssa
&& is_gimple_reg (*to_p
))
4849 /* We should have got an SSA name from the start. */
4850 gcc_assert (TREE_CODE (*to_p
) == SSA_NAME
);
4853 gimplify_seq_add_stmt (pre_p
, assign
);
4854 gsi
= gsi_last (*pre_p
);
4855 /* Don't fold stmts inside of target construct. We'll do it
4856 during omplower pass instead. */
4857 struct gimplify_omp_ctx
*ctx
;
4858 for (ctx
= gimplify_omp_ctxp
; ctx
; ctx
= ctx
->outer_context
)
4859 if (ctx
->region_type
== ORT_TARGET
)
4866 *expr_p
= TREE_THIS_VOLATILE (*to_p
) ? *from_p
: unshare_expr (*to_p
);
4875 /* Gimplify a comparison between two variable-sized objects. Do this
4876 with a call to BUILT_IN_MEMCMP. */
4878 static enum gimplify_status
4879 gimplify_variable_sized_compare (tree
*expr_p
)
4881 location_t loc
= EXPR_LOCATION (*expr_p
);
4882 tree op0
= TREE_OPERAND (*expr_p
, 0);
4883 tree op1
= TREE_OPERAND (*expr_p
, 1);
4884 tree t
, arg
, dest
, src
, expr
;
4886 arg
= TYPE_SIZE_UNIT (TREE_TYPE (op0
));
4887 arg
= unshare_expr (arg
);
4888 arg
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg
, op0
);
4889 src
= build_fold_addr_expr_loc (loc
, op1
);
4890 dest
= build_fold_addr_expr_loc (loc
, op0
);
4891 t
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
4892 t
= build_call_expr_loc (loc
, t
, 3, dest
, src
, arg
);
4895 = build2 (TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), t
, integer_zero_node
);
4896 SET_EXPR_LOCATION (expr
, loc
);
4902 /* Gimplify a comparison between two aggregate objects of integral scalar
4903 mode as a comparison between the bitwise equivalent scalar values. */
4905 static enum gimplify_status
4906 gimplify_scalar_mode_aggregate_compare (tree
*expr_p
)
4908 location_t loc
= EXPR_LOCATION (*expr_p
);
4909 tree op0
= TREE_OPERAND (*expr_p
, 0);
4910 tree op1
= TREE_OPERAND (*expr_p
, 1);
4912 tree type
= TREE_TYPE (op0
);
4913 tree scalar_type
= lang_hooks
.types
.type_for_mode (TYPE_MODE (type
), 1);
4915 op0
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op0
);
4916 op1
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op1
);
4919 = fold_build2_loc (loc
, TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), op0
, op1
);
4924 /* Gimplify an expression sequence. This function gimplifies each
4925 expression and rewrites the original expression with the last
4926 expression of the sequence in GIMPLE form.
4928 PRE_P points to the list where the side effects for all the
4929 expressions in the sequence will be emitted.
4931 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
4933 static enum gimplify_status
4934 gimplify_compound_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
4940 tree
*sub_p
= &TREE_OPERAND (t
, 0);
4942 if (TREE_CODE (*sub_p
) == COMPOUND_EXPR
)
4943 gimplify_compound_expr (sub_p
, pre_p
, false);
4945 gimplify_stmt (sub_p
, pre_p
);
4947 t
= TREE_OPERAND (t
, 1);
4949 while (TREE_CODE (t
) == COMPOUND_EXPR
);
4956 gimplify_stmt (expr_p
, pre_p
);
4961 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
4962 gimplify. After gimplification, EXPR_P will point to a new temporary
4963 that holds the original value of the SAVE_EXPR node.
4965 PRE_P points to the list where side effects that must happen before
4966 *EXPR_P should be stored. */
4968 static enum gimplify_status
4969 gimplify_save_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4971 enum gimplify_status ret
= GS_ALL_DONE
;
4974 gcc_assert (TREE_CODE (*expr_p
) == SAVE_EXPR
);
4975 val
= TREE_OPERAND (*expr_p
, 0);
4977 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
4978 if (!SAVE_EXPR_RESOLVED_P (*expr_p
))
4980 /* The operand may be a void-valued expression such as SAVE_EXPRs
4981 generated by the Java frontend for class initialization. It is
4982 being executed only for its side-effects. */
4983 if (TREE_TYPE (val
) == void_type_node
)
4985 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
4986 is_gimple_stmt
, fb_none
);
4990 val
= get_initialized_tmp_var (val
, pre_p
, post_p
);
4992 TREE_OPERAND (*expr_p
, 0) = val
;
4993 SAVE_EXPR_RESOLVED_P (*expr_p
) = 1;
5001 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
5008 PRE_P points to the list where side effects that must happen before
5009 *EXPR_P should be stored.
5011 POST_P points to the list where side effects that must happen after
5012 *EXPR_P should be stored. */
5014 static enum gimplify_status
5015 gimplify_addr_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5017 tree expr
= *expr_p
;
5018 tree op0
= TREE_OPERAND (expr
, 0);
5019 enum gimplify_status ret
;
5020 location_t loc
= EXPR_LOCATION (*expr_p
);
5022 switch (TREE_CODE (op0
))
5026 /* Check if we are dealing with an expression of the form '&*ptr'.
5027 While the front end folds away '&*ptr' into 'ptr', these
5028 expressions may be generated internally by the compiler (e.g.,
5029 builtins like __builtin_va_end). */
5030 /* Caution: the silent array decomposition semantics we allow for
5031 ADDR_EXPR means we can't always discard the pair. */
5032 /* Gimplification of the ADDR_EXPR operand may drop
5033 cv-qualification conversions, so make sure we add them if
5036 tree op00
= TREE_OPERAND (op0
, 0);
5037 tree t_expr
= TREE_TYPE (expr
);
5038 tree t_op00
= TREE_TYPE (op00
);
5040 if (!useless_type_conversion_p (t_expr
, t_op00
))
5041 op00
= fold_convert_loc (loc
, TREE_TYPE (expr
), op00
);
5047 case VIEW_CONVERT_EXPR
:
5048 /* Take the address of our operand and then convert it to the type of
5051 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
5052 all clear. The impact of this transformation is even less clear. */
5054 /* If the operand is a useless conversion, look through it. Doing so
5055 guarantees that the ADDR_EXPR and its operand will remain of the
5057 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0
, 0)))
5058 op0
= TREE_OPERAND (op0
, 0);
5060 *expr_p
= fold_convert_loc (loc
, TREE_TYPE (expr
),
5061 build_fold_addr_expr_loc (loc
,
5062 TREE_OPERAND (op0
, 0)));
5067 /* We use fb_either here because the C frontend sometimes takes
5068 the address of a call that returns a struct; see
5069 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
5070 the implied temporary explicit. */
5072 /* Make the operand addressable. */
5073 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, post_p
,
5074 is_gimple_addressable
, fb_either
);
5075 if (ret
== GS_ERROR
)
5078 /* Then mark it. Beware that it may not be possible to do so directly
5079 if a temporary has been created by the gimplification. */
5080 prepare_gimple_addressable (&TREE_OPERAND (expr
, 0), pre_p
);
5082 op0
= TREE_OPERAND (expr
, 0);
5084 /* For various reasons, the gimplification of the expression
5085 may have made a new INDIRECT_REF. */
5086 if (TREE_CODE (op0
) == INDIRECT_REF
)
5087 goto do_indirect_ref
;
5089 mark_addressable (TREE_OPERAND (expr
, 0));
5091 /* The FEs may end up building ADDR_EXPRs early on a decl with
5092 an incomplete type. Re-build ADDR_EXPRs in canonical form
5094 if (!types_compatible_p (TREE_TYPE (op0
), TREE_TYPE (TREE_TYPE (expr
))))
5095 *expr_p
= build_fold_addr_expr (op0
);
5097 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
5098 recompute_tree_invariant_for_addr_expr (*expr_p
);
5100 /* If we re-built the ADDR_EXPR add a conversion to the original type
5102 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
5103 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
5111 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
5112 value; output operands should be a gimple lvalue. */
5114 static enum gimplify_status
5115 gimplify_asm_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5119 const char **oconstraints
;
5122 const char *constraint
;
5123 bool allows_mem
, allows_reg
, is_inout
;
5124 enum gimplify_status ret
, tret
;
5126 vec
<tree
, va_gc
> *inputs
;
5127 vec
<tree
, va_gc
> *outputs
;
5128 vec
<tree
, va_gc
> *clobbers
;
5129 vec
<tree
, va_gc
> *labels
;
5133 noutputs
= list_length (ASM_OUTPUTS (expr
));
5134 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
5142 link_next
= NULL_TREE
;
5143 for (i
= 0, link
= ASM_OUTPUTS (expr
); link
; ++i
, link
= link_next
)
5146 size_t constraint_len
;
5148 link_next
= TREE_CHAIN (link
);
5152 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5153 constraint_len
= strlen (constraint
);
5154 if (constraint_len
== 0)
5157 ok
= parse_output_constraint (&constraint
, i
, 0, 0,
5158 &allows_mem
, &allows_reg
, &is_inout
);
5165 if (!allows_reg
&& allows_mem
)
5166 mark_addressable (TREE_VALUE (link
));
5168 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5169 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
5170 fb_lvalue
| fb_mayfail
);
5171 if (tret
== GS_ERROR
)
5173 error ("invalid lvalue in asm output %d", i
);
5177 vec_safe_push (outputs
, link
);
5178 TREE_CHAIN (link
) = NULL_TREE
;
5182 /* An input/output operand. To give the optimizers more
5183 flexibility, split it into separate input and output
5188 /* Turn the in/out constraint into an output constraint. */
5189 char *p
= xstrdup (constraint
);
5191 TREE_VALUE (TREE_PURPOSE (link
)) = build_string (constraint_len
, p
);
5193 /* And add a matching input constraint. */
5196 sprintf (buf
, "%d", i
);
5198 /* If there are multiple alternatives in the constraint,
5199 handle each of them individually. Those that allow register
5200 will be replaced with operand number, the others will stay
5202 if (strchr (p
, ',') != NULL
)
5204 size_t len
= 0, buflen
= strlen (buf
);
5205 char *beg
, *end
, *str
, *dst
;
5209 end
= strchr (beg
, ',');
5211 end
= strchr (beg
, '\0');
5212 if ((size_t) (end
- beg
) < buflen
)
5215 len
+= end
- beg
+ 1;
5222 str
= (char *) alloca (len
);
5223 for (beg
= p
+ 1, dst
= str
;;)
5226 bool mem_p
, reg_p
, inout_p
;
5228 end
= strchr (beg
, ',');
5233 parse_output_constraint (&tem
, i
, 0, 0,
5234 &mem_p
, ®_p
, &inout_p
);
5239 memcpy (dst
, buf
, buflen
);
5248 memcpy (dst
, beg
, len
);
5257 input
= build_string (dst
- str
, str
);
5260 input
= build_string (strlen (buf
), buf
);
5263 input
= build_string (constraint_len
- 1, constraint
+ 1);
5267 input
= build_tree_list (build_tree_list (NULL_TREE
, input
),
5268 unshare_expr (TREE_VALUE (link
)));
5269 ASM_INPUTS (expr
) = chainon (ASM_INPUTS (expr
), input
);
5273 link_next
= NULL_TREE
;
5274 for (link
= ASM_INPUTS (expr
); link
; ++i
, link
= link_next
)
5276 link_next
= TREE_CHAIN (link
);
5277 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5278 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
5279 oconstraints
, &allows_mem
, &allows_reg
);
5281 /* If we can't make copies, we can only accept memory. */
5282 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link
))))
5288 error ("impossible constraint in %<asm%>");
5289 error ("non-memory input %d must stay in memory", i
);
5294 /* If the operand is a memory input, it should be an lvalue. */
5295 if (!allows_reg
&& allows_mem
)
5297 tree inputv
= TREE_VALUE (link
);
5298 STRIP_NOPS (inputv
);
5299 if (TREE_CODE (inputv
) == PREDECREMENT_EXPR
5300 || TREE_CODE (inputv
) == PREINCREMENT_EXPR
5301 || TREE_CODE (inputv
) == POSTDECREMENT_EXPR
5302 || TREE_CODE (inputv
) == POSTINCREMENT_EXPR
)
5303 TREE_VALUE (link
) = error_mark_node
;
5304 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5305 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
5306 mark_addressable (TREE_VALUE (link
));
5307 if (tret
== GS_ERROR
)
5309 if (EXPR_HAS_LOCATION (TREE_VALUE (link
)))
5310 input_location
= EXPR_LOCATION (TREE_VALUE (link
));
5311 error ("memory input %d is not directly addressable", i
);
5317 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5318 is_gimple_asm_val
, fb_rvalue
);
5319 if (tret
== GS_ERROR
)
5323 TREE_CHAIN (link
) = NULL_TREE
;
5324 vec_safe_push (inputs
, link
);
5327 link_next
= NULL_TREE
;
5328 for (link
= ASM_CLOBBERS (expr
); link
; ++i
, link
= link_next
)
5330 link_next
= TREE_CHAIN (link
);
5331 TREE_CHAIN (link
) = NULL_TREE
;
5332 vec_safe_push (clobbers
, link
);
5335 link_next
= NULL_TREE
;
5336 for (link
= ASM_LABELS (expr
); link
; ++i
, link
= link_next
)
5338 link_next
= TREE_CHAIN (link
);
5339 TREE_CHAIN (link
) = NULL_TREE
;
5340 vec_safe_push (labels
, link
);
5343 /* Do not add ASMs with errors to the gimple IL stream. */
5344 if (ret
!= GS_ERROR
)
5346 stmt
= gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr
)),
5347 inputs
, outputs
, clobbers
, labels
);
5349 gimple_asm_set_volatile (stmt
, ASM_VOLATILE_P (expr
));
5350 gimple_asm_set_input (stmt
, ASM_INPUT_P (expr
));
5352 gimplify_seq_add_stmt (pre_p
, stmt
);
5358 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
5359 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
5360 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
5361 return to this function.
5363 FIXME should we complexify the prequeue handling instead? Or use flags
5364 for all the cleanups and let the optimizer tighten them up? The current
5365 code seems pretty fragile; it will break on a cleanup within any
5366 non-conditional nesting. But any such nesting would be broken, anyway;
5367 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
5368 and continues out of it. We can do that at the RTL level, though, so
5369 having an optimizer to tighten up try/finally regions would be a Good
5372 static enum gimplify_status
5373 gimplify_cleanup_point_expr (tree
*expr_p
, gimple_seq
*pre_p
)
5375 gimple_stmt_iterator iter
;
5376 gimple_seq body_sequence
= NULL
;
5378 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
5380 /* We only care about the number of conditions between the innermost
5381 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5382 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5383 int old_conds
= gimplify_ctxp
->conditions
;
5384 gimple_seq old_cleanups
= gimplify_ctxp
->conditional_cleanups
;
5385 bool old_in_cleanup_point_expr
= gimplify_ctxp
->in_cleanup_point_expr
;
5386 gimplify_ctxp
->conditions
= 0;
5387 gimplify_ctxp
->conditional_cleanups
= NULL
;
5388 gimplify_ctxp
->in_cleanup_point_expr
= true;
5390 gimplify_stmt (&TREE_OPERAND (*expr_p
, 0), &body_sequence
);
5392 gimplify_ctxp
->conditions
= old_conds
;
5393 gimplify_ctxp
->conditional_cleanups
= old_cleanups
;
5394 gimplify_ctxp
->in_cleanup_point_expr
= old_in_cleanup_point_expr
;
5396 for (iter
= gsi_start (body_sequence
); !gsi_end_p (iter
); )
5398 gimple wce
= gsi_stmt (iter
);
5400 if (gimple_code (wce
) == GIMPLE_WITH_CLEANUP_EXPR
)
5402 if (gsi_one_before_end_p (iter
))
5404 /* Note that gsi_insert_seq_before and gsi_remove do not
5405 scan operands, unlike some other sequence mutators. */
5406 if (!gimple_wce_cleanup_eh_only (wce
))
5407 gsi_insert_seq_before_without_update (&iter
,
5408 gimple_wce_cleanup (wce
),
5410 gsi_remove (&iter
, true);
5417 enum gimple_try_flags kind
;
5419 if (gimple_wce_cleanup_eh_only (wce
))
5420 kind
= GIMPLE_TRY_CATCH
;
5422 kind
= GIMPLE_TRY_FINALLY
;
5423 seq
= gsi_split_seq_after (iter
);
5425 gtry
= gimple_build_try (seq
, gimple_wce_cleanup (wce
), kind
);
5426 /* Do not use gsi_replace here, as it may scan operands.
5427 We want to do a simple structural modification only. */
5428 gsi_set_stmt (&iter
, gtry
);
5429 iter
= gsi_start (gtry
->gimple_try
.eval
);
5436 gimplify_seq_add_seq (pre_p
, body_sequence
);
5449 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5450 is the cleanup action required. EH_ONLY is true if the cleanup should
5451 only be executed if an exception is thrown, not on normal exit. */
5454 gimple_push_cleanup (tree var
, tree cleanup
, bool eh_only
, gimple_seq
*pre_p
)
5457 gimple_seq cleanup_stmts
= NULL
;
5459 /* Errors can result in improperly nested cleanups. Which results in
5460 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5464 if (gimple_conditional_context ())
5466 /* If we're in a conditional context, this is more complex. We only
5467 want to run the cleanup if we actually ran the initialization that
5468 necessitates it, but we want to run it after the end of the
5469 conditional context. So we wrap the try/finally around the
5470 condition and use a flag to determine whether or not to actually
5471 run the destructor. Thus
5475 becomes (approximately)
5479 if (test) { A::A(temp); flag = 1; val = f(temp); }
5482 if (flag) A::~A(temp);
5486 tree flag
= create_tmp_var (boolean_type_node
, "cleanup");
5487 gimple ffalse
= gimple_build_assign (flag
, boolean_false_node
);
5488 gimple ftrue
= gimple_build_assign (flag
, boolean_true_node
);
5490 cleanup
= build3 (COND_EXPR
, void_type_node
, flag
, cleanup
, NULL
);
5491 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5492 wce
= gimple_build_wce (cleanup_stmts
);
5494 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, ffalse
);
5495 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
5496 gimplify_seq_add_stmt (pre_p
, ftrue
);
5498 /* Because of this manipulation, and the EH edges that jump
5499 threading cannot redirect, the temporary (VAR) will appear
5500 to be used uninitialized. Don't warn. */
5501 TREE_NO_WARNING (var
) = 1;
5505 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5506 wce
= gimple_build_wce (cleanup_stmts
);
5507 gimple_wce_set_cleanup_eh_only (wce
, eh_only
);
5508 gimplify_seq_add_stmt (pre_p
, wce
);
5512 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5514 static enum gimplify_status
5515 gimplify_target_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5517 tree targ
= *expr_p
;
5518 tree temp
= TARGET_EXPR_SLOT (targ
);
5519 tree init
= TARGET_EXPR_INITIAL (targ
);
5520 enum gimplify_status ret
;
5524 tree cleanup
= NULL_TREE
;
5526 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5527 to the temps list. Handle also variable length TARGET_EXPRs. */
5528 if (TREE_CODE (DECL_SIZE (temp
)) != INTEGER_CST
)
5530 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp
)))
5531 gimplify_type_sizes (TREE_TYPE (temp
), pre_p
);
5532 gimplify_vla_decl (temp
, pre_p
);
5535 gimple_add_tmp_var (temp
);
5537 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5538 expression is supposed to initialize the slot. */
5539 if (VOID_TYPE_P (TREE_TYPE (init
)))
5540 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5543 tree init_expr
= build2 (INIT_EXPR
, void_type_node
, temp
, init
);
5545 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5547 ggc_free (init_expr
);
5549 if (ret
== GS_ERROR
)
5551 /* PR c++/28266 Make sure this is expanded only once. */
5552 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5556 gimplify_and_add (init
, pre_p
);
5558 /* If needed, push the cleanup for the temp. */
5559 if (TARGET_EXPR_CLEANUP (targ
))
5561 if (CLEANUP_EH_ONLY (targ
))
5562 gimple_push_cleanup (temp
, TARGET_EXPR_CLEANUP (targ
),
5563 CLEANUP_EH_ONLY (targ
), pre_p
);
5565 cleanup
= TARGET_EXPR_CLEANUP (targ
);
5568 /* Add a clobber for the temporary going out of scope, like
5569 gimplify_bind_expr. */
5570 if (gimplify_ctxp
->in_cleanup_point_expr
5571 && needs_to_live_in_memory (temp
)
5572 && flag_stack_reuse
== SR_ALL
)
5574 tree clobber
= build_constructor (TREE_TYPE (temp
),
5576 TREE_THIS_VOLATILE (clobber
) = true;
5577 clobber
= build2 (MODIFY_EXPR
, TREE_TYPE (temp
), temp
, clobber
);
5579 cleanup
= build2 (COMPOUND_EXPR
, void_type_node
, cleanup
,
5586 gimple_push_cleanup (temp
, cleanup
, false, pre_p
);
5588 /* Only expand this once. */
5589 TREE_OPERAND (targ
, 3) = init
;
5590 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5593 /* We should have expanded this before. */
5594 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp
));
5600 /* Gimplification of expression trees. */
5602 /* Gimplify an expression which appears at statement context. The
5603 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5604 NULL, a new sequence is allocated.
5606 Return true if we actually added a statement to the queue. */
5609 gimplify_stmt (tree
*stmt_p
, gimple_seq
*seq_p
)
5611 gimple_seq_node last
;
5613 last
= gimple_seq_last (*seq_p
);
5614 gimplify_expr (stmt_p
, seq_p
, NULL
, is_gimple_stmt
, fb_none
);
5615 return last
!= gimple_seq_last (*seq_p
);
5618 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5619 to CTX. If entries already exist, force them to be some flavor of private.
5620 If there is no enclosing parallel, do nothing. */
5623 omp_firstprivatize_variable (struct gimplify_omp_ctx
*ctx
, tree decl
)
5627 if (decl
== NULL
|| !DECL_P (decl
))
5632 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5635 if (n
->value
& GOVD_SHARED
)
5636 n
->value
= GOVD_FIRSTPRIVATE
| (n
->value
& GOVD_SEEN
);
5637 else if (n
->value
& GOVD_MAP
)
5638 n
->value
|= GOVD_MAP_TO_ONLY
;
5642 else if (ctx
->region_type
== ORT_TARGET
)
5643 omp_add_variable (ctx
, decl
, GOVD_MAP
| GOVD_MAP_TO_ONLY
);
5644 else if (ctx
->region_type
!= ORT_WORKSHARE
5645 && ctx
->region_type
!= ORT_SIMD
5646 && ctx
->region_type
!= ORT_TARGET_DATA
)
5647 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
5649 ctx
= ctx
->outer_context
;
5654 /* Similarly for each of the type sizes of TYPE. */
5657 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx
*ctx
, tree type
)
5659 if (type
== NULL
|| type
== error_mark_node
)
5661 type
= TYPE_MAIN_VARIANT (type
);
5663 if (pointer_set_insert (ctx
->privatized_types
, type
))
5666 switch (TREE_CODE (type
))
5672 case FIXED_POINT_TYPE
:
5673 omp_firstprivatize_variable (ctx
, TYPE_MIN_VALUE (type
));
5674 omp_firstprivatize_variable (ctx
, TYPE_MAX_VALUE (type
));
5678 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5679 omp_firstprivatize_type_sizes (ctx
, TYPE_DOMAIN (type
));
5684 case QUAL_UNION_TYPE
:
5687 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
5688 if (TREE_CODE (field
) == FIELD_DECL
)
5690 omp_firstprivatize_variable (ctx
, DECL_FIELD_OFFSET (field
));
5691 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (field
));
5697 case REFERENCE_TYPE
:
5698 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5705 omp_firstprivatize_variable (ctx
, TYPE_SIZE (type
));
5706 omp_firstprivatize_variable (ctx
, TYPE_SIZE_UNIT (type
));
5707 lang_hooks
.types
.omp_firstprivatize_type_sizes (ctx
, type
);
5710 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
5713 omp_add_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned int flags
)
5716 unsigned int nflags
;
5719 if (error_operand_p (decl
))
5722 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5723 there are constructors involved somewhere. */
5724 if (TREE_ADDRESSABLE (TREE_TYPE (decl
))
5725 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
5728 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5729 if (n
!= NULL
&& n
->value
!= GOVD_ALIGNED
)
5731 /* We shouldn't be re-adding the decl with the same data
5733 gcc_assert ((n
->value
& GOVD_DATA_SHARE_CLASS
& flags
) == 0);
5734 /* The only combination of data sharing classes we should see is
5735 FIRSTPRIVATE and LASTPRIVATE. */
5736 nflags
= n
->value
| flags
;
5737 gcc_assert ((nflags
& GOVD_DATA_SHARE_CLASS
)
5738 == (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
)
5739 || (flags
& GOVD_DATA_SHARE_CLASS
) == 0);
5744 /* When adding a variable-sized variable, we have to handle all sorts
5745 of additional bits of data: the pointer replacement variable, and
5746 the parameters of the type. */
5747 if (DECL_SIZE (decl
) && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5749 /* Add the pointer replacement variable as PRIVATE if the variable
5750 replacement is private, else FIRSTPRIVATE since we'll need the
5751 address of the original variable either for SHARED, or for the
5752 copy into or out of the context. */
5753 if (!(flags
& GOVD_LOCAL
))
5755 nflags
= flags
& GOVD_MAP
5756 ? GOVD_MAP
| GOVD_MAP_TO_ONLY
| GOVD_EXPLICIT
5757 : flags
& GOVD_PRIVATE
? GOVD_PRIVATE
: GOVD_FIRSTPRIVATE
;
5758 nflags
|= flags
& GOVD_SEEN
;
5759 t
= DECL_VALUE_EXPR (decl
);
5760 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5761 t
= TREE_OPERAND (t
, 0);
5762 gcc_assert (DECL_P (t
));
5763 omp_add_variable (ctx
, t
, nflags
);
5766 /* Add all of the variable and type parameters (which should have
5767 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5768 omp_firstprivatize_variable (ctx
, DECL_SIZE_UNIT (decl
));
5769 omp_firstprivatize_variable (ctx
, DECL_SIZE (decl
));
5770 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5772 /* The variable-sized variable itself is never SHARED, only some form
5773 of PRIVATE. The sharing would take place via the pointer variable
5774 which we remapped above. */
5775 if (flags
& GOVD_SHARED
)
5776 flags
= GOVD_PRIVATE
| GOVD_DEBUG_PRIVATE
5777 | (flags
& (GOVD_SEEN
| GOVD_EXPLICIT
));
5779 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5780 alloca statement we generate for the variable, so make sure it
5781 is available. This isn't automatically needed for the SHARED
5782 case, since we won't be allocating local storage then.
5783 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5784 in this case omp_notice_variable will be called later
5785 on when it is gimplified. */
5786 else if (! (flags
& (GOVD_LOCAL
| GOVD_MAP
))
5787 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl
))))
5788 omp_notice_variable (ctx
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)), true);
5790 else if ((flags
& (GOVD_MAP
| GOVD_LOCAL
)) == 0
5791 && lang_hooks
.decls
.omp_privatize_by_reference (decl
))
5793 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5795 /* Similar to the direct variable sized case above, we'll need the
5796 size of references being privatized. */
5797 if ((flags
& GOVD_SHARED
) == 0)
5799 t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
5800 if (TREE_CODE (t
) != INTEGER_CST
)
5801 omp_notice_variable (ctx
, t
, true);
5808 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, flags
);
5811 /* Notice a threadprivate variable DECL used in OpenMP context CTX.
5812 This just prints out diagnostics about threadprivate variable uses
5813 in untied tasks. If DECL2 is non-NULL, prevent this warning
5814 on that variable. */
5817 omp_notice_threadprivate_variable (struct gimplify_omp_ctx
*ctx
, tree decl
,
5821 struct gimplify_omp_ctx
*octx
;
5823 for (octx
= ctx
; octx
; octx
= octx
->outer_context
)
5824 if (octx
->region_type
== ORT_TARGET
)
5826 n
= splay_tree_lookup (octx
->variables
, (splay_tree_key
)decl
);
5829 error ("threadprivate variable %qE used in target region",
5831 error_at (octx
->location
, "enclosing target region");
5832 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl
, 0);
5835 splay_tree_insert (octx
->variables
, (splay_tree_key
)decl2
, 0);
5838 if (ctx
->region_type
!= ORT_UNTIED_TASK
)
5840 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5843 error ("threadprivate variable %qE used in untied task",
5845 error_at (ctx
->location
, "enclosing task");
5846 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, 0);
5849 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl2
, 0);
5853 /* Record the fact that DECL was used within the OpenMP context CTX.
5854 IN_CODE is true when real code uses DECL, and false when we should
5855 merely emit default(none) errors. Return true if DECL is going to
5856 be remapped and thus DECL shouldn't be gimplified into its
5857 DECL_VALUE_EXPR (if any). */
5860 omp_notice_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, bool in_code
)
5863 unsigned flags
= in_code
? GOVD_SEEN
: 0;
5864 bool ret
= false, shared
;
5866 if (error_operand_p (decl
))
5869 /* Threadprivate variables are predetermined. */
5870 if (is_global_var (decl
))
5872 if (DECL_THREAD_LOCAL_P (decl
))
5873 return omp_notice_threadprivate_variable (ctx
, decl
, NULL_TREE
);
5875 if (DECL_HAS_VALUE_EXPR_P (decl
))
5877 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
5879 if (value
&& DECL_P (value
) && DECL_THREAD_LOCAL_P (value
))
5880 return omp_notice_threadprivate_variable (ctx
, decl
, value
);
5884 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5885 if (ctx
->region_type
== ORT_TARGET
)
5889 if (!lang_hooks
.types
.omp_mappable_type (TREE_TYPE (decl
)))
5891 error ("%qD referenced in target region does not have "
5892 "a mappable type", decl
);
5893 omp_add_variable (ctx
, decl
, GOVD_MAP
| GOVD_EXPLICIT
| flags
);
5896 omp_add_variable (ctx
, decl
, GOVD_MAP
| flags
);
5900 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, true);
5906 enum omp_clause_default_kind default_kind
, kind
;
5907 struct gimplify_omp_ctx
*octx
;
5909 if (ctx
->region_type
== ORT_WORKSHARE
5910 || ctx
->region_type
== ORT_SIMD
5911 || ctx
->region_type
== ORT_TARGET_DATA
)
5914 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
5915 remapped firstprivate instead of shared. To some extent this is
5916 addressed in omp_firstprivatize_type_sizes, but not effectively. */
5917 default_kind
= ctx
->default_kind
;
5918 kind
= lang_hooks
.decls
.omp_predetermined_sharing (decl
);
5919 if (kind
!= OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
5920 default_kind
= kind
;
5922 switch (default_kind
)
5924 case OMP_CLAUSE_DEFAULT_NONE
:
5925 if ((ctx
->region_type
& ORT_TASK
) != 0)
5927 error ("%qE not specified in enclosing task",
5928 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5929 error_at (ctx
->location
, "enclosing task");
5931 else if (ctx
->region_type
== ORT_TEAMS
)
5933 error ("%qE not specified in enclosing teams construct",
5934 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5935 error_at (ctx
->location
, "enclosing teams construct");
5939 error ("%qE not specified in enclosing parallel",
5940 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5941 error_at (ctx
->location
, "enclosing parallel");
5944 case OMP_CLAUSE_DEFAULT_SHARED
:
5945 flags
|= GOVD_SHARED
;
5947 case OMP_CLAUSE_DEFAULT_PRIVATE
:
5948 flags
|= GOVD_PRIVATE
;
5950 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
5951 flags
|= GOVD_FIRSTPRIVATE
;
5953 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
5954 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
5955 gcc_assert ((ctx
->region_type
& ORT_TASK
) != 0);
5956 if (ctx
->outer_context
)
5957 omp_notice_variable (ctx
->outer_context
, decl
, in_code
);
5958 for (octx
= ctx
->outer_context
; octx
; octx
= octx
->outer_context
)
5962 if ((octx
->region_type
& (ORT_TARGET_DATA
| ORT_TARGET
)) != 0)
5964 n2
= splay_tree_lookup (octx
->variables
, (splay_tree_key
) decl
);
5965 if (n2
&& (n2
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
)
5967 flags
|= GOVD_FIRSTPRIVATE
;
5970 if ((octx
->region_type
& (ORT_PARALLEL
| ORT_TEAMS
)) != 0)
5973 if (flags
& GOVD_FIRSTPRIVATE
)
5976 && (TREE_CODE (decl
) == PARM_DECL
5977 || (!is_global_var (decl
)
5978 && DECL_CONTEXT (decl
) == current_function_decl
)))
5980 flags
|= GOVD_FIRSTPRIVATE
;
5983 flags
|= GOVD_SHARED
;
5989 if ((flags
& GOVD_PRIVATE
)
5990 && lang_hooks
.decls
.omp_private_outer_ref (decl
))
5991 flags
|= GOVD_PRIVATE_OUTER_REF
;
5993 omp_add_variable (ctx
, decl
, flags
);
5995 shared
= (flags
& GOVD_SHARED
) != 0;
5996 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
6000 if ((n
->value
& (GOVD_SEEN
| GOVD_LOCAL
)) == 0
6001 && (flags
& (GOVD_SEEN
| GOVD_LOCAL
)) == GOVD_SEEN
6003 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6006 tree t
= DECL_VALUE_EXPR (decl
);
6007 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
6008 t
= TREE_OPERAND (t
, 0);
6009 gcc_assert (DECL_P (t
));
6010 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
6011 n2
->value
|= GOVD_SEEN
;
6014 shared
= ((flags
| n
->value
) & GOVD_SHARED
) != 0;
6015 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
6017 /* If nothing changed, there's nothing left to do. */
6018 if ((n
->value
& flags
) == flags
)
6024 /* If the variable is private in the current context, then we don't
6025 need to propagate anything to an outer context. */
6026 if ((flags
& GOVD_PRIVATE
) && !(flags
& GOVD_PRIVATE_OUTER_REF
))
6028 if (ctx
->outer_context
6029 && omp_notice_variable (ctx
->outer_context
, decl
, in_code
))
6034 /* Verify that DECL is private within CTX. If there's specific information
6035 to the contrary in the innermost scope, generate an error. */
6038 omp_is_private (struct gimplify_omp_ctx
*ctx
, tree decl
, bool simd
)
6042 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
6045 if (n
->value
& GOVD_SHARED
)
6047 if (ctx
== gimplify_omp_ctxp
)
6050 error ("iteration variable %qE is predetermined linear",
6053 error ("iteration variable %qE should be private",
6055 n
->value
= GOVD_PRIVATE
;
6061 else if ((n
->value
& GOVD_EXPLICIT
) != 0
6062 && (ctx
== gimplify_omp_ctxp
6063 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6064 && gimplify_omp_ctxp
->outer_context
== ctx
)))
6066 if ((n
->value
& GOVD_FIRSTPRIVATE
) != 0)
6067 error ("iteration variable %qE should not be firstprivate",
6069 else if ((n
->value
& GOVD_REDUCTION
) != 0)
6070 error ("iteration variable %qE should not be reduction",
6072 else if (simd
&& (n
->value
& GOVD_LASTPRIVATE
) != 0)
6073 error ("iteration variable %qE should not be lastprivate",
6075 else if (simd
&& (n
->value
& GOVD_PRIVATE
) != 0)
6076 error ("iteration variable %qE should not be private",
6078 else if (simd
&& (n
->value
& GOVD_LINEAR
) != 0)
6079 error ("iteration variable %qE is predetermined linear",
6082 return (ctx
== gimplify_omp_ctxp
6083 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6084 && gimplify_omp_ctxp
->outer_context
== ctx
));
6087 if (ctx
->region_type
!= ORT_WORKSHARE
6088 && ctx
->region_type
!= ORT_SIMD
)
6090 else if (ctx
->outer_context
)
6091 return omp_is_private (ctx
->outer_context
, decl
, simd
);
6095 /* Return true if DECL is private within a parallel region
6096 that binds to the current construct's context or in parallel
6097 region's REDUCTION clause. */
6100 omp_check_private (struct gimplify_omp_ctx
*ctx
, tree decl
)
6106 ctx
= ctx
->outer_context
;
6108 return !(is_global_var (decl
)
6109 /* References might be private, but might be shared too. */
6110 || lang_hooks
.decls
.omp_privatize_by_reference (decl
));
6112 if ((ctx
->region_type
& (ORT_TARGET
| ORT_TARGET_DATA
)) != 0)
6115 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6117 return (n
->value
& GOVD_SHARED
) == 0;
6119 while (ctx
->region_type
== ORT_WORKSHARE
6120 || ctx
->region_type
== ORT_SIMD
);
6124 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
6125 and previous omp contexts. */
6128 gimplify_scan_omp_clauses (tree
*list_p
, gimple_seq
*pre_p
,
6129 enum omp_region_type region_type
)
6131 struct gimplify_omp_ctx
*ctx
, *outer_ctx
;
6132 struct gimplify_ctx gctx
;
6135 ctx
= new_omp_context (region_type
);
6136 outer_ctx
= ctx
->outer_context
;
6138 while ((c
= *list_p
) != NULL
)
6140 bool remove
= false;
6141 bool notice_outer
= true;
6142 const char *check_non_private
= NULL
;
6146 switch (OMP_CLAUSE_CODE (c
))
6148 case OMP_CLAUSE_PRIVATE
:
6149 flags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
6150 if (lang_hooks
.decls
.omp_private_outer_ref (OMP_CLAUSE_DECL (c
)))
6152 flags
|= GOVD_PRIVATE_OUTER_REF
;
6153 OMP_CLAUSE_PRIVATE_OUTER_REF (c
) = 1;
6156 notice_outer
= false;
6158 case OMP_CLAUSE_SHARED
:
6159 flags
= GOVD_SHARED
| GOVD_EXPLICIT
;
6161 case OMP_CLAUSE_FIRSTPRIVATE
:
6162 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
6163 check_non_private
= "firstprivate";
6165 case OMP_CLAUSE_LASTPRIVATE
:
6166 flags
= GOVD_LASTPRIVATE
| GOVD_SEEN
| GOVD_EXPLICIT
;
6167 check_non_private
= "lastprivate";
6169 case OMP_CLAUSE_REDUCTION
:
6170 flags
= GOVD_REDUCTION
| GOVD_SEEN
| GOVD_EXPLICIT
;
6171 check_non_private
= "reduction";
6173 case OMP_CLAUSE_LINEAR
:
6174 if (gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
), pre_p
, NULL
,
6175 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6180 flags
= GOVD_LINEAR
| GOVD_EXPLICIT
;
6183 case OMP_CLAUSE_MAP
:
6184 if (OMP_CLAUSE_SIZE (c
)
6185 && gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
6186 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6191 decl
= OMP_CLAUSE_DECL (c
);
6194 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
,
6195 NULL
, is_gimple_lvalue
, fb_lvalue
)
6203 flags
= GOVD_MAP
| GOVD_EXPLICIT
;
6206 case OMP_CLAUSE_DEPEND
:
6207 if (TREE_CODE (OMP_CLAUSE_DECL (c
)) == COMPOUND_EXPR
)
6209 gimplify_expr (&TREE_OPERAND (OMP_CLAUSE_DECL (c
), 0), pre_p
,
6210 NULL
, is_gimple_val
, fb_rvalue
);
6211 OMP_CLAUSE_DECL (c
) = TREE_OPERAND (OMP_CLAUSE_DECL (c
), 1);
6213 if (error_operand_p (OMP_CLAUSE_DECL (c
)))
6218 OMP_CLAUSE_DECL (c
) = build_fold_addr_expr (OMP_CLAUSE_DECL (c
));
6219 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
, NULL
,
6220 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6228 case OMP_CLAUSE_FROM
:
6229 if (OMP_CLAUSE_SIZE (c
)
6230 && gimplify_expr (&OMP_CLAUSE_SIZE (c
), pre_p
,
6231 NULL
, is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6236 decl
= OMP_CLAUSE_DECL (c
);
6237 if (error_operand_p (decl
))
6244 if (gimplify_expr (&OMP_CLAUSE_DECL (c
), pre_p
,
6245 NULL
, is_gimple_lvalue
, fb_lvalue
)
6256 decl
= OMP_CLAUSE_DECL (c
);
6257 if (error_operand_p (decl
))
6262 omp_add_variable (ctx
, decl
, flags
);
6263 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
6264 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
6266 omp_add_variable (ctx
, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
),
6267 GOVD_LOCAL
| GOVD_SEEN
);
6268 gimplify_omp_ctxp
= ctx
;
6269 push_gimplify_context (&gctx
);
6271 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
6272 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
6274 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c
),
6275 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
6276 pop_gimplify_context
6277 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
)));
6278 push_gimplify_context (&gctx
);
6279 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c
),
6280 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
6281 pop_gimplify_context
6282 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
)));
6283 OMP_CLAUSE_REDUCTION_INIT (c
) = NULL_TREE
;
6284 OMP_CLAUSE_REDUCTION_MERGE (c
) = NULL_TREE
;
6286 gimplify_omp_ctxp
= outer_ctx
;
6288 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6289 && OMP_CLAUSE_LASTPRIVATE_STMT (c
))
6291 gimplify_omp_ctxp
= ctx
;
6292 push_gimplify_context (&gctx
);
6293 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c
)) != BIND_EXPR
)
6295 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
6297 TREE_SIDE_EFFECTS (bind
) = 1;
6298 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LASTPRIVATE_STMT (c
);
6299 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = bind
;
6301 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c
),
6302 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6303 pop_gimplify_context
6304 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
)));
6305 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = NULL_TREE
;
6307 gimplify_omp_ctxp
= outer_ctx
;
6313 case OMP_CLAUSE_COPYIN
:
6314 case OMP_CLAUSE_COPYPRIVATE
:
6315 decl
= OMP_CLAUSE_DECL (c
);
6316 if (error_operand_p (decl
))
6323 omp_notice_variable (outer_ctx
, decl
, true);
6324 if (check_non_private
6325 && region_type
== ORT_WORKSHARE
6326 && omp_check_private (ctx
, decl
))
6328 error ("%s variable %qE is private in outer context",
6329 check_non_private
, DECL_NAME (decl
));
6334 case OMP_CLAUSE_FINAL
:
6336 OMP_CLAUSE_OPERAND (c
, 0)
6337 = gimple_boolify (OMP_CLAUSE_OPERAND (c
, 0));
6340 case OMP_CLAUSE_SCHEDULE
:
6341 case OMP_CLAUSE_NUM_THREADS
:
6342 case OMP_CLAUSE_NUM_TEAMS
:
6343 case OMP_CLAUSE_THREAD_LIMIT
:
6344 case OMP_CLAUSE_DIST_SCHEDULE
:
6345 case OMP_CLAUSE_DEVICE
:
6346 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
6347 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6351 case OMP_CLAUSE_NOWAIT
:
6352 case OMP_CLAUSE_ORDERED
:
6353 case OMP_CLAUSE_UNTIED
:
6354 case OMP_CLAUSE_COLLAPSE
:
6355 case OMP_CLAUSE_MERGEABLE
:
6356 case OMP_CLAUSE_PROC_BIND
:
6357 case OMP_CLAUSE_SAFELEN
:
6360 case OMP_CLAUSE_ALIGNED
:
6361 decl
= OMP_CLAUSE_DECL (c
);
6362 if (error_operand_p (decl
))
6367 if (!is_global_var (decl
)
6368 && TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
6369 omp_add_variable (ctx
, decl
, GOVD_ALIGNED
);
6372 case OMP_CLAUSE_DEFAULT
:
6373 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
6381 *list_p
= OMP_CLAUSE_CHAIN (c
);
6383 list_p
= &OMP_CLAUSE_CHAIN (c
);
6386 gimplify_omp_ctxp
= ctx
;
6389 /* For all variables that were not actually used within the context,
6390 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
6393 gimplify_adjust_omp_clauses_1 (splay_tree_node n
, void *data
)
6395 tree
*list_p
= (tree
*) data
;
6396 tree decl
= (tree
) n
->key
;
6397 unsigned flags
= n
->value
;
6398 enum omp_clause_code code
;
6402 if (flags
& (GOVD_EXPLICIT
| GOVD_LOCAL
))
6404 if ((flags
& GOVD_SEEN
) == 0)
6406 if (flags
& GOVD_DEBUG_PRIVATE
)
6408 gcc_assert ((flags
& GOVD_DATA_SHARE_CLASS
) == GOVD_PRIVATE
);
6409 private_debug
= true;
6411 else if (flags
& GOVD_MAP
)
6412 private_debug
= false;
6415 = lang_hooks
.decls
.omp_private_debug_clause (decl
,
6416 !!(flags
& GOVD_SHARED
));
6418 code
= OMP_CLAUSE_PRIVATE
;
6419 else if (flags
& GOVD_MAP
)
6420 code
= OMP_CLAUSE_MAP
;
6421 else if (flags
& GOVD_SHARED
)
6423 if (is_global_var (decl
))
6425 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
6429 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6430 if (on
&& (on
->value
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
6431 | GOVD_PRIVATE
| GOVD_REDUCTION
6432 | GOVD_LINEAR
)) != 0)
6434 ctx
= ctx
->outer_context
;
6439 code
= OMP_CLAUSE_SHARED
;
6441 else if (flags
& GOVD_PRIVATE
)
6442 code
= OMP_CLAUSE_PRIVATE
;
6443 else if (flags
& GOVD_FIRSTPRIVATE
)
6444 code
= OMP_CLAUSE_FIRSTPRIVATE
;
6445 else if (flags
& GOVD_LASTPRIVATE
)
6446 code
= OMP_CLAUSE_LASTPRIVATE
;
6447 else if (flags
& GOVD_ALIGNED
)
6452 clause
= build_omp_clause (input_location
, code
);
6453 OMP_CLAUSE_DECL (clause
) = decl
;
6454 OMP_CLAUSE_CHAIN (clause
) = *list_p
;
6456 OMP_CLAUSE_PRIVATE_DEBUG (clause
) = 1;
6457 else if (code
== OMP_CLAUSE_PRIVATE
&& (flags
& GOVD_PRIVATE_OUTER_REF
))
6458 OMP_CLAUSE_PRIVATE_OUTER_REF (clause
) = 1;
6459 else if (code
== OMP_CLAUSE_MAP
)
6461 OMP_CLAUSE_MAP_KIND (clause
) = flags
& GOVD_MAP_TO_ONLY
6463 : OMP_CLAUSE_MAP_TOFROM
;
6464 if (DECL_SIZE (decl
)
6465 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6467 tree decl2
= DECL_VALUE_EXPR (decl
);
6468 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
6469 decl2
= TREE_OPERAND (decl2
, 0);
6470 gcc_assert (DECL_P (decl2
));
6471 tree mem
= build_simple_mem_ref (decl2
);
6472 OMP_CLAUSE_DECL (clause
) = mem
;
6473 OMP_CLAUSE_SIZE (clause
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6474 if (gimplify_omp_ctxp
->outer_context
)
6476 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
6477 omp_notice_variable (ctx
, decl2
, true);
6478 omp_notice_variable (ctx
, OMP_CLAUSE_SIZE (clause
), true);
6480 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (clause
),
6482 OMP_CLAUSE_DECL (nc
) = decl
;
6483 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
6484 OMP_CLAUSE_MAP_KIND (nc
) = OMP_CLAUSE_MAP_POINTER
;
6485 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (clause
);
6486 OMP_CLAUSE_CHAIN (clause
) = nc
;
6490 lang_hooks
.decls
.omp_finish_clause (clause
);
6496 gimplify_adjust_omp_clauses (tree
*list_p
)
6498 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6501 while ((c
= *list_p
) != NULL
)
6504 bool remove
= false;
6506 switch (OMP_CLAUSE_CODE (c
))
6508 case OMP_CLAUSE_PRIVATE
:
6509 case OMP_CLAUSE_SHARED
:
6510 case OMP_CLAUSE_FIRSTPRIVATE
:
6511 case OMP_CLAUSE_LINEAR
:
6512 decl
= OMP_CLAUSE_DECL (c
);
6513 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6514 remove
= !(n
->value
& GOVD_SEEN
);
6517 bool shared
= OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
;
6518 if ((n
->value
& GOVD_DEBUG_PRIVATE
)
6519 || lang_hooks
.decls
.omp_private_debug_clause (decl
, shared
))
6521 gcc_assert ((n
->value
& GOVD_DEBUG_PRIVATE
) == 0
6522 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
6524 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_PRIVATE
);
6525 OMP_CLAUSE_PRIVATE_DEBUG (c
) = 1;
6527 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
6528 && ctx
->outer_context
6529 && !(OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
6530 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
6531 && !is_global_var (decl
))
6533 if (ctx
->outer_context
->region_type
== ORT_COMBINED_PARALLEL
)
6535 n
= splay_tree_lookup (ctx
->outer_context
->variables
,
6536 (splay_tree_key
) decl
);
6538 || (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
6540 int flags
= OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
6541 ? GOVD_LASTPRIVATE
: GOVD_SHARED
;
6543 omp_add_variable (ctx
->outer_context
, decl
,
6546 n
->value
|= flags
| GOVD_SEEN
;
6550 omp_notice_variable (ctx
->outer_context
, decl
, true);
6555 case OMP_CLAUSE_LASTPRIVATE
:
6556 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
6557 accurately reflect the presence of a FIRSTPRIVATE clause. */
6558 decl
= OMP_CLAUSE_DECL (c
);
6559 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6560 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
6561 = (n
->value
& GOVD_FIRSTPRIVATE
) != 0;
6564 case OMP_CLAUSE_ALIGNED
:
6565 decl
= OMP_CLAUSE_DECL (c
);
6566 if (!is_global_var (decl
))
6568 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6569 remove
= n
== NULL
|| !(n
->value
& GOVD_SEEN
);
6570 if (!remove
&& TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
6572 struct gimplify_omp_ctx
*octx
;
6574 && (n
->value
& (GOVD_DATA_SHARE_CLASS
6575 & ~GOVD_FIRSTPRIVATE
)))
6578 for (octx
= ctx
->outer_context
; octx
;
6579 octx
= octx
->outer_context
)
6581 n
= splay_tree_lookup (octx
->variables
,
6582 (splay_tree_key
) decl
);
6585 if (n
->value
& GOVD_LOCAL
)
6587 /* We have to avoid assigning a shared variable
6588 to itself when trying to add
6589 __builtin_assume_aligned. */
6590 if (n
->value
& GOVD_SHARED
)
6598 else if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
6600 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6601 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
6606 case OMP_CLAUSE_MAP
:
6607 decl
= OMP_CLAUSE_DECL (c
);
6610 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6611 if (ctx
->region_type
== ORT_TARGET
&& !(n
->value
& GOVD_SEEN
))
6613 else if (DECL_SIZE (decl
)
6614 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
6615 && OMP_CLAUSE_MAP_KIND (c
) != OMP_CLAUSE_MAP_POINTER
)
6617 tree decl2
= DECL_VALUE_EXPR (decl
);
6618 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
6619 decl2
= TREE_OPERAND (decl2
, 0);
6620 gcc_assert (DECL_P (decl2
));
6621 tree mem
= build_simple_mem_ref (decl2
);
6622 OMP_CLAUSE_DECL (c
) = mem
;
6623 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6624 if (ctx
->outer_context
)
6626 omp_notice_variable (ctx
->outer_context
, decl2
, true);
6627 omp_notice_variable (ctx
->outer_context
,
6628 OMP_CLAUSE_SIZE (c
), true);
6630 tree nc
= build_omp_clause (OMP_CLAUSE_LOCATION (c
),
6632 OMP_CLAUSE_DECL (nc
) = decl
;
6633 OMP_CLAUSE_SIZE (nc
) = size_zero_node
;
6634 OMP_CLAUSE_MAP_KIND (nc
) = OMP_CLAUSE_MAP_POINTER
;
6635 OMP_CLAUSE_CHAIN (nc
) = OMP_CLAUSE_CHAIN (c
);
6636 OMP_CLAUSE_CHAIN (c
) = nc
;
6642 case OMP_CLAUSE_FROM
:
6643 decl
= OMP_CLAUSE_DECL (c
);
6646 if (DECL_SIZE (decl
)
6647 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6649 tree decl2
= DECL_VALUE_EXPR (decl
);
6650 gcc_assert (TREE_CODE (decl2
) == INDIRECT_REF
);
6651 decl2
= TREE_OPERAND (decl2
, 0);
6652 gcc_assert (DECL_P (decl2
));
6653 tree mem
= build_simple_mem_ref (decl2
);
6654 OMP_CLAUSE_DECL (c
) = mem
;
6655 OMP_CLAUSE_SIZE (c
) = TYPE_SIZE_UNIT (TREE_TYPE (decl
));
6656 if (ctx
->outer_context
)
6658 omp_notice_variable (ctx
->outer_context
, decl2
, true);
6659 omp_notice_variable (ctx
->outer_context
,
6660 OMP_CLAUSE_SIZE (c
), true);
6665 case OMP_CLAUSE_REDUCTION
:
6666 case OMP_CLAUSE_COPYIN
:
6667 case OMP_CLAUSE_COPYPRIVATE
:
6669 case OMP_CLAUSE_NUM_THREADS
:
6670 case OMP_CLAUSE_NUM_TEAMS
:
6671 case OMP_CLAUSE_THREAD_LIMIT
:
6672 case OMP_CLAUSE_DIST_SCHEDULE
:
6673 case OMP_CLAUSE_DEVICE
:
6674 case OMP_CLAUSE_SCHEDULE
:
6675 case OMP_CLAUSE_NOWAIT
:
6676 case OMP_CLAUSE_ORDERED
:
6677 case OMP_CLAUSE_DEFAULT
:
6678 case OMP_CLAUSE_UNTIED
:
6679 case OMP_CLAUSE_COLLAPSE
:
6680 case OMP_CLAUSE_FINAL
:
6681 case OMP_CLAUSE_MERGEABLE
:
6682 case OMP_CLAUSE_PROC_BIND
:
6683 case OMP_CLAUSE_SAFELEN
:
6684 case OMP_CLAUSE_DEPEND
:
6692 *list_p
= OMP_CLAUSE_CHAIN (c
);
6694 list_p
= &OMP_CLAUSE_CHAIN (c
);
6697 /* Add in any implicit data sharing. */
6698 splay_tree_foreach (ctx
->variables
, gimplify_adjust_omp_clauses_1
, list_p
);
6700 gimplify_omp_ctxp
= ctx
->outer_context
;
6701 delete_omp_context (ctx
);
6704 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
6705 gimplification of the body, as well as scanning the body for used
6706 variables. We need to do this scan now, because variable-sized
6707 decls will be decomposed during gimplification. */
6710 gimplify_omp_parallel (tree
*expr_p
, gimple_seq
*pre_p
)
6712 tree expr
= *expr_p
;
6714 gimple_seq body
= NULL
;
6715 struct gimplify_ctx gctx
;
6717 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
), pre_p
,
6718 OMP_PARALLEL_COMBINED (expr
)
6719 ? ORT_COMBINED_PARALLEL
6722 push_gimplify_context (&gctx
);
6724 g
= gimplify_and_return_first (OMP_PARALLEL_BODY (expr
), &body
);
6725 if (gimple_code (g
) == GIMPLE_BIND
)
6726 pop_gimplify_context (g
);
6728 pop_gimplify_context (NULL
);
6730 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
));
6732 g
= gimple_build_omp_parallel (body
,
6733 OMP_PARALLEL_CLAUSES (expr
),
6734 NULL_TREE
, NULL_TREE
);
6735 if (OMP_PARALLEL_COMBINED (expr
))
6736 gimple_omp_set_subcode (g
, GF_OMP_PARALLEL_COMBINED
);
6737 gimplify_seq_add_stmt (pre_p
, g
);
6738 *expr_p
= NULL_TREE
;
6741 /* Gimplify the contents of an OMP_TASK statement. This involves
6742 gimplification of the body, as well as scanning the body for used
6743 variables. We need to do this scan now, because variable-sized
6744 decls will be decomposed during gimplification. */
6747 gimplify_omp_task (tree
*expr_p
, gimple_seq
*pre_p
)
6749 tree expr
= *expr_p
;
6751 gimple_seq body
= NULL
;
6752 struct gimplify_ctx gctx
;
6754 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr
), pre_p
,
6755 find_omp_clause (OMP_TASK_CLAUSES (expr
),
6757 ? ORT_UNTIED_TASK
: ORT_TASK
);
6759 push_gimplify_context (&gctx
);
6761 g
= gimplify_and_return_first (OMP_TASK_BODY (expr
), &body
);
6762 if (gimple_code (g
) == GIMPLE_BIND
)
6763 pop_gimplify_context (g
);
6765 pop_gimplify_context (NULL
);
6767 gimplify_adjust_omp_clauses (&OMP_TASK_CLAUSES (expr
));
6769 g
= gimple_build_omp_task (body
,
6770 OMP_TASK_CLAUSES (expr
),
6771 NULL_TREE
, NULL_TREE
,
6772 NULL_TREE
, NULL_TREE
, NULL_TREE
);
6773 gimplify_seq_add_stmt (pre_p
, g
);
6774 *expr_p
= NULL_TREE
;
6777 /* Helper function of gimplify_omp_for, find OMP_FOR resp. OMP_SIMD
6778 with non-NULL OMP_FOR_INIT. */
6781 find_combined_omp_for (tree
*tp
, int *walk_subtrees
, void *)
6784 switch (TREE_CODE (*tp
))
6790 if (OMP_FOR_INIT (*tp
) != NULL_TREE
)
6794 case STATEMENT_LIST
:
6804 /* Gimplify the gross structure of an OMP_FOR statement. */
6806 static enum gimplify_status
6807 gimplify_omp_for (tree
*expr_p
, gimple_seq
*pre_p
)
6809 tree for_stmt
, orig_for_stmt
, decl
, var
, t
;
6810 enum gimplify_status ret
= GS_ALL_DONE
;
6811 enum gimplify_status tret
;
6813 gimple_seq for_body
, for_pre_body
;
6816 bitmap has_decl_expr
= NULL
;
6818 orig_for_stmt
= for_stmt
= *expr_p
;
6820 simd
= TREE_CODE (for_stmt
) == OMP_SIMD
;
6821 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
), pre_p
,
6822 simd
? ORT_SIMD
: ORT_WORKSHARE
);
6824 /* Handle OMP_FOR_INIT. */
6825 for_pre_body
= NULL
;
6826 if (simd
&& OMP_FOR_PRE_BODY (for_stmt
))
6828 has_decl_expr
= BITMAP_ALLOC (NULL
);
6829 if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == DECL_EXPR
6830 && TREE_CODE (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt
)))
6833 t
= OMP_FOR_PRE_BODY (for_stmt
);
6834 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
6836 else if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == STATEMENT_LIST
)
6838 tree_stmt_iterator si
;
6839 for (si
= tsi_start (OMP_FOR_PRE_BODY (for_stmt
)); !tsi_end_p (si
);
6843 if (TREE_CODE (t
) == DECL_EXPR
6844 && TREE_CODE (DECL_EXPR_DECL (t
)) == VAR_DECL
)
6845 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
6849 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
6850 OMP_FOR_PRE_BODY (for_stmt
) = NULL_TREE
;
6852 if (OMP_FOR_INIT (for_stmt
) == NULL_TREE
)
6854 for_stmt
= walk_tree (&OMP_FOR_BODY (for_stmt
), find_combined_omp_for
,
6856 gcc_assert (for_stmt
!= NULL_TREE
);
6857 gimplify_omp_ctxp
->combined_loop
= true;
6861 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6862 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt
)));
6863 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6864 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt
)));
6865 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6867 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6868 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6869 decl
= TREE_OPERAND (t
, 0);
6870 gcc_assert (DECL_P (decl
));
6871 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl
))
6872 || POINTER_TYPE_P (TREE_TYPE (decl
)));
6874 /* Make sure the iteration variable is private. */
6876 if (orig_for_stmt
!= for_stmt
)
6877 /* Do this only on innermost construct for combined ones. */;
6880 splay_tree_node n
= splay_tree_lookup (gimplify_omp_ctxp
->variables
,
6881 (splay_tree_key
)decl
);
6882 omp_is_private (gimplify_omp_ctxp
, decl
, simd
);
6883 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
6884 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
6885 else if (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
6887 c
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
6888 OMP_CLAUSE_LINEAR_NO_COPYIN (c
) = 1;
6890 && bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)))
6891 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
6892 OMP_CLAUSE_DECL (c
) = decl
;
6893 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
6894 OMP_FOR_CLAUSES (for_stmt
) = c
;
6895 omp_add_variable (gimplify_omp_ctxp
, decl
,
6896 GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
);
6902 || !bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)));
6903 c
= build_omp_clause (input_location
,
6904 lastprivate
? OMP_CLAUSE_LASTPRIVATE
6905 : OMP_CLAUSE_PRIVATE
);
6906 OMP_CLAUSE_DECL (c
) = decl
;
6907 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
6908 omp_add_variable (gimplify_omp_ctxp
, decl
,
6909 (lastprivate
? GOVD_LASTPRIVATE
: GOVD_PRIVATE
)
6914 else if (omp_is_private (gimplify_omp_ctxp
, decl
, simd
))
6915 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
6917 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_PRIVATE
| GOVD_SEEN
);
6919 /* If DECL is not a gimple register, create a temporary variable to act
6920 as an iteration counter. This is valid, since DECL cannot be
6921 modified in the body of the loop. */
6922 if (orig_for_stmt
!= for_stmt
)
6924 else if (!is_gimple_reg (decl
))
6926 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
6927 TREE_OPERAND (t
, 0) = var
;
6929 gimplify_seq_add_stmt (&for_body
, gimple_build_assign (decl
, var
));
6931 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
6936 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6937 is_gimple_val
, fb_rvalue
);
6938 ret
= MIN (ret
, tret
);
6939 if (ret
== GS_ERROR
)
6942 /* Handle OMP_FOR_COND. */
6943 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
6944 gcc_assert (COMPARISON_CLASS_P (t
));
6945 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6947 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6948 is_gimple_val
, fb_rvalue
);
6949 ret
= MIN (ret
, tret
);
6951 /* Handle OMP_FOR_INCR. */
6952 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6953 switch (TREE_CODE (t
))
6955 case PREINCREMENT_EXPR
:
6956 case POSTINCREMENT_EXPR
:
6957 if (orig_for_stmt
!= for_stmt
)
6959 t
= build_int_cst (TREE_TYPE (decl
), 1);
6961 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
6962 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6963 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6964 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6967 case PREDECREMENT_EXPR
:
6968 case POSTDECREMENT_EXPR
:
6969 if (orig_for_stmt
!= for_stmt
)
6971 t
= build_int_cst (TREE_TYPE (decl
), -1);
6973 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
6974 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6975 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6976 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6980 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6981 TREE_OPERAND (t
, 0) = var
;
6983 t
= TREE_OPERAND (t
, 1);
6984 switch (TREE_CODE (t
))
6987 if (TREE_OPERAND (t
, 1) == decl
)
6989 TREE_OPERAND (t
, 1) = TREE_OPERAND (t
, 0);
6990 TREE_OPERAND (t
, 0) = var
;
6996 case POINTER_PLUS_EXPR
:
6997 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6998 TREE_OPERAND (t
, 0) = var
;
7004 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
7005 is_gimple_val
, fb_rvalue
);
7006 ret
= MIN (ret
, tret
);
7009 OMP_CLAUSE_LINEAR_STEP (c
) = TREE_OPERAND (t
, 1);
7010 if (TREE_CODE (t
) == MINUS_EXPR
)
7012 t
= TREE_OPERAND (t
, 1);
7013 OMP_CLAUSE_LINEAR_STEP (c
)
7014 = fold_build1 (NEGATE_EXPR
, TREE_TYPE (t
), t
);
7015 tret
= gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
),
7016 &for_pre_body
, NULL
,
7017 is_gimple_val
, fb_rvalue
);
7018 ret
= MIN (ret
, tret
);
7027 if ((var
!= decl
|| TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1)
7028 && orig_for_stmt
== for_stmt
)
7030 for (c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
7031 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
7032 && OMP_CLAUSE_DECL (c
) == decl
7033 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) == NULL
)
7035 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7036 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
7037 gcc_assert (TREE_OPERAND (t
, 0) == var
);
7038 t
= TREE_OPERAND (t
, 1);
7039 gcc_assert (TREE_CODE (t
) == PLUS_EXPR
7040 || TREE_CODE (t
) == MINUS_EXPR
7041 || TREE_CODE (t
) == POINTER_PLUS_EXPR
);
7042 gcc_assert (TREE_OPERAND (t
, 0) == var
);
7043 t
= build2 (TREE_CODE (t
), TREE_TYPE (decl
), decl
,
7044 TREE_OPERAND (t
, 1));
7045 gimplify_assign (decl
, t
,
7046 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
7051 BITMAP_FREE (has_decl_expr
);
7053 gimplify_and_add (OMP_FOR_BODY (orig_for_stmt
), &for_body
);
7055 if (orig_for_stmt
!= for_stmt
)
7056 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
7058 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
7059 decl
= TREE_OPERAND (t
, 0);
7060 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
7061 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
7062 TREE_OPERAND (t
, 0) = var
;
7063 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7064 TREE_OPERAND (t
, 1) = copy_node (TREE_OPERAND (t
, 1));
7065 TREE_OPERAND (TREE_OPERAND (t
, 1), 0) = var
;
7068 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (orig_for_stmt
));
7071 switch (TREE_CODE (orig_for_stmt
))
7073 case OMP_FOR
: kind
= GF_OMP_FOR_KIND_FOR
; break;
7074 case OMP_SIMD
: kind
= GF_OMP_FOR_KIND_SIMD
; break;
7075 case OMP_DISTRIBUTE
: kind
= GF_OMP_FOR_KIND_DISTRIBUTE
; break;
7079 gfor
= gimple_build_omp_for (for_body
, kind
, OMP_FOR_CLAUSES (orig_for_stmt
),
7080 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)),
7082 if (orig_for_stmt
!= for_stmt
)
7083 gimple_omp_for_set_combined_p (gfor
, true);
7084 if (gimplify_omp_ctxp
7085 && (gimplify_omp_ctxp
->combined_loop
7086 || (gimplify_omp_ctxp
->region_type
== ORT_COMBINED_PARALLEL
7087 && gimplify_omp_ctxp
->outer_context
7088 && gimplify_omp_ctxp
->outer_context
->combined_loop
)))
7090 gimple_omp_for_set_combined_into_p (gfor
, true);
7091 if (gimplify_omp_ctxp
->combined_loop
)
7092 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_SIMD
);
7094 gcc_assert (TREE_CODE (orig_for_stmt
) == OMP_FOR
);
7097 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
7099 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
7100 gimple_omp_for_set_index (gfor
, i
, TREE_OPERAND (t
, 0));
7101 gimple_omp_for_set_initial (gfor
, i
, TREE_OPERAND (t
, 1));
7102 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
7103 gimple_omp_for_set_cond (gfor
, i
, TREE_CODE (t
));
7104 gimple_omp_for_set_final (gfor
, i
, TREE_OPERAND (t
, 1));
7105 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
7106 gimple_omp_for_set_incr (gfor
, i
, TREE_OPERAND (t
, 1));
7109 gimplify_seq_add_stmt (pre_p
, gfor
);
7110 if (ret
!= GS_ALL_DONE
)
7112 *expr_p
= NULL_TREE
;
7116 /* Gimplify the gross structure of other OpenMP constructs.
7117 In particular, OMP_SECTIONS, OMP_SINGLE, OMP_TARGET, OMP_TARGET_DATA
7121 gimplify_omp_workshare (tree
*expr_p
, gimple_seq
*pre_p
)
7123 tree expr
= *expr_p
;
7125 gimple_seq body
= NULL
;
7126 enum omp_region_type ort
= ORT_WORKSHARE
;
7128 switch (TREE_CODE (expr
))
7136 case OMP_TARGET_DATA
:
7137 ort
= ORT_TARGET_DATA
;
7145 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr
), pre_p
, ort
);
7146 if (ort
== ORT_TARGET
|| ort
== ORT_TARGET_DATA
)
7148 struct gimplify_ctx gctx
;
7149 push_gimplify_context (&gctx
);
7150 gimple g
= gimplify_and_return_first (OMP_BODY (expr
), &body
);
7151 if (gimple_code (g
) == GIMPLE_BIND
)
7152 pop_gimplify_context (g
);
7154 pop_gimplify_context (NULL
);
7155 if (ort
== ORT_TARGET_DATA
)
7157 gimple_seq cleanup
= NULL
;
7158 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_TARGET_END_DATA
);
7159 g
= gimple_build_call (fn
, 0);
7160 gimple_seq_add_stmt (&cleanup
, g
);
7161 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
7163 gimple_seq_add_stmt (&body
, g
);
7167 gimplify_and_add (OMP_BODY (expr
), &body
);
7168 gimplify_adjust_omp_clauses (&OMP_CLAUSES (expr
));
7170 switch (TREE_CODE (expr
))
7173 stmt
= gimple_build_omp_sections (body
, OMP_CLAUSES (expr
));
7176 stmt
= gimple_build_omp_single (body
, OMP_CLAUSES (expr
));
7179 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_REGION
,
7180 OMP_CLAUSES (expr
));
7182 case OMP_TARGET_DATA
:
7183 stmt
= gimple_build_omp_target (body
, GF_OMP_TARGET_KIND_DATA
,
7184 OMP_CLAUSES (expr
));
7187 stmt
= gimple_build_omp_teams (body
, OMP_CLAUSES (expr
));
7193 gimplify_seq_add_stmt (pre_p
, stmt
);
7194 *expr_p
= NULL_TREE
;
7197 /* Gimplify the gross structure of OpenMP target update construct. */
7200 gimplify_omp_target_update (tree
*expr_p
, gimple_seq
*pre_p
)
7202 tree expr
= *expr_p
;
7205 gimplify_scan_omp_clauses (&OMP_TARGET_UPDATE_CLAUSES (expr
), pre_p
,
7207 gimplify_adjust_omp_clauses (&OMP_TARGET_UPDATE_CLAUSES (expr
));
7208 stmt
= gimple_build_omp_target (NULL
, GF_OMP_TARGET_KIND_UPDATE
,
7209 OMP_TARGET_UPDATE_CLAUSES (expr
));
7211 gimplify_seq_add_stmt (pre_p
, stmt
);
7212 *expr_p
= NULL_TREE
;
7215 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
7216 stabilized the lhs of the atomic operation as *ADDR. Return true if
7217 EXPR is this stabilized form. */
7220 goa_lhs_expr_p (tree expr
, tree addr
)
7222 /* Also include casts to other type variants. The C front end is fond
7223 of adding these for e.g. volatile variables. This is like
7224 STRIP_TYPE_NOPS but includes the main variant lookup. */
7225 STRIP_USELESS_TYPE_CONVERSION (expr
);
7227 if (TREE_CODE (expr
) == INDIRECT_REF
)
7229 expr
= TREE_OPERAND (expr
, 0);
7231 && (CONVERT_EXPR_P (expr
)
7232 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
7233 && TREE_CODE (expr
) == TREE_CODE (addr
)
7234 && types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (addr
)))
7236 expr
= TREE_OPERAND (expr
, 0);
7237 addr
= TREE_OPERAND (addr
, 0);
7241 return (TREE_CODE (addr
) == ADDR_EXPR
7242 && TREE_CODE (expr
) == ADDR_EXPR
7243 && TREE_OPERAND (addr
, 0) == TREE_OPERAND (expr
, 0));
7245 if (TREE_CODE (addr
) == ADDR_EXPR
&& expr
== TREE_OPERAND (addr
, 0))
7250 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
7251 expression does not involve the lhs, evaluate it into a temporary.
7252 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
7253 or -1 if an error was encountered. */
7256 goa_stabilize_expr (tree
*expr_p
, gimple_seq
*pre_p
, tree lhs_addr
,
7259 tree expr
= *expr_p
;
7262 if (goa_lhs_expr_p (expr
, lhs_addr
))
7267 if (is_gimple_val (expr
))
7271 switch (TREE_CODE_CLASS (TREE_CODE (expr
)))
7274 case tcc_comparison
:
7275 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
, lhs_addr
,
7278 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
, lhs_addr
,
7281 case tcc_expression
:
7282 switch (TREE_CODE (expr
))
7284 case TRUTH_ANDIF_EXPR
:
7285 case TRUTH_ORIF_EXPR
:
7286 case TRUTH_AND_EXPR
:
7288 case TRUTH_XOR_EXPR
:
7289 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
,
7291 case TRUTH_NOT_EXPR
:
7292 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
7296 /* Break out any preevaluations from cp_build_modify_expr. */
7297 for (; TREE_CODE (expr
) == COMPOUND_EXPR
;
7298 expr
= TREE_OPERAND (expr
, 1))
7299 gimplify_stmt (&TREE_OPERAND (expr
, 0), pre_p
);
7301 return goa_stabilize_expr (expr_p
, pre_p
, lhs_addr
, lhs_var
);
7312 enum gimplify_status gs
;
7313 gs
= gimplify_expr (expr_p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
7314 if (gs
!= GS_ALL_DONE
)
7321 /* Gimplify an OMP_ATOMIC statement. */
7323 static enum gimplify_status
7324 gimplify_omp_atomic (tree
*expr_p
, gimple_seq
*pre_p
)
7326 tree addr
= TREE_OPERAND (*expr_p
, 0);
7327 tree rhs
= TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
7328 ? NULL
: TREE_OPERAND (*expr_p
, 1);
7329 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
7331 gimple loadstmt
, storestmt
;
7333 tmp_load
= create_tmp_reg (type
, NULL
);
7334 if (rhs
&& goa_stabilize_expr (&rhs
, pre_p
, addr
, tmp_load
) < 0)
7337 if (gimplify_expr (&addr
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7341 loadstmt
= gimple_build_omp_atomic_load (tmp_load
, addr
);
7342 gimplify_seq_add_stmt (pre_p
, loadstmt
);
7343 if (rhs
&& gimplify_expr (&rhs
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7347 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
)
7349 storestmt
= gimple_build_omp_atomic_store (rhs
);
7350 gimplify_seq_add_stmt (pre_p
, storestmt
);
7351 if (OMP_ATOMIC_SEQ_CST (*expr_p
))
7353 gimple_omp_atomic_set_seq_cst (loadstmt
);
7354 gimple_omp_atomic_set_seq_cst (storestmt
);
7356 switch (TREE_CODE (*expr_p
))
7358 case OMP_ATOMIC_READ
:
7359 case OMP_ATOMIC_CAPTURE_OLD
:
7361 gimple_omp_atomic_set_need_value (loadstmt
);
7363 case OMP_ATOMIC_CAPTURE_NEW
:
7365 gimple_omp_atomic_set_need_value (storestmt
);
7375 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
7376 body, and adding some EH bits. */
7378 static enum gimplify_status
7379 gimplify_transaction (tree
*expr_p
, gimple_seq
*pre_p
)
7381 tree expr
= *expr_p
, temp
, tbody
= TRANSACTION_EXPR_BODY (expr
);
7383 gimple_seq body
= NULL
;
7384 struct gimplify_ctx gctx
;
7387 /* Wrap the transaction body in a BIND_EXPR so we have a context
7388 where to put decls for OpenMP. */
7389 if (TREE_CODE (tbody
) != BIND_EXPR
)
7391 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, tbody
, NULL
);
7392 TREE_SIDE_EFFECTS (bind
) = 1;
7393 SET_EXPR_LOCATION (bind
, EXPR_LOCATION (tbody
));
7394 TRANSACTION_EXPR_BODY (expr
) = bind
;
7397 push_gimplify_context (&gctx
);
7398 temp
= voidify_wrapper_expr (*expr_p
, NULL
);
7400 g
= gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr
), &body
);
7401 pop_gimplify_context (g
);
7403 g
= gimple_build_transaction (body
, NULL
);
7404 if (TRANSACTION_EXPR_OUTER (expr
))
7405 subcode
= GTMA_IS_OUTER
;
7406 else if (TRANSACTION_EXPR_RELAXED (expr
))
7407 subcode
= GTMA_IS_RELAXED
;
7408 gimple_transaction_set_subcode (g
, subcode
);
7410 gimplify_seq_add_stmt (pre_p
, g
);
7418 *expr_p
= NULL_TREE
;
7422 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
7423 expression produces a value to be used as an operand inside a GIMPLE
7424 statement, the value will be stored back in *EXPR_P. This value will
7425 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
7426 an SSA_NAME. The corresponding sequence of GIMPLE statements is
7427 emitted in PRE_P and POST_P.
7429 Additionally, this process may overwrite parts of the input
7430 expression during gimplification. Ideally, it should be
7431 possible to do non-destructive gimplification.
7433 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
7434 the expression needs to evaluate to a value to be used as
7435 an operand in a GIMPLE statement, this value will be stored in
7436 *EXPR_P on exit. This happens when the caller specifies one
7437 of fb_lvalue or fb_rvalue fallback flags.
7439 PRE_P will contain the sequence of GIMPLE statements corresponding
7440 to the evaluation of EXPR and all the side-effects that must
7441 be executed before the main expression. On exit, the last
7442 statement of PRE_P is the core statement being gimplified. For
7443 instance, when gimplifying 'if (++a)' the last statement in
7444 PRE_P will be 'if (t.1)' where t.1 is the result of
7445 pre-incrementing 'a'.
7447 POST_P will contain the sequence of GIMPLE statements corresponding
7448 to the evaluation of all the side-effects that must be executed
7449 after the main expression. If this is NULL, the post
7450 side-effects are stored at the end of PRE_P.
7452 The reason why the output is split in two is to handle post
7453 side-effects explicitly. In some cases, an expression may have
7454 inner and outer post side-effects which need to be emitted in
7455 an order different from the one given by the recursive
7456 traversal. For instance, for the expression (*p--)++ the post
7457 side-effects of '--' must actually occur *after* the post
7458 side-effects of '++'. However, gimplification will first visit
7459 the inner expression, so if a separate POST sequence was not
7460 used, the resulting sequence would be:
7467 However, the post-decrement operation in line #2 must not be
7468 evaluated until after the store to *p at line #4, so the
7469 correct sequence should be:
7476 So, by specifying a separate post queue, it is possible
7477 to emit the post side-effects in the correct order.
7478 If POST_P is NULL, an internal queue will be used. Before
7479 returning to the caller, the sequence POST_P is appended to
7480 the main output sequence PRE_P.
7482 GIMPLE_TEST_F points to a function that takes a tree T and
7483 returns nonzero if T is in the GIMPLE form requested by the
7484 caller. The GIMPLE predicates are in gimple.c.
7486 FALLBACK tells the function what sort of a temporary we want if
7487 gimplification cannot produce an expression that complies with
7490 fb_none means that no temporary should be generated
7491 fb_rvalue means that an rvalue is OK to generate
7492 fb_lvalue means that an lvalue is OK to generate
7493 fb_either means that either is OK, but an lvalue is preferable.
7494 fb_mayfail means that gimplification may fail (in which case
7495 GS_ERROR will be returned)
7497 The return value is either GS_ERROR or GS_ALL_DONE, since this
7498 function iterates until EXPR is completely gimplified or an error
7501 enum gimplify_status
7502 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
7503 bool (*gimple_test_f
) (tree
), fallback_t fallback
)
7506 gimple_seq internal_pre
= NULL
;
7507 gimple_seq internal_post
= NULL
;
7510 location_t saved_location
;
7511 enum gimplify_status ret
;
7512 gimple_stmt_iterator pre_last_gsi
, post_last_gsi
;
7514 save_expr
= *expr_p
;
7515 if (save_expr
== NULL_TREE
)
7518 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
7519 is_statement
= gimple_test_f
== is_gimple_stmt
;
7523 /* Consistency checks. */
7524 if (gimple_test_f
== is_gimple_reg
)
7525 gcc_assert (fallback
& (fb_rvalue
| fb_lvalue
));
7526 else if (gimple_test_f
== is_gimple_val
7527 || gimple_test_f
== is_gimple_call_addr
7528 || gimple_test_f
== is_gimple_condexpr
7529 || gimple_test_f
== is_gimple_mem_rhs
7530 || gimple_test_f
== is_gimple_mem_rhs_or_call
7531 || gimple_test_f
== is_gimple_reg_rhs
7532 || gimple_test_f
== is_gimple_reg_rhs_or_call
7533 || gimple_test_f
== is_gimple_asm_val
7534 || gimple_test_f
== is_gimple_mem_ref_addr
)
7535 gcc_assert (fallback
& fb_rvalue
);
7536 else if (gimple_test_f
== is_gimple_min_lval
7537 || gimple_test_f
== is_gimple_lvalue
)
7538 gcc_assert (fallback
& fb_lvalue
);
7539 else if (gimple_test_f
== is_gimple_addressable
)
7540 gcc_assert (fallback
& fb_either
);
7541 else if (gimple_test_f
== is_gimple_stmt
)
7542 gcc_assert (fallback
== fb_none
);
7545 /* We should have recognized the GIMPLE_TEST_F predicate to
7546 know what kind of fallback to use in case a temporary is
7547 needed to hold the value or address of *EXPR_P. */
7551 /* We used to check the predicate here and return immediately if it
7552 succeeds. This is wrong; the design is for gimplification to be
7553 idempotent, and for the predicates to only test for valid forms, not
7554 whether they are fully simplified. */
7556 pre_p
= &internal_pre
;
7559 post_p
= &internal_post
;
7561 /* Remember the last statements added to PRE_P and POST_P. Every
7562 new statement added by the gimplification helpers needs to be
7563 annotated with location information. To centralize the
7564 responsibility, we remember the last statement that had been
7565 added to both queues before gimplifying *EXPR_P. If
7566 gimplification produces new statements in PRE_P and POST_P, those
7567 statements will be annotated with the same location information
7569 pre_last_gsi
= gsi_last (*pre_p
);
7570 post_last_gsi
= gsi_last (*post_p
);
7572 saved_location
= input_location
;
7573 if (save_expr
!= error_mark_node
7574 && EXPR_HAS_LOCATION (*expr_p
))
7575 input_location
= EXPR_LOCATION (*expr_p
);
7577 /* Loop over the specific gimplifiers until the toplevel node
7578 remains the same. */
7581 /* Strip away as many useless type conversions as possible
7583 STRIP_USELESS_TYPE_CONVERSION (*expr_p
);
7585 /* Remember the expr. */
7586 save_expr
= *expr_p
;
7588 /* Die, die, die, my darling. */
7589 if (save_expr
== error_mark_node
7590 || (TREE_TYPE (save_expr
)
7591 && TREE_TYPE (save_expr
) == error_mark_node
))
7597 /* Do any language-specific gimplification. */
7598 ret
= ((enum gimplify_status
)
7599 lang_hooks
.gimplify_expr (expr_p
, pre_p
, post_p
));
7602 if (*expr_p
== NULL_TREE
)
7604 if (*expr_p
!= save_expr
)
7607 else if (ret
!= GS_UNHANDLED
)
7610 /* Make sure that all the cases set 'ret' appropriately. */
7612 switch (TREE_CODE (*expr_p
))
7614 /* First deal with the special cases. */
7616 case POSTINCREMENT_EXPR
:
7617 case POSTDECREMENT_EXPR
:
7618 case PREINCREMENT_EXPR
:
7619 case PREDECREMENT_EXPR
:
7620 ret
= gimplify_self_mod_expr (expr_p
, pre_p
, post_p
,
7621 fallback
!= fb_none
,
7622 TREE_TYPE (*expr_p
));
7626 case ARRAY_RANGE_REF
:
7630 case VIEW_CONVERT_EXPR
:
7631 ret
= gimplify_compound_lval (expr_p
, pre_p
, post_p
,
7632 fallback
? fallback
: fb_rvalue
);
7636 ret
= gimplify_cond_expr (expr_p
, pre_p
, fallback
);
7638 /* C99 code may assign to an array in a structure value of a
7639 conditional expression, and this has undefined behavior
7640 only on execution, so create a temporary if an lvalue is
7642 if (fallback
== fb_lvalue
)
7644 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7645 mark_addressable (*expr_p
);
7651 ret
= gimplify_call_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7653 /* C99 code may assign to an array in a structure returned
7654 from a function, and this has undefined behavior only on
7655 execution, so create a temporary if an lvalue is
7657 if (fallback
== fb_lvalue
)
7659 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7660 mark_addressable (*expr_p
);
7669 ret
= gimplify_compound_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7672 case COMPOUND_LITERAL_EXPR
:
7673 ret
= gimplify_compound_literal_expr (expr_p
, pre_p
,
7674 gimple_test_f
, fallback
);
7679 ret
= gimplify_modify_expr (expr_p
, pre_p
, post_p
,
7680 fallback
!= fb_none
);
7683 case TRUTH_ANDIF_EXPR
:
7684 case TRUTH_ORIF_EXPR
:
7686 /* Preserve the original type of the expression and the
7687 source location of the outer expression. */
7688 tree org_type
= TREE_TYPE (*expr_p
);
7689 *expr_p
= gimple_boolify (*expr_p
);
7690 *expr_p
= build3_loc (input_location
, COND_EXPR
,
7694 org_type
, boolean_true_node
),
7697 org_type
, boolean_false_node
));
7702 case TRUTH_NOT_EXPR
:
7704 tree type
= TREE_TYPE (*expr_p
);
7705 /* The parsers are careful to generate TRUTH_NOT_EXPR
7706 only with operands that are always zero or one.
7707 We do not fold here but handle the only interesting case
7708 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
7709 *expr_p
= gimple_boolify (*expr_p
);
7710 if (TYPE_PRECISION (TREE_TYPE (*expr_p
)) == 1)
7711 *expr_p
= build1_loc (input_location
, BIT_NOT_EXPR
,
7712 TREE_TYPE (*expr_p
),
7713 TREE_OPERAND (*expr_p
, 0));
7715 *expr_p
= build2_loc (input_location
, BIT_XOR_EXPR
,
7716 TREE_TYPE (*expr_p
),
7717 TREE_OPERAND (*expr_p
, 0),
7718 build_int_cst (TREE_TYPE (*expr_p
), 1));
7719 if (!useless_type_conversion_p (type
, TREE_TYPE (*expr_p
)))
7720 *expr_p
= fold_convert_loc (input_location
, type
, *expr_p
);
7726 ret
= gimplify_addr_expr (expr_p
, pre_p
, post_p
);
7730 ret
= gimplify_va_arg_expr (expr_p
, pre_p
, post_p
);
7734 if (IS_EMPTY_STMT (*expr_p
))
7740 if (VOID_TYPE_P (TREE_TYPE (*expr_p
))
7741 || fallback
== fb_none
)
7743 /* Just strip a conversion to void (or in void context) and
7745 *expr_p
= TREE_OPERAND (*expr_p
, 0);
7750 ret
= gimplify_conversion (expr_p
);
7751 if (ret
== GS_ERROR
)
7753 if (*expr_p
!= save_expr
)
7757 case FIX_TRUNC_EXPR
:
7758 /* unary_expr: ... | '(' cast ')' val | ... */
7759 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7760 is_gimple_val
, fb_rvalue
);
7761 recalculate_side_effects (*expr_p
);
7766 bool volatilep
= TREE_THIS_VOLATILE (*expr_p
);
7767 bool notrap
= TREE_THIS_NOTRAP (*expr_p
);
7768 tree saved_ptr_type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 0));
7770 *expr_p
= fold_indirect_ref_loc (input_location
, *expr_p
);
7771 if (*expr_p
!= save_expr
)
7777 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7778 is_gimple_reg
, fb_rvalue
);
7779 if (ret
== GS_ERROR
)
7782 recalculate_side_effects (*expr_p
);
7783 *expr_p
= fold_build2_loc (input_location
, MEM_REF
,
7784 TREE_TYPE (*expr_p
),
7785 TREE_OPERAND (*expr_p
, 0),
7786 build_int_cst (saved_ptr_type
, 0));
7787 TREE_THIS_VOLATILE (*expr_p
) = volatilep
;
7788 TREE_THIS_NOTRAP (*expr_p
) = notrap
;
7793 /* We arrive here through the various re-gimplifcation paths. */
7795 /* First try re-folding the whole thing. */
7796 tmp
= fold_binary (MEM_REF
, TREE_TYPE (*expr_p
),
7797 TREE_OPERAND (*expr_p
, 0),
7798 TREE_OPERAND (*expr_p
, 1));
7802 recalculate_side_effects (*expr_p
);
7806 /* Avoid re-gimplifying the address operand if it is already
7807 in suitable form. Re-gimplifying would mark the address
7808 operand addressable. Always gimplify when not in SSA form
7809 as we still may have to gimplify decls with value-exprs. */
7810 if (!gimplify_ctxp
|| !gimplify_ctxp
->into_ssa
7811 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p
, 0)))
7813 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7814 is_gimple_mem_ref_addr
, fb_rvalue
);
7815 if (ret
== GS_ERROR
)
7818 recalculate_side_effects (*expr_p
);
7822 /* Constants need not be gimplified. */
7833 /* If we require an lvalue, such as for ADDR_EXPR, retain the
7834 CONST_DECL node. Otherwise the decl is replaceable by its
7836 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
7837 if (fallback
& fb_lvalue
)
7841 *expr_p
= DECL_INITIAL (*expr_p
);
7847 ret
= gimplify_decl_expr (expr_p
, pre_p
);
7851 ret
= gimplify_bind_expr (expr_p
, pre_p
);
7855 ret
= gimplify_loop_expr (expr_p
, pre_p
);
7859 ret
= gimplify_switch_expr (expr_p
, pre_p
);
7863 ret
= gimplify_exit_expr (expr_p
);
7867 /* If the target is not LABEL, then it is a computed jump
7868 and the target needs to be gimplified. */
7869 if (TREE_CODE (GOTO_DESTINATION (*expr_p
)) != LABEL_DECL
)
7871 ret
= gimplify_expr (&GOTO_DESTINATION (*expr_p
), pre_p
,
7872 NULL
, is_gimple_val
, fb_rvalue
);
7873 if (ret
== GS_ERROR
)
7876 gimplify_seq_add_stmt (pre_p
,
7877 gimple_build_goto (GOTO_DESTINATION (*expr_p
)));
7882 gimplify_seq_add_stmt (pre_p
,
7883 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p
),
7884 PREDICT_EXPR_OUTCOME (*expr_p
)));
7890 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p
))
7891 == current_function_decl
);
7892 gimplify_seq_add_stmt (pre_p
,
7893 gimple_build_label (LABEL_EXPR_LABEL (*expr_p
)));
7896 case CASE_LABEL_EXPR
:
7897 ret
= gimplify_case_label_expr (expr_p
, pre_p
);
7901 ret
= gimplify_return_expr (*expr_p
, pre_p
);
7905 /* Don't reduce this in place; let gimplify_init_constructor work its
7906 magic. Buf if we're just elaborating this for side effects, just
7907 gimplify any element that has side-effects. */
7908 if (fallback
== fb_none
)
7910 unsigned HOST_WIDE_INT ix
;
7912 tree temp
= NULL_TREE
;
7913 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p
), ix
, val
)
7914 if (TREE_SIDE_EFFECTS (val
))
7915 append_to_statement_list (val
, &temp
);
7918 ret
= temp
? GS_OK
: GS_ALL_DONE
;
7920 /* C99 code may assign to an array in a constructed
7921 structure or union, and this has undefined behavior only
7922 on execution, so create a temporary if an lvalue is
7924 else if (fallback
== fb_lvalue
)
7926 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7927 mark_addressable (*expr_p
);
7934 /* The following are special cases that are not handled by the
7935 original GIMPLE grammar. */
7937 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
7940 ret
= gimplify_save_expr (expr_p
, pre_p
, post_p
);
7944 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7945 post_p
, is_gimple_lvalue
, fb_either
);
7946 recalculate_side_effects (*expr_p
);
7949 case TARGET_MEM_REF
:
7951 enum gimplify_status r0
= GS_ALL_DONE
, r1
= GS_ALL_DONE
;
7953 if (TMR_BASE (*expr_p
))
7954 r0
= gimplify_expr (&TMR_BASE (*expr_p
), pre_p
,
7955 post_p
, is_gimple_mem_ref_addr
, fb_either
);
7956 if (TMR_INDEX (*expr_p
))
7957 r1
= gimplify_expr (&TMR_INDEX (*expr_p
), pre_p
,
7958 post_p
, is_gimple_val
, fb_rvalue
);
7959 if (TMR_INDEX2 (*expr_p
))
7960 r1
= gimplify_expr (&TMR_INDEX2 (*expr_p
), pre_p
,
7961 post_p
, is_gimple_val
, fb_rvalue
);
7962 /* TMR_STEP and TMR_OFFSET are always integer constants. */
7967 case NON_LVALUE_EXPR
:
7968 /* This should have been stripped above. */
7972 ret
= gimplify_asm_expr (expr_p
, pre_p
, post_p
);
7975 case TRY_FINALLY_EXPR
:
7976 case TRY_CATCH_EXPR
:
7978 gimple_seq eval
, cleanup
;
7981 /* Calls to destructors are generated automatically in FINALLY/CATCH
7982 block. They should have location as UNKNOWN_LOCATION. However,
7983 gimplify_call_expr will reset these call stmts to input_location
7984 if it finds stmt's location is unknown. To prevent resetting for
7985 destructors, we set the input_location to unknown.
7986 Note that this only affects the destructor calls in FINALLY/CATCH
7987 block, and will automatically reset to its original value by the
7988 end of gimplify_expr. */
7989 input_location
= UNKNOWN_LOCATION
;
7990 eval
= cleanup
= NULL
;
7991 gimplify_and_add (TREE_OPERAND (*expr_p
, 0), &eval
);
7992 gimplify_and_add (TREE_OPERAND (*expr_p
, 1), &cleanup
);
7993 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
7994 if (gimple_seq_empty_p (cleanup
))
7996 gimple_seq_add_seq (pre_p
, eval
);
8000 try_
= gimple_build_try (eval
, cleanup
,
8001 TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
8002 ? GIMPLE_TRY_FINALLY
8003 : GIMPLE_TRY_CATCH
);
8004 if (LOCATION_LOCUS (saved_location
) != UNKNOWN_LOCATION
)
8005 gimple_set_location (try_
, saved_location
);
8007 gimple_set_location (try_
, EXPR_LOCATION (save_expr
));
8008 if (TREE_CODE (*expr_p
) == TRY_CATCH_EXPR
)
8009 gimple_try_set_catch_is_cleanup (try_
,
8010 TRY_CATCH_IS_CLEANUP (*expr_p
));
8011 gimplify_seq_add_stmt (pre_p
, try_
);
8016 case CLEANUP_POINT_EXPR
:
8017 ret
= gimplify_cleanup_point_expr (expr_p
, pre_p
);
8021 ret
= gimplify_target_expr (expr_p
, pre_p
, post_p
);
8027 gimple_seq handler
= NULL
;
8028 gimplify_and_add (CATCH_BODY (*expr_p
), &handler
);
8029 c
= gimple_build_catch (CATCH_TYPES (*expr_p
), handler
);
8030 gimplify_seq_add_stmt (pre_p
, c
);
8035 case EH_FILTER_EXPR
:
8038 gimple_seq failure
= NULL
;
8040 gimplify_and_add (EH_FILTER_FAILURE (*expr_p
), &failure
);
8041 ehf
= gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p
), failure
);
8042 gimple_set_no_warning (ehf
, TREE_NO_WARNING (*expr_p
));
8043 gimplify_seq_add_stmt (pre_p
, ehf
);
8050 enum gimplify_status r0
, r1
;
8051 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
,
8052 post_p
, is_gimple_val
, fb_rvalue
);
8053 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
,
8054 post_p
, is_gimple_val
, fb_rvalue
);
8055 TREE_SIDE_EFFECTS (*expr_p
) = 0;
8061 /* We get here when taking the address of a label. We mark
8062 the label as "forced"; meaning it can never be removed and
8063 it is a potential target for any computed goto. */
8064 FORCED_LABEL (*expr_p
) = 1;
8068 case STATEMENT_LIST
:
8069 ret
= gimplify_statement_list (expr_p
, pre_p
);
8072 case WITH_SIZE_EXPR
:
8074 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8075 post_p
== &internal_post
? NULL
: post_p
,
8076 gimple_test_f
, fallback
);
8077 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
8078 is_gimple_val
, fb_rvalue
);
8085 ret
= gimplify_var_or_parm_decl (expr_p
);
8089 /* When within an OpenMP context, notice uses of variables. */
8090 if (gimplify_omp_ctxp
)
8091 omp_notice_variable (gimplify_omp_ctxp
, *expr_p
, true);
8096 /* Allow callbacks into the gimplifier during optimization. */
8101 gimplify_omp_parallel (expr_p
, pre_p
);
8106 gimplify_omp_task (expr_p
, pre_p
);
8112 case OMP_DISTRIBUTE
:
8113 ret
= gimplify_omp_for (expr_p
, pre_p
);
8119 case OMP_TARGET_DATA
:
8121 gimplify_omp_workshare (expr_p
, pre_p
);
8125 case OMP_TARGET_UPDATE
:
8126 gimplify_omp_target_update (expr_p
, pre_p
);
8136 gimple_seq body
= NULL
;
8139 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
8140 switch (TREE_CODE (*expr_p
))
8143 g
= gimple_build_omp_section (body
);
8146 g
= gimple_build_omp_master (body
);
8150 gimple_seq cleanup
= NULL
;
8152 = builtin_decl_explicit (BUILT_IN_GOMP_TASKGROUP_END
);
8153 g
= gimple_build_call (fn
, 0);
8154 gimple_seq_add_stmt (&cleanup
, g
);
8155 g
= gimple_build_try (body
, cleanup
, GIMPLE_TRY_FINALLY
);
8157 gimple_seq_add_stmt (&body
, g
);
8158 g
= gimple_build_omp_taskgroup (body
);
8162 g
= gimple_build_omp_ordered (body
);
8165 g
= gimple_build_omp_critical (body
,
8166 OMP_CRITICAL_NAME (*expr_p
));
8171 gimplify_seq_add_stmt (pre_p
, g
);
8177 case OMP_ATOMIC_READ
:
8178 case OMP_ATOMIC_CAPTURE_OLD
:
8179 case OMP_ATOMIC_CAPTURE_NEW
:
8180 ret
= gimplify_omp_atomic (expr_p
, pre_p
);
8183 case TRANSACTION_EXPR
:
8184 ret
= gimplify_transaction (expr_p
, pre_p
);
8187 case TRUTH_AND_EXPR
:
8189 case TRUTH_XOR_EXPR
:
8191 tree orig_type
= TREE_TYPE (*expr_p
);
8192 tree new_type
, xop0
, xop1
;
8193 *expr_p
= gimple_boolify (*expr_p
);
8194 new_type
= TREE_TYPE (*expr_p
);
8195 if (!useless_type_conversion_p (orig_type
, new_type
))
8197 *expr_p
= fold_convert_loc (input_location
, orig_type
, *expr_p
);
8202 /* Boolified binary truth expressions are semantically equivalent
8203 to bitwise binary expressions. Canonicalize them to the
8205 switch (TREE_CODE (*expr_p
))
8207 case TRUTH_AND_EXPR
:
8208 TREE_SET_CODE (*expr_p
, BIT_AND_EXPR
);
8211 TREE_SET_CODE (*expr_p
, BIT_IOR_EXPR
);
8213 case TRUTH_XOR_EXPR
:
8214 TREE_SET_CODE (*expr_p
, BIT_XOR_EXPR
);
8219 /* Now make sure that operands have compatible type to
8220 expression's new_type. */
8221 xop0
= TREE_OPERAND (*expr_p
, 0);
8222 xop1
= TREE_OPERAND (*expr_p
, 1);
8223 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop0
)))
8224 TREE_OPERAND (*expr_p
, 0) = fold_convert_loc (input_location
,
8227 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop1
)))
8228 TREE_OPERAND (*expr_p
, 1) = fold_convert_loc (input_location
,
8231 /* Continue classified as tcc_binary. */
8238 /* Classified as tcc_expression. */
8241 case POINTER_PLUS_EXPR
:
8243 enum gimplify_status r0
, r1
;
8244 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8245 post_p
, is_gimple_val
, fb_rvalue
);
8246 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
8247 post_p
, is_gimple_val
, fb_rvalue
);
8248 recalculate_side_effects (*expr_p
);
8250 /* Convert &X + CST to invariant &MEM[&X, CST]. Do this
8251 after gimplifying operands - this is similar to how
8252 it would be folding all gimplified stmts on creation
8253 to have them canonicalized, which is what we eventually
8254 should do anyway. */
8255 if (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == INTEGER_CST
8256 && is_gimple_min_invariant (TREE_OPERAND (*expr_p
, 0)))
8258 *expr_p
= build_fold_addr_expr_with_type_loc
8260 fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (*expr_p
)),
8261 TREE_OPERAND (*expr_p
, 0),
8262 fold_convert (ptr_type_node
,
8263 TREE_OPERAND (*expr_p
, 1))),
8264 TREE_TYPE (*expr_p
));
8265 ret
= MIN (ret
, GS_OK
);
8271 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p
)))
8273 case tcc_comparison
:
8274 /* Handle comparison of objects of non scalar mode aggregates
8275 with a call to memcmp. It would be nice to only have to do
8276 this for variable-sized objects, but then we'd have to allow
8277 the same nest of reference nodes we allow for MODIFY_EXPR and
8280 Compare scalar mode aggregates as scalar mode values. Using
8281 memcmp for them would be very inefficient at best, and is
8282 plain wrong if bitfields are involved. */
8284 tree type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 1));
8286 /* Vector comparisons need no boolification. */
8287 if (TREE_CODE (type
) == VECTOR_TYPE
)
8289 else if (!AGGREGATE_TYPE_P (type
))
8291 tree org_type
= TREE_TYPE (*expr_p
);
8292 *expr_p
= gimple_boolify (*expr_p
);
8293 if (!useless_type_conversion_p (org_type
,
8294 TREE_TYPE (*expr_p
)))
8296 *expr_p
= fold_convert_loc (input_location
,
8303 else if (TYPE_MODE (type
) != BLKmode
)
8304 ret
= gimplify_scalar_mode_aggregate_compare (expr_p
);
8306 ret
= gimplify_variable_sized_compare (expr_p
);
8311 /* If *EXPR_P does not need to be special-cased, handle it
8312 according to its class. */
8314 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8315 post_p
, is_gimple_val
, fb_rvalue
);
8321 enum gimplify_status r0
, r1
;
8323 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8324 post_p
, is_gimple_val
, fb_rvalue
);
8325 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
8326 post_p
, is_gimple_val
, fb_rvalue
);
8334 enum gimplify_status r0
, r1
, r2
;
8336 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
8337 post_p
, is_gimple_val
, fb_rvalue
);
8338 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
8339 post_p
, is_gimple_val
, fb_rvalue
);
8340 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
8341 post_p
, is_gimple_val
, fb_rvalue
);
8343 ret
= MIN (MIN (r0
, r1
), r2
);
8347 case tcc_declaration
:
8350 goto dont_recalculate
;
8356 recalculate_side_effects (*expr_p
);
8362 gcc_assert (*expr_p
|| ret
!= GS_OK
);
8364 while (ret
== GS_OK
);
8366 /* If we encountered an error_mark somewhere nested inside, either
8367 stub out the statement or propagate the error back out. */
8368 if (ret
== GS_ERROR
)
8375 /* This was only valid as a return value from the langhook, which
8376 we handled. Make sure it doesn't escape from any other context. */
8377 gcc_assert (ret
!= GS_UNHANDLED
);
8379 if (fallback
== fb_none
&& *expr_p
&& !is_gimple_stmt (*expr_p
))
8381 /* We aren't looking for a value, and we don't have a valid
8382 statement. If it doesn't have side-effects, throw it away. */
8383 if (!TREE_SIDE_EFFECTS (*expr_p
))
8385 else if (!TREE_THIS_VOLATILE (*expr_p
))
8387 /* This is probably a _REF that contains something nested that
8388 has side effects. Recurse through the operands to find it. */
8389 enum tree_code code
= TREE_CODE (*expr_p
);
8396 case VIEW_CONVERT_EXPR
:
8397 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8398 gimple_test_f
, fallback
);
8402 case ARRAY_RANGE_REF
:
8403 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8404 gimple_test_f
, fallback
);
8405 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
8406 gimple_test_f
, fallback
);
8410 /* Anything else with side-effects must be converted to
8411 a valid statement before we get here. */
8417 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p
))
8418 && TYPE_MODE (TREE_TYPE (*expr_p
)) != BLKmode
)
8420 /* Historically, the compiler has treated a bare reference
8421 to a non-BLKmode volatile lvalue as forcing a load. */
8422 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p
));
8424 /* Normally, we do not want to create a temporary for a
8425 TREE_ADDRESSABLE type because such a type should not be
8426 copied by bitwise-assignment. However, we make an
8427 exception here, as all we are doing here is ensuring that
8428 we read the bytes that make up the type. We use
8429 create_tmp_var_raw because create_tmp_var will abort when
8430 given a TREE_ADDRESSABLE type. */
8431 tree tmp
= create_tmp_var_raw (type
, "vol");
8432 gimple_add_tmp_var (tmp
);
8433 gimplify_assign (tmp
, *expr_p
, pre_p
);
8437 /* We can't do anything useful with a volatile reference to
8438 an incomplete type, so just throw it away. Likewise for
8439 a BLKmode type, since any implicit inner load should
8440 already have been turned into an explicit one by the
8441 gimplification process. */
8445 /* If we are gimplifying at the statement level, we're done. Tack
8446 everything together and return. */
8447 if (fallback
== fb_none
|| is_statement
)
8449 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
8450 it out for GC to reclaim it. */
8451 *expr_p
= NULL_TREE
;
8453 if (!gimple_seq_empty_p (internal_pre
)
8454 || !gimple_seq_empty_p (internal_post
))
8456 gimplify_seq_add_seq (&internal_pre
, internal_post
);
8457 gimplify_seq_add_seq (pre_p
, internal_pre
);
8460 /* The result of gimplifying *EXPR_P is going to be the last few
8461 statements in *PRE_P and *POST_P. Add location information
8462 to all the statements that were added by the gimplification
8464 if (!gimple_seq_empty_p (*pre_p
))
8465 annotate_all_with_location_after (*pre_p
, pre_last_gsi
, input_location
);
8467 if (!gimple_seq_empty_p (*post_p
))
8468 annotate_all_with_location_after (*post_p
, post_last_gsi
,
8474 #ifdef ENABLE_GIMPLE_CHECKING
8477 enum tree_code code
= TREE_CODE (*expr_p
);
8478 /* These expressions should already be in gimple IR form. */
8479 gcc_assert (code
!= MODIFY_EXPR
8481 && code
!= BIND_EXPR
8482 && code
!= CATCH_EXPR
8483 && (code
!= COND_EXPR
|| gimplify_ctxp
->allow_rhs_cond_expr
)
8484 && code
!= EH_FILTER_EXPR
8485 && code
!= GOTO_EXPR
8486 && code
!= LABEL_EXPR
8487 && code
!= LOOP_EXPR
8488 && code
!= SWITCH_EXPR
8489 && code
!= TRY_FINALLY_EXPR
8490 && code
!= OMP_CRITICAL
8492 && code
!= OMP_MASTER
8493 && code
!= OMP_TASKGROUP
8494 && code
!= OMP_ORDERED
8495 && code
!= OMP_PARALLEL
8496 && code
!= OMP_SECTIONS
8497 && code
!= OMP_SECTION
8498 && code
!= OMP_SINGLE
);
8502 /* Otherwise we're gimplifying a subexpression, so the resulting
8503 value is interesting. If it's a valid operand that matches
8504 GIMPLE_TEST_F, we're done. Unless we are handling some
8505 post-effects internally; if that's the case, we need to copy into
8506 a temporary before adding the post-effects to POST_P. */
8507 if (gimple_seq_empty_p (internal_post
) && (*gimple_test_f
) (*expr_p
))
8510 /* Otherwise, we need to create a new temporary for the gimplified
8513 /* We can't return an lvalue if we have an internal postqueue. The
8514 object the lvalue refers to would (probably) be modified by the
8515 postqueue; we need to copy the value out first, which means an
8517 if ((fallback
& fb_lvalue
)
8518 && gimple_seq_empty_p (internal_post
)
8519 && is_gimple_addressable (*expr_p
))
8521 /* An lvalue will do. Take the address of the expression, store it
8522 in a temporary, and replace the expression with an INDIRECT_REF of
8524 tmp
= build_fold_addr_expr_loc (input_location
, *expr_p
);
8525 gimplify_expr (&tmp
, pre_p
, post_p
, is_gimple_reg
, fb_rvalue
);
8526 *expr_p
= build_simple_mem_ref (tmp
);
8528 else if ((fallback
& fb_rvalue
) && is_gimple_reg_rhs_or_call (*expr_p
))
8530 /* An rvalue will do. Assign the gimplified expression into a
8531 new temporary TMP and replace the original expression with
8532 TMP. First, make sure that the expression has a type so that
8533 it can be assigned into a temporary. */
8534 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p
)));
8535 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
8539 #ifdef ENABLE_GIMPLE_CHECKING
8540 if (!(fallback
& fb_mayfail
))
8542 fprintf (stderr
, "gimplification failed:\n");
8543 print_generic_expr (stderr
, *expr_p
, 0);
8544 debug_tree (*expr_p
);
8545 internal_error ("gimplification failed");
8548 gcc_assert (fallback
& fb_mayfail
);
8550 /* If this is an asm statement, and the user asked for the
8551 impossible, don't die. Fail and let gimplify_asm_expr
8557 /* Make sure the temporary matches our predicate. */
8558 gcc_assert ((*gimple_test_f
) (*expr_p
));
8560 if (!gimple_seq_empty_p (internal_post
))
8562 annotate_all_with_location (internal_post
, input_location
);
8563 gimplify_seq_add_seq (pre_p
, internal_post
);
8567 input_location
= saved_location
;
8571 /* Look through TYPE for variable-sized objects and gimplify each such
8572 size that we find. Add to LIST_P any statements generated. */
8575 gimplify_type_sizes (tree type
, gimple_seq
*list_p
)
8579 if (type
== NULL
|| type
== error_mark_node
)
8582 /* We first do the main variant, then copy into any other variants. */
8583 type
= TYPE_MAIN_VARIANT (type
);
8585 /* Avoid infinite recursion. */
8586 if (TYPE_SIZES_GIMPLIFIED (type
))
8589 TYPE_SIZES_GIMPLIFIED (type
) = 1;
8591 switch (TREE_CODE (type
))
8597 case FIXED_POINT_TYPE
:
8598 gimplify_one_sizepos (&TYPE_MIN_VALUE (type
), list_p
);
8599 gimplify_one_sizepos (&TYPE_MAX_VALUE (type
), list_p
);
8601 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8603 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (type
);
8604 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (type
);
8609 /* These types may not have declarations, so handle them here. */
8610 gimplify_type_sizes (TREE_TYPE (type
), list_p
);
8611 gimplify_type_sizes (TYPE_DOMAIN (type
), list_p
);
8612 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
8613 with assigned stack slots, for -O1+ -g they should be tracked
8615 if (!(TYPE_NAME (type
)
8616 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
8617 && DECL_IGNORED_P (TYPE_NAME (type
)))
8618 && TYPE_DOMAIN (type
)
8619 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type
)))
8621 t
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
8622 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8623 DECL_IGNORED_P (t
) = 0;
8624 t
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
8625 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8626 DECL_IGNORED_P (t
) = 0;
8632 case QUAL_UNION_TYPE
:
8633 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
8634 if (TREE_CODE (field
) == FIELD_DECL
)
8636 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field
), list_p
);
8637 gimplify_one_sizepos (&DECL_SIZE (field
), list_p
);
8638 gimplify_one_sizepos (&DECL_SIZE_UNIT (field
), list_p
);
8639 gimplify_type_sizes (TREE_TYPE (field
), list_p
);
8644 case REFERENCE_TYPE
:
8645 /* We used to recurse on the pointed-to type here, which turned out to
8646 be incorrect because its definition might refer to variables not
8647 yet initialized at this point if a forward declaration is involved.
8649 It was actually useful for anonymous pointed-to types to ensure
8650 that the sizes evaluation dominates every possible later use of the
8651 values. Restricting to such types here would be safe since there
8652 is no possible forward declaration around, but would introduce an
8653 undesirable middle-end semantic to anonymity. We then defer to
8654 front-ends the responsibility of ensuring that the sizes are
8655 evaluated both early and late enough, e.g. by attaching artificial
8656 type declarations to the tree. */
8663 gimplify_one_sizepos (&TYPE_SIZE (type
), list_p
);
8664 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type
), list_p
);
8666 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8668 TYPE_SIZE (t
) = TYPE_SIZE (type
);
8669 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (type
);
8670 TYPE_SIZES_GIMPLIFIED (t
) = 1;
8674 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
8675 a size or position, has had all of its SAVE_EXPRs evaluated.
8676 We add any required statements to *STMT_P. */
8679 gimplify_one_sizepos (tree
*expr_p
, gimple_seq
*stmt_p
)
8681 tree expr
= *expr_p
;
8683 /* We don't do anything if the value isn't there, is constant, or contains
8684 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
8685 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
8686 will want to replace it with a new variable, but that will cause problems
8687 if this type is from outside the function. It's OK to have that here. */
8688 if (is_gimple_sizepos (expr
))
8691 *expr_p
= unshare_expr (expr
);
8693 gimplify_expr (expr_p
, stmt_p
, NULL
, is_gimple_val
, fb_rvalue
);
8696 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
8697 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
8698 is true, also gimplify the parameters. */
8701 gimplify_body (tree fndecl
, bool do_parms
)
8703 location_t saved_location
= input_location
;
8704 gimple_seq parm_stmts
, seq
;
8706 struct gimplify_ctx gctx
;
8707 struct cgraph_node
*cgn
;
8709 timevar_push (TV_TREE_GIMPLIFY
);
8711 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
8713 default_rtl_profile ();
8715 gcc_assert (gimplify_ctxp
== NULL
);
8716 push_gimplify_context (&gctx
);
8720 gcc_assert (gimplify_omp_ctxp
== NULL
);
8721 if (lookup_attribute ("omp declare target", DECL_ATTRIBUTES (fndecl
)))
8722 gimplify_omp_ctxp
= new_omp_context (ORT_TARGET
);
8725 /* Unshare most shared trees in the body and in that of any nested functions.
8726 It would seem we don't have to do this for nested functions because
8727 they are supposed to be output and then the outer function gimplified
8728 first, but the g++ front end doesn't always do it that way. */
8729 unshare_body (fndecl
);
8730 unvisit_body (fndecl
);
8732 cgn
= cgraph_get_node (fndecl
);
8733 if (cgn
&& cgn
->origin
)
8734 nonlocal_vlas
= pointer_set_create ();
8736 /* Make sure input_location isn't set to something weird. */
8737 input_location
= DECL_SOURCE_LOCATION (fndecl
);
8739 /* Resolve callee-copies. This has to be done before processing
8740 the body so that DECL_VALUE_EXPR gets processed correctly. */
8741 parm_stmts
= do_parms
? gimplify_parameters () : NULL
;
8743 /* Gimplify the function's body. */
8745 gimplify_stmt (&DECL_SAVED_TREE (fndecl
), &seq
);
8746 outer_bind
= gimple_seq_first_stmt (seq
);
8749 outer_bind
= gimple_build_nop ();
8750 gimplify_seq_add_stmt (&seq
, outer_bind
);
8753 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
8754 not the case, wrap everything in a GIMPLE_BIND to make it so. */
8755 if (gimple_code (outer_bind
) == GIMPLE_BIND
8756 && gimple_seq_first (seq
) == gimple_seq_last (seq
))
8759 outer_bind
= gimple_build_bind (NULL_TREE
, seq
, NULL
);
8761 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
8763 /* If we had callee-copies statements, insert them at the beginning
8764 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
8765 if (!gimple_seq_empty_p (parm_stmts
))
8769 gimplify_seq_add_seq (&parm_stmts
, gimple_bind_body (outer_bind
));
8770 gimple_bind_set_body (outer_bind
, parm_stmts
);
8772 for (parm
= DECL_ARGUMENTS (current_function_decl
);
8773 parm
; parm
= DECL_CHAIN (parm
))
8774 if (DECL_HAS_VALUE_EXPR_P (parm
))
8776 DECL_HAS_VALUE_EXPR_P (parm
) = 0;
8777 DECL_IGNORED_P (parm
) = 0;
8783 pointer_set_destroy (nonlocal_vlas
);
8784 nonlocal_vlas
= NULL
;
8787 if (flag_openmp
&& gimplify_omp_ctxp
)
8789 delete_omp_context (gimplify_omp_ctxp
);
8790 gimplify_omp_ctxp
= NULL
;
8793 pop_gimplify_context (outer_bind
);
8794 gcc_assert (gimplify_ctxp
== NULL
);
8796 #ifdef ENABLE_CHECKING
8798 verify_gimple_in_seq (gimple_bind_body (outer_bind
));
8801 timevar_pop (TV_TREE_GIMPLIFY
);
8802 input_location
= saved_location
;
8807 typedef char *char_p
; /* For DEF_VEC_P. */
8809 /* Return whether we should exclude FNDECL from instrumentation. */
8812 flag_instrument_functions_exclude_p (tree fndecl
)
8816 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_functions
;
8817 if (v
&& v
->length () > 0)
8823 name
= lang_hooks
.decl_printable_name (fndecl
, 0);
8824 FOR_EACH_VEC_ELT (*v
, i
, s
)
8825 if (strstr (name
, s
) != NULL
)
8829 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_files
;
8830 if (v
&& v
->length () > 0)
8836 name
= DECL_SOURCE_FILE (fndecl
);
8837 FOR_EACH_VEC_ELT (*v
, i
, s
)
8838 if (strstr (name
, s
) != NULL
)
8845 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
8846 node for the function we want to gimplify.
8848 Return the sequence of GIMPLE statements corresponding to the body
8852 gimplify_function_tree (tree fndecl
)
8858 gcc_assert (!gimple_body (fndecl
));
8860 if (DECL_STRUCT_FUNCTION (fndecl
))
8861 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
8863 push_struct_function (fndecl
);
8865 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
8867 /* Preliminarily mark non-addressed complex variables as eligible
8868 for promotion to gimple registers. We'll transform their uses
8870 if ((TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
8871 || TREE_CODE (TREE_TYPE (parm
)) == VECTOR_TYPE
)
8872 && !TREE_THIS_VOLATILE (parm
)
8873 && !needs_to_live_in_memory (parm
))
8874 DECL_GIMPLE_REG_P (parm
) = 1;
8877 ret
= DECL_RESULT (fndecl
);
8878 if ((TREE_CODE (TREE_TYPE (ret
)) == COMPLEX_TYPE
8879 || TREE_CODE (TREE_TYPE (ret
)) == VECTOR_TYPE
)
8880 && !needs_to_live_in_memory (ret
))
8881 DECL_GIMPLE_REG_P (ret
) = 1;
8883 bind
= gimplify_body (fndecl
, true);
8885 /* The tree body of the function is no longer needed, replace it
8886 with the new GIMPLE body. */
8888 gimple_seq_add_stmt (&seq
, bind
);
8889 gimple_set_body (fndecl
, seq
);
8891 /* If we're instrumenting function entry/exit, then prepend the call to
8892 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
8893 catch the exit hook. */
8894 /* ??? Add some way to ignore exceptions for this TFE. */
8895 if (flag_instrument_function_entry_exit
8896 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
)
8897 && !flag_instrument_functions_exclude_p (fndecl
))
8902 gimple_seq cleanup
= NULL
, body
= NULL
;
8906 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
8907 call
= gimple_build_call (x
, 1, integer_zero_node
);
8908 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
8909 gimple_call_set_lhs (call
, tmp_var
);
8910 gimplify_seq_add_stmt (&cleanup
, call
);
8911 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT
);
8912 call
= gimple_build_call (x
, 2,
8913 build_fold_addr_expr (current_function_decl
),
8915 gimplify_seq_add_stmt (&cleanup
, call
);
8916 tf
= gimple_build_try (seq
, cleanup
, GIMPLE_TRY_FINALLY
);
8918 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
8919 call
= gimple_build_call (x
, 1, integer_zero_node
);
8920 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
8921 gimple_call_set_lhs (call
, tmp_var
);
8922 gimplify_seq_add_stmt (&body
, call
);
8923 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER
);
8924 call
= gimple_build_call (x
, 2,
8925 build_fold_addr_expr (current_function_decl
),
8927 gimplify_seq_add_stmt (&body
, call
);
8928 gimplify_seq_add_stmt (&body
, tf
);
8929 new_bind
= gimple_build_bind (NULL
, body
, gimple_bind_block (bind
));
8930 /* Clear the block for BIND, since it is no longer directly inside
8931 the function, but within a try block. */
8932 gimple_bind_set_block (bind
, NULL
);
8934 /* Replace the current function body with the body
8935 wrapped in the try/finally TF. */
8937 gimple_seq_add_stmt (&seq
, new_bind
);
8938 gimple_set_body (fndecl
, seq
);
8941 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
8942 cfun
->curr_properties
= PROP_gimple_any
;
8947 /* Some transformations like inlining may invalidate the GIMPLE form
8948 for operands. This function traverses all the operands in STMT and
8949 gimplifies anything that is not a valid gimple operand. Any new
8950 GIMPLE statements are inserted before *GSI_P. */
8953 gimple_regimplify_operands (gimple stmt
, gimple_stmt_iterator
*gsi_p
)
8957 gimple_seq pre
= NULL
;
8958 gimple post_stmt
= NULL
;
8959 struct gimplify_ctx gctx
;
8961 push_gimplify_context (&gctx
);
8962 gimplify_ctxp
->into_ssa
= gimple_in_ssa_p (cfun
);
8964 switch (gimple_code (stmt
))
8967 gimplify_expr (gimple_cond_lhs_ptr (stmt
), &pre
, NULL
,
8968 is_gimple_val
, fb_rvalue
);
8969 gimplify_expr (gimple_cond_rhs_ptr (stmt
), &pre
, NULL
,
8970 is_gimple_val
, fb_rvalue
);
8973 gimplify_expr (gimple_switch_index_ptr (stmt
), &pre
, NULL
,
8974 is_gimple_val
, fb_rvalue
);
8976 case GIMPLE_OMP_ATOMIC_LOAD
:
8977 gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt
), &pre
, NULL
,
8978 is_gimple_val
, fb_rvalue
);
8982 size_t i
, noutputs
= gimple_asm_noutputs (stmt
);
8983 const char *constraint
, **oconstraints
;
8984 bool allows_mem
, allows_reg
, is_inout
;
8987 = (const char **) alloca ((noutputs
) * sizeof (const char *));
8988 for (i
= 0; i
< noutputs
; i
++)
8990 tree op
= gimple_asm_output_op (stmt
, i
);
8991 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op
)));
8992 oconstraints
[i
] = constraint
;
8993 parse_output_constraint (&constraint
, i
, 0, 0, &allows_mem
,
8994 &allows_reg
, &is_inout
);
8995 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8996 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
8997 fb_lvalue
| fb_mayfail
);
8999 for (i
= 0; i
< gimple_asm_ninputs (stmt
); i
++)
9001 tree op
= gimple_asm_input_op (stmt
, i
);
9002 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op
)));
9003 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
9004 oconstraints
, &allows_mem
, &allows_reg
);
9005 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op
))) && allows_mem
)
9007 if (!allows_reg
&& allows_mem
)
9008 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
9009 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
9011 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
9012 is_gimple_asm_val
, fb_rvalue
);
9017 /* NOTE: We start gimplifying operands from last to first to
9018 make sure that side-effects on the RHS of calls, assignments
9019 and ASMs are executed before the LHS. The ordering is not
9020 important for other statements. */
9021 num_ops
= gimple_num_ops (stmt
);
9022 for (i
= num_ops
; i
> 0; i
--)
9024 tree op
= gimple_op (stmt
, i
- 1);
9025 if (op
== NULL_TREE
)
9027 if (i
== 1 && (is_gimple_call (stmt
) || is_gimple_assign (stmt
)))
9028 gimplify_expr (&op
, &pre
, NULL
, is_gimple_lvalue
, fb_lvalue
);
9030 && is_gimple_assign (stmt
)
9032 && get_gimple_rhs_class (gimple_expr_code (stmt
))
9033 == GIMPLE_SINGLE_RHS
)
9034 gimplify_expr (&op
, &pre
, NULL
,
9035 rhs_predicate_for (gimple_assign_lhs (stmt
)),
9037 else if (i
== 2 && is_gimple_call (stmt
))
9039 if (TREE_CODE (op
) == FUNCTION_DECL
)
9041 gimplify_expr (&op
, &pre
, NULL
, is_gimple_call_addr
, fb_rvalue
);
9044 gimplify_expr (&op
, &pre
, NULL
, is_gimple_val
, fb_rvalue
);
9045 gimple_set_op (stmt
, i
- 1, op
);
9048 lhs
= gimple_get_lhs (stmt
);
9049 /* If the LHS changed it in a way that requires a simple RHS,
9050 create temporary. */
9051 if (lhs
&& !is_gimple_reg (lhs
))
9053 bool need_temp
= false;
9055 if (is_gimple_assign (stmt
)
9057 && get_gimple_rhs_class (gimple_expr_code (stmt
))
9058 == GIMPLE_SINGLE_RHS
)
9059 gimplify_expr (gimple_assign_rhs1_ptr (stmt
), &pre
, NULL
,
9060 rhs_predicate_for (gimple_assign_lhs (stmt
)),
9062 else if (is_gimple_reg (lhs
))
9064 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
9066 if (is_gimple_call (stmt
))
9068 i
= gimple_call_flags (stmt
);
9069 if ((i
& ECF_LOOPING_CONST_OR_PURE
)
9070 || !(i
& (ECF_CONST
| ECF_PURE
)))
9073 if (stmt_can_throw_internal (stmt
))
9079 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
9081 else if (TYPE_MODE (TREE_TYPE (lhs
)) != BLKmode
)
9083 if (is_gimple_call (stmt
))
9085 tree fndecl
= gimple_call_fndecl (stmt
);
9087 if (!aggregate_value_p (TREE_TYPE (lhs
), fndecl
)
9088 && !(fndecl
&& DECL_RESULT (fndecl
)
9089 && DECL_BY_REFERENCE (DECL_RESULT (fndecl
))))
9098 tree temp
= create_tmp_reg (TREE_TYPE (lhs
), NULL
);
9099 if (gimple_in_ssa_p (cfun
))
9100 temp
= make_ssa_name (temp
, NULL
);
9101 gimple_set_lhs (stmt
, temp
);
9102 post_stmt
= gimple_build_assign (lhs
, temp
);
9103 if (TREE_CODE (lhs
) == SSA_NAME
)
9104 SSA_NAME_DEF_STMT (lhs
) = post_stmt
;
9110 if (!gimple_seq_empty_p (pre
))
9111 gsi_insert_seq_before (gsi_p
, pre
, GSI_SAME_STMT
);
9113 gsi_insert_after (gsi_p
, post_stmt
, GSI_NEW_STMT
);
9115 pop_gimplify_context (NULL
);
9118 /* Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
9119 the predicate that will hold for the result. If VAR is not NULL, make the
9120 base variable of the final destination be VAR if suitable. */
9123 force_gimple_operand_1 (tree expr
, gimple_seq
*stmts
,
9124 gimple_predicate gimple_test_f
, tree var
)
9126 enum gimplify_status ret
;
9127 struct gimplify_ctx gctx
;
9128 location_t saved_location
;
9132 /* gimple_test_f might be more strict than is_gimple_val, make
9133 sure we pass both. Just checking gimple_test_f doesn't work
9134 because most gimple predicates do not work recursively. */
9135 if (is_gimple_val (expr
)
9136 && (*gimple_test_f
) (expr
))
9139 push_gimplify_context (&gctx
);
9140 gimplify_ctxp
->into_ssa
= gimple_in_ssa_p (cfun
);
9141 gimplify_ctxp
->allow_rhs_cond_expr
= true;
9142 saved_location
= input_location
;
9143 input_location
= UNKNOWN_LOCATION
;
9147 if (gimplify_ctxp
->into_ssa
9148 && is_gimple_reg (var
))
9149 var
= make_ssa_name (var
, NULL
);
9150 expr
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, expr
);
9153 if (TREE_CODE (expr
) != MODIFY_EXPR
9154 && TREE_TYPE (expr
) == void_type_node
)
9156 gimplify_and_add (expr
, stmts
);
9161 ret
= gimplify_expr (&expr
, stmts
, NULL
, gimple_test_f
, fb_rvalue
);
9162 gcc_assert (ret
!= GS_ERROR
);
9165 input_location
= saved_location
;
9166 pop_gimplify_context (NULL
);
9171 /* Expand EXPR to list of gimple statements STMTS. If SIMPLE is true,
9172 force the result to be either ssa_name or an invariant, otherwise
9173 just force it to be a rhs expression. If VAR is not NULL, make the
9174 base variable of the final destination be VAR if suitable. */
9177 force_gimple_operand (tree expr
, gimple_seq
*stmts
, bool simple
, tree var
)
9179 return force_gimple_operand_1 (expr
, stmts
,
9180 simple
? is_gimple_val
: is_gimple_reg_rhs
,
9184 /* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
9185 and VAR. If some statements are produced, emits them at GSI.
9186 If BEFORE is true. the statements are appended before GSI, otherwise
9187 they are appended after it. M specifies the way GSI moves after
9188 insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values). */
9191 force_gimple_operand_gsi_1 (gimple_stmt_iterator
*gsi
, tree expr
,
9192 gimple_predicate gimple_test_f
,
9193 tree var
, bool before
,
9194 enum gsi_iterator_update m
)
9198 expr
= force_gimple_operand_1 (expr
, &stmts
, gimple_test_f
, var
);
9200 if (!gimple_seq_empty_p (stmts
))
9203 gsi_insert_seq_before (gsi
, stmts
, m
);
9205 gsi_insert_seq_after (gsi
, stmts
, m
);
9211 /* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
9212 If SIMPLE is true, force the result to be either ssa_name or an invariant,
9213 otherwise just force it to be a rhs expression. If some statements are
9214 produced, emits them at GSI. If BEFORE is true, the statements are
9215 appended before GSI, otherwise they are appended after it. M specifies
9216 the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
9217 are the usual values). */
9220 force_gimple_operand_gsi (gimple_stmt_iterator
*gsi
, tree expr
,
9221 bool simple_p
, tree var
, bool before
,
9222 enum gsi_iterator_update m
)
9224 return force_gimple_operand_gsi_1 (gsi
, expr
,
9226 ? is_gimple_val
: is_gimple_reg_rhs
,
9230 #ifndef PAD_VARARGS_DOWN
9231 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
9234 /* Build an indirect-ref expression over the given TREE, which represents a
9235 piece of a va_arg() expansion. */
9237 build_va_arg_indirect_ref (tree addr
)
9239 addr
= build_simple_mem_ref_loc (EXPR_LOCATION (addr
), addr
);
9241 if (flag_mudflap
) /* Don't instrument va_arg INDIRECT_REF. */
9247 /* The "standard" implementation of va_arg: read the value from the
9248 current (padded) address and increment by the (padded) size. */
9251 std_gimplify_va_arg_expr (tree valist
, tree type
, gimple_seq
*pre_p
,
9254 tree addr
, t
, type_size
, rounded_size
, valist_tmp
;
9255 unsigned HOST_WIDE_INT align
, boundary
;
9258 #ifdef ARGS_GROW_DOWNWARD
9259 /* All of the alignment and movement below is for args-grow-up machines.
9260 As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
9261 implement their own specialized gimplify_va_arg_expr routines. */
9265 indirect
= pass_by_reference (NULL
, TYPE_MODE (type
), type
, false);
9267 type
= build_pointer_type (type
);
9269 align
= PARM_BOUNDARY
/ BITS_PER_UNIT
;
9270 boundary
= targetm
.calls
.function_arg_boundary (TYPE_MODE (type
), type
);
9272 /* When we align parameter on stack for caller, if the parameter
9273 alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
9274 aligned at MAX_SUPPORTED_STACK_ALIGNMENT. We will match callee
9275 here with caller. */
9276 if (boundary
> MAX_SUPPORTED_STACK_ALIGNMENT
)
9277 boundary
= MAX_SUPPORTED_STACK_ALIGNMENT
;
9279 boundary
/= BITS_PER_UNIT
;
9281 /* Hoist the valist value into a temporary for the moment. */
9282 valist_tmp
= get_initialized_tmp_var (valist
, pre_p
, NULL
);
9284 /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
9285 requires greater alignment, we must perform dynamic alignment. */
9286 if (boundary
> align
9287 && !integer_zerop (TYPE_SIZE (type
)))
9289 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
9290 fold_build_pointer_plus_hwi (valist_tmp
, boundary
- 1));
9291 gimplify_and_add (t
, pre_p
);
9293 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist_tmp
,
9294 fold_build2 (BIT_AND_EXPR
, TREE_TYPE (valist
),
9296 build_int_cst (TREE_TYPE (valist
), -boundary
)));
9297 gimplify_and_add (t
, pre_p
);
9302 /* If the actual alignment is less than the alignment of the type,
9303 adjust the type accordingly so that we don't assume strict alignment
9304 when dereferencing the pointer. */
9305 boundary
*= BITS_PER_UNIT
;
9306 if (boundary
< TYPE_ALIGN (type
))
9308 type
= build_variant_type_copy (type
);
9309 TYPE_ALIGN (type
) = boundary
;
9312 /* Compute the rounded size of the type. */
9313 type_size
= size_in_bytes (type
);
9314 rounded_size
= round_up (type_size
, align
);
9316 /* Reduce rounded_size so it's sharable with the postqueue. */
9317 gimplify_expr (&rounded_size
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
9321 if (PAD_VARARGS_DOWN
&& !integer_zerop (rounded_size
))
9323 /* Small args are padded downward. */
9324 t
= fold_build2_loc (input_location
, GT_EXPR
, sizetype
,
9325 rounded_size
, size_int (align
));
9326 t
= fold_build3 (COND_EXPR
, sizetype
, t
, size_zero_node
,
9327 size_binop (MINUS_EXPR
, rounded_size
, type_size
));
9328 addr
= fold_build_pointer_plus (addr
, t
);
9331 /* Compute new value for AP. */
9332 t
= fold_build_pointer_plus (valist_tmp
, rounded_size
);
9333 t
= build2 (MODIFY_EXPR
, TREE_TYPE (valist
), valist
, t
);
9334 gimplify_and_add (t
, pre_p
);
9336 addr
= fold_convert (build_pointer_type (type
), addr
);
9339 addr
= build_va_arg_indirect_ref (addr
);
9341 return build_va_arg_indirect_ref (addr
);
9344 #include "gt-gimplify.h"