1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Major work done by Sebastian Pop <s.pop@laposte.net>,
6 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
26 #include "coretypes.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
32 #include "tree-pretty-print.h"
33 #include "langhooks.h"
34 #include "tree-flow.h"
42 #include "diagnostic-core.h"
45 #include "pointer-set.h"
46 #include "splay-tree.h"
49 #include "tree-pass.h"
51 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name. */
52 #include "expr.h" /* FIXME: for can_move_by_pieces
53 and STACK_CHECK_MAX_VAR_SIZE. */
55 enum gimplify_omp_var_data
61 GOVD_FIRSTPRIVATE
= 16,
62 GOVD_LASTPRIVATE
= 32,
65 GOVD_DEBUG_PRIVATE
= 256,
66 GOVD_PRIVATE_OUTER_REF
= 512,
67 GOVD_DATA_SHARE_CLASS
= (GOVD_SHARED
| GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
68 | GOVD_LASTPRIVATE
| GOVD_REDUCTION
| GOVD_LOCAL
)
76 ORT_COMBINED_PARALLEL
= 3,
81 struct gimplify_omp_ctx
83 struct gimplify_omp_ctx
*outer_context
;
85 struct pointer_set_t
*privatized_types
;
87 enum omp_clause_default_kind default_kind
;
88 enum omp_region_type region_type
;
91 static struct gimplify_ctx
*gimplify_ctxp
;
92 static struct gimplify_omp_ctx
*gimplify_omp_ctxp
;
95 /* Formal (expression) temporary table handling: Multiple occurrences of
96 the same scalar expression are evaluated into the same temporary. */
98 typedef struct gimple_temp_hash_elt
101 tree temp
; /* Value */
104 /* Forward declarations. */
105 static enum gimplify_status
gimplify_compound_expr (tree
*, gimple_seq
*, bool);
107 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
108 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;
124 /* Return a hash value for a formal temporary table entry. */
127 gimple_tree_hash (const void *p
)
129 tree t
= ((const elt_t
*) p
)->val
;
130 return iterative_hash_expr (t
, 0);
133 /* Compare two formal temporary table entries. */
136 gimple_tree_eq (const void *p1
, const void *p2
)
138 tree t1
= ((const elt_t
*) p1
)->val
;
139 tree t2
= ((const elt_t
*) p2
)->val
;
140 enum tree_code code
= TREE_CODE (t1
);
142 if (TREE_CODE (t2
) != code
143 || TREE_TYPE (t1
) != TREE_TYPE (t2
))
146 if (!operand_equal_p (t1
, t2
, 0))
149 /* Only allow them to compare equal if they also hash equal; otherwise
150 results are nondeterminate, and we fail bootstrap comparison. */
151 gcc_assert (gimple_tree_hash (p1
) == gimple_tree_hash (p2
));
156 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
157 *SEQ_P is NULL, a new sequence is allocated. This function is
158 similar to gimple_seq_add_stmt, but does not scan the operands.
159 During gimplification, we need to manipulate statement sequences
160 before the def/use vectors have been constructed. */
163 gimplify_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
165 gimple_stmt_iterator si
;
171 *seq_p
= gimple_seq_alloc ();
173 si
= gsi_last (*seq_p
);
175 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
178 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
179 NULL, a new sequence is allocated. This function is
180 similar to gimple_seq_add_seq, but does not scan the operands.
181 During gimplification, we need to manipulate statement sequences
182 before the def/use vectors have been constructed. */
185 gimplify_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
187 gimple_stmt_iterator si
;
193 *dst_p
= gimple_seq_alloc ();
195 si
= gsi_last (*dst_p
);
196 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
199 /* Set up a context for the gimplifier. */
202 push_gimplify_context (struct gimplify_ctx
*c
)
204 memset (c
, '\0', sizeof (*c
));
205 c
->prev_context
= gimplify_ctxp
;
209 /* Tear down a context for the gimplifier. If BODY is non-null, then
210 put the temporaries into the outer BIND_EXPR. Otherwise, put them
213 BODY is not a sequence, but the first tuple in a sequence. */
216 pop_gimplify_context (gimple body
)
218 struct gimplify_ctx
*c
= gimplify_ctxp
;
220 gcc_assert (c
&& (c
->bind_expr_stack
== NULL
221 || VEC_empty (gimple
, c
->bind_expr_stack
)));
222 VEC_free (gimple
, heap
, c
->bind_expr_stack
);
223 gimplify_ctxp
= c
->prev_context
;
226 declare_vars (c
->temps
, body
, false);
228 record_vars (c
->temps
);
231 htab_delete (c
->temp_htab
);
235 gimple_push_bind_expr (gimple gimple_bind
)
237 if (gimplify_ctxp
->bind_expr_stack
== NULL
)
238 gimplify_ctxp
->bind_expr_stack
= VEC_alloc (gimple
, heap
, 8);
239 VEC_safe_push (gimple
, heap
, gimplify_ctxp
->bind_expr_stack
, gimple_bind
);
243 gimple_pop_bind_expr (void)
245 VEC_pop (gimple
, gimplify_ctxp
->bind_expr_stack
);
249 gimple_current_bind_expr (void)
251 return VEC_last (gimple
, gimplify_ctxp
->bind_expr_stack
);
254 /* Return the stack GIMPLE_BINDs created during gimplification. */
257 gimple_bind_expr_stack (void)
259 return gimplify_ctxp
->bind_expr_stack
;
262 /* Returns true iff there is a COND_EXPR between us and the innermost
263 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
266 gimple_conditional_context (void)
268 return gimplify_ctxp
->conditions
> 0;
271 /* Note that we've entered a COND_EXPR. */
274 gimple_push_condition (void)
276 #ifdef ENABLE_GIMPLE_CHECKING
277 if (gimplify_ctxp
->conditions
== 0)
278 gcc_assert (gimple_seq_empty_p (gimplify_ctxp
->conditional_cleanups
));
280 ++(gimplify_ctxp
->conditions
);
283 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
284 now, add any conditional cleanups we've seen to the prequeue. */
287 gimple_pop_condition (gimple_seq
*pre_p
)
289 int conds
= --(gimplify_ctxp
->conditions
);
291 gcc_assert (conds
>= 0);
294 gimplify_seq_add_seq (pre_p
, gimplify_ctxp
->conditional_cleanups
);
295 gimplify_ctxp
->conditional_cleanups
= NULL
;
299 /* A stable comparison routine for use with splay trees and DECLs. */
302 splay_tree_compare_decl_uid (splay_tree_key xa
, splay_tree_key xb
)
307 return DECL_UID (a
) - DECL_UID (b
);
310 /* Create a new omp construct that deals with variable remapping. */
312 static struct gimplify_omp_ctx
*
313 new_omp_context (enum omp_region_type region_type
)
315 struct gimplify_omp_ctx
*c
;
317 c
= XCNEW (struct gimplify_omp_ctx
);
318 c
->outer_context
= gimplify_omp_ctxp
;
319 c
->variables
= splay_tree_new (splay_tree_compare_decl_uid
, 0, 0);
320 c
->privatized_types
= pointer_set_create ();
321 c
->location
= input_location
;
322 c
->region_type
= region_type
;
323 if ((region_type
& ORT_TASK
) == 0)
324 c
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
326 c
->default_kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
331 /* Destroy an omp construct that deals with variable remapping. */
334 delete_omp_context (struct gimplify_omp_ctx
*c
)
336 splay_tree_delete (c
->variables
);
337 pointer_set_destroy (c
->privatized_types
);
341 static void omp_add_variable (struct gimplify_omp_ctx
*, tree
, unsigned int);
342 static bool omp_notice_variable (struct gimplify_omp_ctx
*, tree
, bool);
344 /* Both gimplify the statement T and append it to *SEQ_P. This function
345 behaves exactly as gimplify_stmt, but you don't have to pass T as a
349 gimplify_and_add (tree t
, gimple_seq
*seq_p
)
351 gimplify_stmt (&t
, seq_p
);
354 /* Gimplify statement T into sequence *SEQ_P, and return the first
355 tuple in the sequence of generated tuples for this statement.
356 Return NULL if gimplifying T produced no tuples. */
359 gimplify_and_return_first (tree t
, gimple_seq
*seq_p
)
361 gimple_stmt_iterator last
= gsi_last (*seq_p
);
363 gimplify_and_add (t
, seq_p
);
365 if (!gsi_end_p (last
))
368 return gsi_stmt (last
);
371 return gimple_seq_first_stmt (*seq_p
);
374 /* Strip off a legitimate source ending from the input string NAME of
375 length LEN. Rather than having to know the names used by all of
376 our front ends, we strip off an ending of a period followed by
377 up to five characters. (Java uses ".class".) */
380 remove_suffix (char *name
, int len
)
384 for (i
= 2; i
< 8 && len
> i
; i
++)
386 if (name
[len
- i
] == '.')
388 name
[len
- i
] = '\0';
394 /* Create a new temporary name with PREFIX. Returns an identifier. */
396 static GTY(()) unsigned int tmp_var_id_num
;
399 create_tmp_var_name (const char *prefix
)
405 char *preftmp
= ASTRDUP (prefix
);
407 remove_suffix (preftmp
, strlen (preftmp
));
411 ASM_FORMAT_PRIVATE_NAME (tmp_name
, prefix
? prefix
: "T", tmp_var_id_num
++);
412 return get_identifier (tmp_name
);
416 /* Create a new temporary variable declaration of type TYPE.
417 Does NOT push it into the current binding. */
420 create_tmp_var_raw (tree type
, const char *prefix
)
425 /* Make the type of the variable writable. */
426 new_type
= build_type_variant (type
, 0, 0);
427 TYPE_ATTRIBUTES (new_type
) = TYPE_ATTRIBUTES (type
);
429 tmp_var
= build_decl (input_location
,
430 VAR_DECL
, prefix
? create_tmp_var_name (prefix
) : NULL
,
433 /* The variable was declared by the compiler. */
434 DECL_ARTIFICIAL (tmp_var
) = 1;
435 /* And we don't want debug info for it. */
436 DECL_IGNORED_P (tmp_var
) = 1;
438 /* Make the variable writable. */
439 TREE_READONLY (tmp_var
) = 0;
441 DECL_EXTERNAL (tmp_var
) = 0;
442 TREE_STATIC (tmp_var
) = 0;
443 TREE_USED (tmp_var
) = 1;
448 /* Create a new temporary variable declaration of type TYPE. DOES push the
449 variable into the current binding. Further, assume that this is called
450 only from gimplification or optimization, at which point the creation of
451 certain types are bugs. */
454 create_tmp_var (tree type
, const char *prefix
)
458 /* We don't allow types that are addressable (meaning we can't make copies),
459 or incomplete. We also used to reject every variable size objects here,
460 but now support those for which a constant upper bound can be obtained.
461 The processing for variable sizes is performed in gimple_add_tmp_var,
462 point at which it really matters and possibly reached via paths not going
463 through this function, e.g. after direct calls to create_tmp_var_raw. */
464 gcc_assert (!TREE_ADDRESSABLE (type
) && COMPLETE_TYPE_P (type
));
466 tmp_var
= create_tmp_var_raw (type
, prefix
);
467 gimple_add_tmp_var (tmp_var
);
471 /* Create a new temporary variable declaration of type TYPE by calling
472 create_tmp_var and if TYPE is a vector or a complex number, mark the new
473 temporary as gimple register. */
476 create_tmp_reg (tree type
, const char *prefix
)
480 tmp
= create_tmp_var (type
, prefix
);
481 if (TREE_CODE (type
) == COMPLEX_TYPE
482 || TREE_CODE (type
) == VECTOR_TYPE
)
483 DECL_GIMPLE_REG_P (tmp
) = 1;
488 /* Create a temporary with a name derived from VAL. Subroutine of
489 lookup_tmp_var; nobody else should call this function. */
492 create_tmp_from_val (tree val
)
494 return create_tmp_var (TREE_TYPE (val
), get_name (val
));
497 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
498 an existing expression temporary. */
501 lookup_tmp_var (tree val
, bool is_formal
)
505 /* If not optimizing, never really reuse a temporary. local-alloc
506 won't allocate any variable that is used in more than one basic
507 block, which means it will go into memory, causing much extra
508 work in reload and final and poorer code generation, outweighing
509 the extra memory allocation here. */
510 if (!optimize
|| !is_formal
|| TREE_SIDE_EFFECTS (val
))
511 ret
= create_tmp_from_val (val
);
518 if (gimplify_ctxp
->temp_htab
== NULL
)
519 gimplify_ctxp
->temp_htab
520 = htab_create (1000, gimple_tree_hash
, gimple_tree_eq
, free
);
521 slot
= htab_find_slot (gimplify_ctxp
->temp_htab
, (void *)&elt
, INSERT
);
524 elt_p
= XNEW (elt_t
);
526 elt_p
->temp
= ret
= create_tmp_from_val (val
);
527 *slot
= (void *) elt_p
;
531 elt_p
= (elt_t
*) *slot
;
540 /* Return true if T is a CALL_EXPR or an expression that can be
541 assigned to a temporary. Note that this predicate should only be
542 used during gimplification. See the rationale for this in
543 gimplify_modify_expr. */
546 is_gimple_reg_rhs_or_call (tree t
)
548 return (get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
549 || TREE_CODE (t
) == CALL_EXPR
);
552 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
553 this predicate should only be used during gimplification. See the
554 rationale for this in gimplify_modify_expr. */
557 is_gimple_mem_rhs_or_call (tree t
)
559 /* If we're dealing with a renamable type, either source or dest must be
560 a renamed variable. */
561 if (is_gimple_reg_type (TREE_TYPE (t
)))
562 return is_gimple_val (t
);
564 return (is_gimple_val (t
) || is_gimple_lvalue (t
)
565 || TREE_CODE (t
) == CALL_EXPR
);
568 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
571 internal_get_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
576 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
577 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
578 gimplify_expr (&val
, pre_p
, post_p
, is_gimple_reg_rhs_or_call
,
581 t
= lookup_tmp_var (val
, is_formal
);
584 && (TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
585 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
))
586 DECL_GIMPLE_REG_P (t
) = 1;
588 mod
= build2 (INIT_EXPR
, TREE_TYPE (t
), t
, unshare_expr (val
));
590 SET_EXPR_LOCATION (mod
, EXPR_LOC_OR_HERE (val
));
592 /* gimplify_modify_expr might want to reduce this further. */
593 gimplify_and_add (mod
, pre_p
);
596 /* If we're gimplifying into ssa, gimplify_modify_expr will have
597 given our temporary an SSA name. Find and return it. */
598 if (gimplify_ctxp
->into_ssa
)
600 gimple last
= gimple_seq_last_stmt (*pre_p
);
601 t
= gimple_get_lhs (last
);
607 /* Returns a formal temporary variable initialized with VAL. PRE_P is as
608 in gimplify_expr. Only use this function if:
610 1) The value of the unfactored expression represented by VAL will not
611 change between the initialization and use of the temporary, and
612 2) The temporary will not be otherwise modified.
614 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
615 and #2 means it is inappropriate for && temps.
617 For other cases, use get_initialized_tmp_var instead. */
620 get_formal_tmp_var (tree val
, gimple_seq
*pre_p
)
622 return internal_get_tmp_var (val
, pre_p
, NULL
, true);
625 /* Returns a temporary variable initialized with VAL. PRE_P and POST_P
626 are as in gimplify_expr. */
629 get_initialized_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
631 return internal_get_tmp_var (val
, pre_p
, post_p
, false);
634 /* Declares all the variables in VARS in SCOPE. If DEBUG_INFO is
635 true, generate debug info for them; otherwise don't. */
638 declare_vars (tree vars
, gimple scope
, bool debug_info
)
645 gcc_assert (gimple_code (scope
) == GIMPLE_BIND
);
647 temps
= nreverse (last
);
649 block
= gimple_bind_block (scope
);
650 gcc_assert (!block
|| TREE_CODE (block
) == BLOCK
);
651 if (!block
|| !debug_info
)
653 DECL_CHAIN (last
) = gimple_bind_vars (scope
);
654 gimple_bind_set_vars (scope
, temps
);
658 /* We need to attach the nodes both to the BIND_EXPR and to its
659 associated BLOCK for debugging purposes. The key point here
660 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
661 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
662 if (BLOCK_VARS (block
))
663 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), temps
);
666 gimple_bind_set_vars (scope
,
667 chainon (gimple_bind_vars (scope
), temps
));
668 BLOCK_VARS (block
) = temps
;
674 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
675 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
676 no such upper bound can be obtained. */
679 force_constant_size (tree var
)
681 /* The only attempt we make is by querying the maximum size of objects
682 of the variable's type. */
684 HOST_WIDE_INT max_size
;
686 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
688 max_size
= max_int_size_in_bytes (TREE_TYPE (var
));
690 gcc_assert (max_size
>= 0);
693 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var
)), max_size
);
695 = build_int_cst (TREE_TYPE (DECL_SIZE (var
)), max_size
* BITS_PER_UNIT
);
699 gimple_add_tmp_var (tree tmp
)
701 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
703 /* Later processing assumes that the object size is constant, which might
704 not be true at this point. Force the use of a constant upper bound in
706 if (!host_integerp (DECL_SIZE_UNIT (tmp
), 1))
707 force_constant_size (tmp
);
709 DECL_CONTEXT (tmp
) = current_function_decl
;
710 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
714 DECL_CHAIN (tmp
) = gimplify_ctxp
->temps
;
715 gimplify_ctxp
->temps
= tmp
;
717 /* Mark temporaries local within the nearest enclosing parallel. */
718 if (gimplify_omp_ctxp
)
720 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
721 while (ctx
&& ctx
->region_type
== ORT_WORKSHARE
)
722 ctx
= ctx
->outer_context
;
724 omp_add_variable (ctx
, tmp
, GOVD_LOCAL
| GOVD_SEEN
);
733 /* This case is for nested functions. We need to expose the locals
735 body_seq
= gimple_body (current_function_decl
);
736 declare_vars (tmp
, gimple_seq_first_stmt (body_seq
), false);
740 /* Determines whether to assign a location to the statement GS. */
743 should_carry_location_p (gimple gs
)
745 /* Don't emit a line note for a label. We particularly don't want to
746 emit one for the break label, since it doesn't actually correspond
747 to the beginning of the loop/switch. */
748 if (gimple_code (gs
) == GIMPLE_LABEL
)
755 /* Return true if a location should not be emitted for this statement
756 by annotate_one_with_location. */
759 gimple_do_not_emit_location_p (gimple g
)
761 return gimple_plf (g
, GF_PLF_1
);
764 /* Mark statement G so a location will not be emitted by
765 annotate_one_with_location. */
768 gimple_set_do_not_emit_location (gimple g
)
770 /* The PLF flags are initialized to 0 when a new tuple is created,
771 so no need to initialize it anywhere. */
772 gimple_set_plf (g
, GF_PLF_1
, true);
775 /* Set the location for gimple statement GS to LOCATION. */
778 annotate_one_with_location (gimple gs
, location_t location
)
780 if (!gimple_has_location (gs
)
781 && !gimple_do_not_emit_location_p (gs
)
782 && should_carry_location_p (gs
))
783 gimple_set_location (gs
, location
);
787 /* Set LOCATION for all the statements after iterator GSI in sequence
788 SEQ. If GSI is pointing to the end of the sequence, start with the
789 first statement in SEQ. */
792 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
796 gsi
= gsi_start (seq
);
800 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
801 annotate_one_with_location (gsi_stmt (gsi
), location
);
805 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
808 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
810 gimple_stmt_iterator i
;
812 if (gimple_seq_empty_p (stmt_p
))
815 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
817 gimple gs
= gsi_stmt (i
);
818 annotate_one_with_location (gs
, location
);
822 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
823 nodes that are referenced more than once in GENERIC functions. This is
824 necessary because gimplification (translation into GIMPLE) is performed
825 by modifying tree nodes in-place, so gimplication of a shared node in a
826 first context could generate an invalid GIMPLE form in a second context.
828 This is achieved with a simple mark/copy/unmark algorithm that walks the
829 GENERIC representation top-down, marks nodes with TREE_VISITED the first
830 time it encounters them, duplicates them if they already have TREE_VISITED
831 set, and finally removes the TREE_VISITED marks it has set.
833 The algorithm works only at the function level, i.e. it generates a GENERIC
834 representation of a function with no nodes shared within the function when
835 passed a GENERIC function (except for nodes that are allowed to be shared).
837 At the global level, it is also necessary to unshare tree nodes that are
838 referenced in more than one function, for the same aforementioned reason.
839 This requires some cooperation from the front-end. There are 2 strategies:
841 1. Manual unsharing. The front-end needs to call unshare_expr on every
842 expression that might end up being shared across functions.
844 2. Deep unsharing. This is an extension of regular unsharing. Instead
845 of calling unshare_expr on expressions that might be shared across
846 functions, the front-end pre-marks them with TREE_VISITED. This will
847 ensure that they are unshared on the first reference within functions
848 when the regular unsharing algorithm runs. The counterpart is that
849 this algorithm must look deeper than for manual unsharing, which is
850 specified by LANG_HOOKS_DEEP_UNSHARING.
852 If there are only few specific cases of node sharing across functions, it is
853 probably easier for a front-end to unshare the expressions manually. On the
854 contrary, if the expressions generated at the global level are as widespread
855 as expressions generated within functions, deep unsharing is very likely the
858 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
859 These nodes model computations that should only be done once. If we
860 were to unshare something like SAVE_EXPR(i++), the gimplification
861 process would create wrong code. */
864 mostly_copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
867 enum tree_code code
= TREE_CODE (t
);
869 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
870 copy their subtrees if we can make sure to do it only once. */
871 if (code
== SAVE_EXPR
|| code
== TARGET_EXPR
|| code
== BIND_EXPR
)
873 if (data
&& !pointer_set_insert ((struct pointer_set_t
*)data
, t
))
879 /* Stop at types, decls, constants like copy_tree_r. */
880 else if (TREE_CODE_CLASS (code
) == tcc_type
881 || TREE_CODE_CLASS (code
) == tcc_declaration
882 || TREE_CODE_CLASS (code
) == tcc_constant
883 /* We can't do anything sensible with a BLOCK used as an
884 expression, but we also can't just die when we see it
885 because of non-expression uses. So we avert our eyes
886 and cross our fingers. Silly Java. */
890 /* Cope with the statement expression extension. */
891 else if (code
== STATEMENT_LIST
)
894 /* Leave the bulk of the work to copy_tree_r itself. */
896 copy_tree_r (tp
, walk_subtrees
, NULL
);
901 /* Callback for walk_tree to unshare most of the shared trees rooted at
902 *TP. If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1),
903 then *TP is deep copied by calling mostly_copy_tree_r. */
906 copy_if_shared_r (tree
*tp
, int *walk_subtrees
, void *data
)
909 enum tree_code code
= TREE_CODE (t
);
911 /* Skip types, decls, and constants. But we do want to look at their
912 types and the bounds of types. Mark them as visited so we properly
913 unmark their subtrees on the unmark pass. If we've already seen them,
914 don't look down further. */
915 if (TREE_CODE_CLASS (code
) == tcc_type
916 || TREE_CODE_CLASS (code
) == tcc_declaration
917 || TREE_CODE_CLASS (code
) == tcc_constant
)
919 if (TREE_VISITED (t
))
922 TREE_VISITED (t
) = 1;
925 /* If this node has been visited already, unshare it and don't look
927 else if (TREE_VISITED (t
))
929 walk_tree (tp
, mostly_copy_tree_r
, data
, NULL
);
933 /* Otherwise, mark the node as visited and keep looking. */
935 TREE_VISITED (t
) = 1;
940 /* Unshare most of the shared trees rooted at *TP. */
943 copy_if_shared (tree
*tp
)
945 /* If the language requires deep unsharing, we need a pointer set to make
946 sure we don't repeatedly unshare subtrees of unshareable nodes. */
947 struct pointer_set_t
*visited
948 = lang_hooks
.deep_unsharing
? pointer_set_create () : NULL
;
949 walk_tree (tp
, copy_if_shared_r
, visited
, NULL
);
951 pointer_set_destroy (visited
);
954 /* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the
955 bodies of any nested functions if we are unsharing the entire body of
959 unshare_body (tree
*body_p
, tree fndecl
)
961 struct cgraph_node
*cgn
= cgraph_node (fndecl
);
963 copy_if_shared (body_p
);
965 if (body_p
== &DECL_SAVED_TREE (fndecl
))
966 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
967 unshare_body (&DECL_SAVED_TREE (cgn
->decl
), cgn
->decl
);
970 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
971 Subtrees are walked until the first unvisited node is encountered. */
974 unmark_visited_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
978 /* If this node has been visited, unmark it and keep looking. */
979 if (TREE_VISITED (t
))
980 TREE_VISITED (t
) = 0;
982 /* Otherwise, don't look any deeper. */
989 /* Unmark the visited trees rooted at *TP. */
992 unmark_visited (tree
*tp
)
994 walk_tree (tp
, unmark_visited_r
, NULL
, NULL
);
997 /* Likewise, but mark all trees as not visited. */
1000 unvisit_body (tree
*body_p
, tree fndecl
)
1002 struct cgraph_node
*cgn
= cgraph_node (fndecl
);
1004 unmark_visited (body_p
);
1006 if (body_p
== &DECL_SAVED_TREE (fndecl
))
1007 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
1008 unvisit_body (&DECL_SAVED_TREE (cgn
->decl
), cgn
->decl
);
1011 /* Unconditionally make an unshared copy of EXPR. This is used when using
1012 stored expressions which span multiple functions, such as BINFO_VTABLE,
1013 as the normal unsharing process can't tell that they're shared. */
1016 unshare_expr (tree expr
)
1018 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
1022 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1023 contain statements and have a value. Assign its value to a temporary
1024 and give it void_type_node. Returns the temporary, or NULL_TREE if
1025 WRAPPER was already void. */
1028 voidify_wrapper_expr (tree wrapper
, tree temp
)
1030 tree type
= TREE_TYPE (wrapper
);
1031 if (type
&& !VOID_TYPE_P (type
))
1035 /* Set p to point to the body of the wrapper. Loop until we find
1036 something that isn't a wrapper. */
1037 for (p
= &wrapper
; p
&& *p
; )
1039 switch (TREE_CODE (*p
))
1042 TREE_SIDE_EFFECTS (*p
) = 1;
1043 TREE_TYPE (*p
) = void_type_node
;
1044 /* For a BIND_EXPR, the body is operand 1. */
1045 p
= &BIND_EXPR_BODY (*p
);
1048 case CLEANUP_POINT_EXPR
:
1049 case TRY_FINALLY_EXPR
:
1050 case TRY_CATCH_EXPR
:
1051 TREE_SIDE_EFFECTS (*p
) = 1;
1052 TREE_TYPE (*p
) = void_type_node
;
1053 p
= &TREE_OPERAND (*p
, 0);
1056 case STATEMENT_LIST
:
1058 tree_stmt_iterator i
= tsi_last (*p
);
1059 TREE_SIDE_EFFECTS (*p
) = 1;
1060 TREE_TYPE (*p
) = void_type_node
;
1061 p
= tsi_end_p (i
) ? NULL
: tsi_stmt_ptr (i
);
1066 /* Advance to the last statement. Set all container types to void. */
1067 for (; TREE_CODE (*p
) == COMPOUND_EXPR
; p
= &TREE_OPERAND (*p
, 1))
1069 TREE_SIDE_EFFECTS (*p
) = 1;
1070 TREE_TYPE (*p
) = void_type_node
;
1080 if (p
== NULL
|| IS_EMPTY_STMT (*p
))
1084 /* The wrapper is on the RHS of an assignment that we're pushing
1086 gcc_assert (TREE_CODE (temp
) == INIT_EXPR
1087 || TREE_CODE (temp
) == MODIFY_EXPR
);
1088 TREE_OPERAND (temp
, 1) = *p
;
1093 temp
= create_tmp_var (type
, "retval");
1094 *p
= build2 (INIT_EXPR
, type
, temp
, *p
);
1103 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1104 a temporary through which they communicate. */
1107 build_stack_save_restore (gimple
*save
, gimple
*restore
)
1111 *save
= gimple_build_call (implicit_built_in_decls
[BUILT_IN_STACK_SAVE
], 0);
1112 tmp_var
= create_tmp_var (ptr_type_node
, "saved_stack");
1113 gimple_call_set_lhs (*save
, tmp_var
);
1115 *restore
= gimple_build_call (implicit_built_in_decls
[BUILT_IN_STACK_RESTORE
],
1119 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1121 static enum gimplify_status
1122 gimplify_bind_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1124 tree bind_expr
= *expr_p
;
1125 bool old_save_stack
= gimplify_ctxp
->save_stack
;
1130 tree temp
= voidify_wrapper_expr (bind_expr
, NULL
);
1132 /* Mark variables seen in this bind expr. */
1133 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1135 if (TREE_CODE (t
) == VAR_DECL
)
1137 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1139 /* Mark variable as local. */
1140 if (ctx
&& !is_global_var (t
)
1141 && (! DECL_SEEN_IN_BIND_EXPR_P (t
)
1142 || splay_tree_lookup (ctx
->variables
,
1143 (splay_tree_key
) t
) == NULL
))
1144 omp_add_variable (gimplify_omp_ctxp
, t
, GOVD_LOCAL
| GOVD_SEEN
);
1146 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
1148 if (DECL_HARD_REGISTER (t
) && !is_global_var (t
) && cfun
)
1149 cfun
->has_local_explicit_reg_vars
= true;
1152 /* Preliminarily mark non-addressed complex variables as eligible
1153 for promotion to gimple registers. We'll transform their uses
1155 if ((TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
1156 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1157 && !TREE_THIS_VOLATILE (t
)
1158 && (TREE_CODE (t
) == VAR_DECL
&& !DECL_HARD_REGISTER (t
))
1159 && !needs_to_live_in_memory (t
))
1160 DECL_GIMPLE_REG_P (t
) = 1;
1163 gimple_bind
= gimple_build_bind (BIND_EXPR_VARS (bind_expr
), NULL
,
1164 BIND_EXPR_BLOCK (bind_expr
));
1165 gimple_push_bind_expr (gimple_bind
);
1167 gimplify_ctxp
->save_stack
= false;
1169 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1171 gimplify_stmt (&BIND_EXPR_BODY (bind_expr
), &body
);
1172 gimple_bind_set_body (gimple_bind
, body
);
1174 if (gimplify_ctxp
->save_stack
)
1176 gimple stack_save
, stack_restore
, gs
;
1177 gimple_seq cleanup
, new_body
;
1179 /* Save stack on entry and restore it on exit. Add a try_finally
1180 block to achieve this. Note that mudflap depends on the
1181 format of the emitted code: see mx_register_decls(). */
1182 build_stack_save_restore (&stack_save
, &stack_restore
);
1184 cleanup
= new_body
= NULL
;
1185 gimplify_seq_add_stmt (&cleanup
, stack_restore
);
1186 gs
= gimple_build_try (gimple_bind_body (gimple_bind
), cleanup
,
1187 GIMPLE_TRY_FINALLY
);
1189 gimplify_seq_add_stmt (&new_body
, stack_save
);
1190 gimplify_seq_add_stmt (&new_body
, gs
);
1191 gimple_bind_set_body (gimple_bind
, new_body
);
1194 gimplify_ctxp
->save_stack
= old_save_stack
;
1195 gimple_pop_bind_expr ();
1197 gimplify_seq_add_stmt (pre_p
, gimple_bind
);
1205 *expr_p
= NULL_TREE
;
1209 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1210 GIMPLE value, it is assigned to a new temporary and the statement is
1211 re-written to return the temporary.
1213 PRE_P points to the sequence where side effects that must happen before
1214 STMT should be stored. */
1216 static enum gimplify_status
1217 gimplify_return_expr (tree stmt
, gimple_seq
*pre_p
)
1220 tree ret_expr
= TREE_OPERAND (stmt
, 0);
1221 tree result_decl
, result
;
1223 if (ret_expr
== error_mark_node
)
1227 || TREE_CODE (ret_expr
) == RESULT_DECL
1228 || ret_expr
== error_mark_node
)
1230 gimple ret
= gimple_build_return (ret_expr
);
1231 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1232 gimplify_seq_add_stmt (pre_p
, ret
);
1236 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1237 result_decl
= NULL_TREE
;
1240 result_decl
= TREE_OPERAND (ret_expr
, 0);
1242 /* See through a return by reference. */
1243 if (TREE_CODE (result_decl
) == INDIRECT_REF
)
1244 result_decl
= TREE_OPERAND (result_decl
, 0);
1246 gcc_assert ((TREE_CODE (ret_expr
) == MODIFY_EXPR
1247 || TREE_CODE (ret_expr
) == INIT_EXPR
)
1248 && TREE_CODE (result_decl
) == RESULT_DECL
);
1251 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1252 Recall that aggregate_value_p is FALSE for any aggregate type that is
1253 returned in registers. If we're returning values in registers, then
1254 we don't want to extend the lifetime of the RESULT_DECL, particularly
1255 across another call. In addition, for those aggregates for which
1256 hard_function_value generates a PARALLEL, we'll die during normal
1257 expansion of structure assignments; there's special code in expand_return
1258 to handle this case that does not exist in expand_expr. */
1261 else if (aggregate_value_p (result_decl
, TREE_TYPE (current_function_decl
)))
1263 if (TREE_CODE (DECL_SIZE (result_decl
)) != INTEGER_CST
)
1265 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl
)))
1266 gimplify_type_sizes (TREE_TYPE (result_decl
), pre_p
);
1267 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1268 should be effectively allocated by the caller, i.e. all calls to
1269 this function must be subject to the Return Slot Optimization. */
1270 gimplify_one_sizepos (&DECL_SIZE (result_decl
), pre_p
);
1271 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl
), pre_p
);
1273 result
= result_decl
;
1275 else if (gimplify_ctxp
->return_temp
)
1276 result
= gimplify_ctxp
->return_temp
;
1279 result
= create_tmp_reg (TREE_TYPE (result_decl
), NULL
);
1281 /* ??? With complex control flow (usually involving abnormal edges),
1282 we can wind up warning about an uninitialized value for this. Due
1283 to how this variable is constructed and initialized, this is never
1284 true. Give up and never warn. */
1285 TREE_NO_WARNING (result
) = 1;
1287 gimplify_ctxp
->return_temp
= result
;
1290 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1291 Then gimplify the whole thing. */
1292 if (result
!= result_decl
)
1293 TREE_OPERAND (ret_expr
, 0) = result
;
1295 gimplify_and_add (TREE_OPERAND (stmt
, 0), pre_p
);
1297 ret
= gimple_build_return (result
);
1298 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1299 gimplify_seq_add_stmt (pre_p
, ret
);
1305 gimplify_vla_decl (tree decl
, gimple_seq
*seq_p
)
1307 /* This is a variable-sized decl. Simplify its size and mark it
1308 for deferred expansion. Note that mudflap depends on the format
1309 of the emitted code: see mx_register_decls(). */
1310 tree t
, addr
, ptr_type
;
1312 gimplify_one_sizepos (&DECL_SIZE (decl
), seq_p
);
1313 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl
), seq_p
);
1315 /* All occurrences of this decl in final gimplified code will be
1316 replaced by indirection. Setting DECL_VALUE_EXPR does two
1317 things: First, it lets the rest of the gimplifier know what
1318 replacement to use. Second, it lets the debug info know
1319 where to find the value. */
1320 ptr_type
= build_pointer_type (TREE_TYPE (decl
));
1321 addr
= create_tmp_var (ptr_type
, get_name (decl
));
1322 DECL_IGNORED_P (addr
) = 0;
1323 t
= build_fold_indirect_ref (addr
);
1324 SET_DECL_VALUE_EXPR (decl
, t
);
1325 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1327 t
= built_in_decls
[BUILT_IN_ALLOCA
];
1328 t
= build_call_expr (t
, 1, DECL_SIZE_UNIT (decl
));
1329 /* The call has been built for a variable-sized object. */
1330 ALLOCA_FOR_VAR_P (t
) = 1;
1331 t
= fold_convert (ptr_type
, t
);
1332 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
1334 gimplify_and_add (t
, seq_p
);
1336 /* Indicate that we need to restore the stack level when the
1337 enclosing BIND_EXPR is exited. */
1338 gimplify_ctxp
->save_stack
= true;
1342 /* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation
1343 and initialization explicit. */
1345 static enum gimplify_status
1346 gimplify_decl_expr (tree
*stmt_p
, gimple_seq
*seq_p
)
1348 tree stmt
= *stmt_p
;
1349 tree decl
= DECL_EXPR_DECL (stmt
);
1351 *stmt_p
= NULL_TREE
;
1353 if (TREE_TYPE (decl
) == error_mark_node
)
1356 if ((TREE_CODE (decl
) == TYPE_DECL
1357 || TREE_CODE (decl
) == VAR_DECL
)
1358 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl
)))
1359 gimplify_type_sizes (TREE_TYPE (decl
), seq_p
);
1361 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1363 tree init
= DECL_INITIAL (decl
);
1365 if (TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1366 || (!TREE_STATIC (decl
)
1367 && flag_stack_check
== GENERIC_STACK_CHECK
1368 && compare_tree_int (DECL_SIZE_UNIT (decl
),
1369 STACK_CHECK_MAX_VAR_SIZE
) > 0))
1370 gimplify_vla_decl (decl
, seq_p
);
1372 /* Some front ends do not explicitly declare all anonymous
1373 artificial variables. We compensate here by declaring the
1374 variables, though it would be better if the front ends would
1375 explicitly declare them. */
1376 if (!DECL_SEEN_IN_BIND_EXPR_P (decl
)
1377 && DECL_ARTIFICIAL (decl
) && DECL_NAME (decl
) == NULL_TREE
)
1378 gimple_add_tmp_var (decl
);
1380 if (init
&& init
!= error_mark_node
)
1382 if (!TREE_STATIC (decl
))
1384 DECL_INITIAL (decl
) = NULL_TREE
;
1385 init
= build2 (INIT_EXPR
, void_type_node
, decl
, init
);
1386 gimplify_and_add (init
, seq_p
);
1390 /* We must still examine initializers for static variables
1391 as they may contain a label address. */
1392 walk_tree (&init
, force_labels_r
, NULL
, NULL
);
1399 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1400 and replacing the LOOP_EXPR with goto, but if the loop contains an
1401 EXIT_EXPR, we need to append a label for it to jump to. */
1403 static enum gimplify_status
1404 gimplify_loop_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1406 tree saved_label
= gimplify_ctxp
->exit_label
;
1407 tree start_label
= create_artificial_label (UNKNOWN_LOCATION
);
1409 gimplify_seq_add_stmt (pre_p
, gimple_build_label (start_label
));
1411 gimplify_ctxp
->exit_label
= NULL_TREE
;
1413 gimplify_and_add (LOOP_EXPR_BODY (*expr_p
), pre_p
);
1415 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (start_label
));
1417 if (gimplify_ctxp
->exit_label
)
1418 gimplify_seq_add_stmt (pre_p
, gimple_build_label (gimplify_ctxp
->exit_label
));
1420 gimplify_ctxp
->exit_label
= saved_label
;
1426 /* Gimplifies a statement list onto a sequence. These may be created either
1427 by an enlightened front-end, or by shortcut_cond_expr. */
1429 static enum gimplify_status
1430 gimplify_statement_list (tree
*expr_p
, gimple_seq
*pre_p
)
1432 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
1434 tree_stmt_iterator i
= tsi_start (*expr_p
);
1436 while (!tsi_end_p (i
))
1438 gimplify_stmt (tsi_stmt_ptr (i
), pre_p
);
1451 /* Compare two case labels. Because the front end should already have
1452 made sure that case ranges do not overlap, it is enough to only compare
1453 the CASE_LOW values of each case label. */
1456 compare_case_labels (const void *p1
, const void *p2
)
1458 const_tree
const case1
= *(const_tree
const*)p1
;
1459 const_tree
const case2
= *(const_tree
const*)p2
;
1461 /* The 'default' case label always goes first. */
1462 if (!CASE_LOW (case1
))
1464 else if (!CASE_LOW (case2
))
1467 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
1471 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1474 sort_case_labels (VEC(tree
,heap
)* label_vec
)
1476 VEC_qsort (tree
, label_vec
, compare_case_labels
);
1480 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1483 static enum gimplify_status
1484 gimplify_switch_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1486 tree switch_expr
= *expr_p
;
1487 gimple_seq switch_body_seq
= NULL
;
1488 enum gimplify_status ret
;
1490 ret
= gimplify_expr (&SWITCH_COND (switch_expr
), pre_p
, NULL
, is_gimple_val
,
1492 if (ret
== GS_ERROR
|| ret
== GS_UNHANDLED
)
1495 if (SWITCH_BODY (switch_expr
))
1497 VEC (tree
,heap
) *labels
;
1498 VEC (tree
,heap
) *saved_labels
;
1499 tree default_case
= NULL_TREE
;
1501 gimple gimple_switch
;
1503 /* If someone can be bothered to fill in the labels, they can
1504 be bothered to null out the body too. */
1505 gcc_assert (!SWITCH_LABELS (switch_expr
));
1507 /* save old labels, get new ones from body, then restore the old
1508 labels. Save all the things from the switch body to append after. */
1509 saved_labels
= gimplify_ctxp
->case_labels
;
1510 gimplify_ctxp
->case_labels
= VEC_alloc (tree
, heap
, 8);
1512 gimplify_stmt (&SWITCH_BODY (switch_expr
), &switch_body_seq
);
1513 labels
= gimplify_ctxp
->case_labels
;
1514 gimplify_ctxp
->case_labels
= saved_labels
;
1517 while (i
< VEC_length (tree
, labels
))
1519 tree elt
= VEC_index (tree
, labels
, i
);
1520 tree low
= CASE_LOW (elt
);
1521 bool remove_element
= FALSE
;
1525 /* Discard empty ranges. */
1526 tree high
= CASE_HIGH (elt
);
1527 if (high
&& tree_int_cst_lt (high
, low
))
1528 remove_element
= TRUE
;
1532 /* The default case must be the last label in the list. */
1533 gcc_assert (!default_case
);
1535 remove_element
= TRUE
;
1539 VEC_ordered_remove (tree
, labels
, i
);
1545 if (!VEC_empty (tree
, labels
))
1546 sort_case_labels (labels
);
1550 tree type
= TREE_TYPE (switch_expr
);
1552 /* If the switch has no default label, add one, so that we jump
1553 around the switch body. If the labels already cover the whole
1554 range of type, add the default label pointing to one of the
1556 if (type
== void_type_node
)
1557 type
= TREE_TYPE (SWITCH_COND (switch_expr
));
1559 && INTEGRAL_TYPE_P (type
)
1560 && TYPE_MIN_VALUE (type
)
1561 && TYPE_MAX_VALUE (type
)
1562 && tree_int_cst_equal (CASE_LOW (VEC_index (tree
, labels
, 0)),
1563 TYPE_MIN_VALUE (type
)))
1565 tree low
, high
= CASE_HIGH (VEC_index (tree
, labels
, len
- 1));
1567 high
= CASE_LOW (VEC_index (tree
, labels
, len
- 1));
1568 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (type
)))
1570 for (i
= 1; i
< len
; i
++)
1572 high
= CASE_LOW (VEC_index (tree
, labels
, i
));
1573 low
= CASE_HIGH (VEC_index (tree
, labels
, i
- 1));
1575 low
= CASE_LOW (VEC_index (tree
, labels
, i
- 1));
1576 if ((TREE_INT_CST_LOW (low
) + 1
1577 != TREE_INT_CST_LOW (high
))
1578 || (TREE_INT_CST_HIGH (low
)
1579 + (TREE_INT_CST_LOW (high
) == 0)
1580 != TREE_INT_CST_HIGH (high
)))
1584 default_case
= build3 (CASE_LABEL_EXPR
, void_type_node
,
1585 NULL_TREE
, NULL_TREE
,
1586 CASE_LABEL (VEC_index (tree
,
1596 = build3 (CASE_LABEL_EXPR
, void_type_node
,
1597 NULL_TREE
, NULL_TREE
,
1598 create_artificial_label (UNKNOWN_LOCATION
));
1599 new_default
= gimple_build_label (CASE_LABEL (default_case
));
1600 gimplify_seq_add_stmt (&switch_body_seq
, new_default
);
1604 gimple_switch
= gimple_build_switch_vec (SWITCH_COND (switch_expr
),
1605 default_case
, labels
);
1606 gimplify_seq_add_stmt (pre_p
, gimple_switch
);
1607 gimplify_seq_add_seq (pre_p
, switch_body_seq
);
1608 VEC_free(tree
, heap
, labels
);
1611 gcc_assert (SWITCH_LABELS (switch_expr
));
1617 static enum gimplify_status
1618 gimplify_case_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1620 struct gimplify_ctx
*ctxp
;
1621 gimple gimple_label
;
1623 /* Invalid OpenMP programs can play Duff's Device type games with
1624 #pragma omp parallel. At least in the C front end, we don't
1625 detect such invalid branches until after gimplification. */
1626 for (ctxp
= gimplify_ctxp
; ; ctxp
= ctxp
->prev_context
)
1627 if (ctxp
->case_labels
)
1630 gimple_label
= gimple_build_label (CASE_LABEL (*expr_p
));
1631 VEC_safe_push (tree
, heap
, ctxp
->case_labels
, *expr_p
);
1632 gimplify_seq_add_stmt (pre_p
, gimple_label
);
1637 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1641 build_and_jump (tree
*label_p
)
1643 if (label_p
== NULL
)
1644 /* If there's nowhere to jump, just fall through. */
1647 if (*label_p
== NULL_TREE
)
1649 tree label
= create_artificial_label (UNKNOWN_LOCATION
);
1653 return build1 (GOTO_EXPR
, void_type_node
, *label_p
);
1656 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1657 This also involves building a label to jump to and communicating it to
1658 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1660 static enum gimplify_status
1661 gimplify_exit_expr (tree
*expr_p
)
1663 tree cond
= TREE_OPERAND (*expr_p
, 0);
1666 expr
= build_and_jump (&gimplify_ctxp
->exit_label
);
1667 expr
= build3 (COND_EXPR
, void_type_node
, cond
, expr
, NULL_TREE
);
1673 /* A helper function to be called via walk_tree. Mark all labels under *TP
1674 as being forced. To be called for DECL_INITIAL of static variables. */
1677 force_labels_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1681 if (TREE_CODE (*tp
) == LABEL_DECL
)
1682 FORCED_LABEL (*tp
) = 1;
1687 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1688 different from its canonical type, wrap the whole thing inside a
1689 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1692 The canonical type of a COMPONENT_REF is the type of the field being
1693 referenced--unless the field is a bit-field which can be read directly
1694 in a smaller mode, in which case the canonical type is the
1695 sign-appropriate type corresponding to that mode. */
1698 canonicalize_component_ref (tree
*expr_p
)
1700 tree expr
= *expr_p
;
1703 gcc_assert (TREE_CODE (expr
) == COMPONENT_REF
);
1705 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
1706 type
= TREE_TYPE (get_unwidened (expr
, NULL_TREE
));
1708 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
1710 /* One could argue that all the stuff below is not necessary for
1711 the non-bitfield case and declare it a FE error if type
1712 adjustment would be needed. */
1713 if (TREE_TYPE (expr
) != type
)
1715 #ifdef ENABLE_TYPES_CHECKING
1716 tree old_type
= TREE_TYPE (expr
);
1720 /* We need to preserve qualifiers and propagate them from
1722 type_quals
= TYPE_QUALS (type
)
1723 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1724 if (TYPE_QUALS (type
) != type_quals
)
1725 type
= build_qualified_type (TYPE_MAIN_VARIANT (type
), type_quals
);
1727 /* Set the type of the COMPONENT_REF to the underlying type. */
1728 TREE_TYPE (expr
) = type
;
1730 #ifdef ENABLE_TYPES_CHECKING
1731 /* It is now a FE error, if the conversion from the canonical
1732 type to the original expression type is not useless. */
1733 gcc_assert (useless_type_conversion_p (old_type
, type
));
1738 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1739 to foo, embed that change in the ADDR_EXPR by converting
1744 where L is the lower bound. For simplicity, only do this for constant
1746 The constraint is that the type of &array[L] is trivially convertible
1750 canonicalize_addr_expr (tree
*expr_p
)
1752 tree expr
= *expr_p
;
1753 tree addr_expr
= TREE_OPERAND (expr
, 0);
1754 tree datype
, ddatype
, pddatype
;
1756 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1757 if (!POINTER_TYPE_P (TREE_TYPE (expr
))
1758 || TREE_CODE (addr_expr
) != ADDR_EXPR
)
1761 /* The addr_expr type should be a pointer to an array. */
1762 datype
= TREE_TYPE (TREE_TYPE (addr_expr
));
1763 if (TREE_CODE (datype
) != ARRAY_TYPE
)
1766 /* The pointer to element type shall be trivially convertible to
1767 the expression pointer type. */
1768 ddatype
= TREE_TYPE (datype
);
1769 pddatype
= build_pointer_type (ddatype
);
1770 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)),
1774 /* The lower bound and element sizes must be constant. */
1775 if (!TYPE_SIZE_UNIT (ddatype
)
1776 || TREE_CODE (TYPE_SIZE_UNIT (ddatype
)) != INTEGER_CST
1777 || !TYPE_DOMAIN (datype
) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))
1778 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))) != INTEGER_CST
)
1781 /* All checks succeeded. Build a new node to merge the cast. */
1782 *expr_p
= build4 (ARRAY_REF
, ddatype
, TREE_OPERAND (addr_expr
, 0),
1783 TYPE_MIN_VALUE (TYPE_DOMAIN (datype
)),
1784 NULL_TREE
, NULL_TREE
);
1785 *expr_p
= build1 (ADDR_EXPR
, pddatype
, *expr_p
);
1787 /* We can have stripped a required restrict qualifier above. */
1788 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
1789 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
1792 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1793 underneath as appropriate. */
1795 static enum gimplify_status
1796 gimplify_conversion (tree
*expr_p
)
1799 location_t loc
= EXPR_LOCATION (*expr_p
);
1800 gcc_assert (CONVERT_EXPR_P (*expr_p
));
1802 /* Then strip away all but the outermost conversion. */
1803 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p
, 0));
1805 /* And remove the outermost conversion if it's useless. */
1806 if (tree_ssa_useless_type_conversion (*expr_p
))
1807 *expr_p
= TREE_OPERAND (*expr_p
, 0);
1809 /* Attempt to avoid NOP_EXPR by producing reference to a subtype.
1810 For example this fold (subclass *)&A into &A->subclass avoiding
1811 a need for statement. */
1812 if (CONVERT_EXPR_P (*expr_p
)
1813 && POINTER_TYPE_P (TREE_TYPE (*expr_p
))
1814 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p
, 0)))
1815 && (tem
= maybe_fold_offset_to_address
1816 (EXPR_LOCATION (*expr_p
), TREE_OPERAND (*expr_p
, 0),
1817 integer_zero_node
, TREE_TYPE (*expr_p
))) != NULL_TREE
)
1820 /* If we still have a conversion at the toplevel,
1821 then canonicalize some constructs. */
1822 if (CONVERT_EXPR_P (*expr_p
))
1824 tree sub
= TREE_OPERAND (*expr_p
, 0);
1826 /* If a NOP conversion is changing the type of a COMPONENT_REF
1827 expression, then canonicalize its type now in order to expose more
1828 redundant conversions. */
1829 if (TREE_CODE (sub
) == COMPONENT_REF
)
1830 canonicalize_component_ref (&TREE_OPERAND (*expr_p
, 0));
1832 /* If a NOP conversion is changing a pointer to array of foo
1833 to a pointer to foo, embed that change in the ADDR_EXPR. */
1834 else if (TREE_CODE (sub
) == ADDR_EXPR
)
1835 canonicalize_addr_expr (expr_p
);
1838 /* If we have a conversion to a non-register type force the
1839 use of a VIEW_CONVERT_EXPR instead. */
1840 if (CONVERT_EXPR_P (*expr_p
) && !is_gimple_reg_type (TREE_TYPE (*expr_p
)))
1841 *expr_p
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (*expr_p
),
1842 TREE_OPERAND (*expr_p
, 0));
1847 /* Nonlocal VLAs seen in the current function. */
1848 static struct pointer_set_t
*nonlocal_vlas
;
1850 /* Gimplify a VAR_DECL or PARM_DECL. Returns GS_OK if we expanded a
1851 DECL_VALUE_EXPR, and it's worth re-examining things. */
1853 static enum gimplify_status
1854 gimplify_var_or_parm_decl (tree
*expr_p
)
1856 tree decl
= *expr_p
;
1858 /* ??? If this is a local variable, and it has not been seen in any
1859 outer BIND_EXPR, then it's probably the result of a duplicate
1860 declaration, for which we've already issued an error. It would
1861 be really nice if the front end wouldn't leak these at all.
1862 Currently the only known culprit is C++ destructors, as seen
1863 in g++.old-deja/g++.jason/binding.C. */
1864 if (TREE_CODE (decl
) == VAR_DECL
1865 && !DECL_SEEN_IN_BIND_EXPR_P (decl
)
1866 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)
1867 && decl_function_context (decl
) == current_function_decl
)
1869 gcc_assert (seen_error ());
1873 /* When within an OpenMP context, notice uses of variables. */
1874 if (gimplify_omp_ctxp
&& omp_notice_variable (gimplify_omp_ctxp
, decl
, true))
1877 /* If the decl is an alias for another expression, substitute it now. */
1878 if (DECL_HAS_VALUE_EXPR_P (decl
))
1880 tree value_expr
= DECL_VALUE_EXPR (decl
);
1882 /* For referenced nonlocal VLAs add a decl for debugging purposes
1883 to the current function. */
1884 if (TREE_CODE (decl
) == VAR_DECL
1885 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1886 && nonlocal_vlas
!= NULL
1887 && TREE_CODE (value_expr
) == INDIRECT_REF
1888 && TREE_CODE (TREE_OPERAND (value_expr
, 0)) == VAR_DECL
1889 && decl_function_context (decl
) != current_function_decl
)
1891 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1892 while (ctx
&& ctx
->region_type
== ORT_WORKSHARE
)
1893 ctx
= ctx
->outer_context
;
1894 if (!ctx
&& !pointer_set_insert (nonlocal_vlas
, decl
))
1896 tree copy
= copy_node (decl
), block
;
1898 lang_hooks
.dup_lang_specific_decl (copy
);
1899 SET_DECL_RTL (copy
, 0);
1900 TREE_USED (copy
) = 1;
1901 block
= DECL_INITIAL (current_function_decl
);
1902 DECL_CHAIN (copy
) = BLOCK_VARS (block
);
1903 BLOCK_VARS (block
) = copy
;
1904 SET_DECL_VALUE_EXPR (copy
, unshare_expr (value_expr
));
1905 DECL_HAS_VALUE_EXPR_P (copy
) = 1;
1909 *expr_p
= unshare_expr (value_expr
);
1917 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1921 : min_lval '[' val ']'
1923 | compound_lval '[' val ']'
1924 | compound_lval '.' ID
1926 This is not part of the original SIMPLE definition, which separates
1927 array and member references, but it seems reasonable to handle them
1928 together. Also, this way we don't run into problems with union
1929 aliasing; gcc requires that for accesses through a union to alias, the
1930 union reference must be explicit, which was not always the case when we
1931 were splitting up array and member refs.
1933 PRE_P points to the sequence where side effects that must happen before
1934 *EXPR_P should be stored.
1936 POST_P points to the sequence where side effects that must happen after
1937 *EXPR_P should be stored. */
1939 static enum gimplify_status
1940 gimplify_compound_lval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
1941 fallback_t fallback
)
1944 VEC(tree
,heap
) *stack
;
1945 enum gimplify_status ret
= GS_ALL_DONE
, tret
;
1947 location_t loc
= EXPR_LOCATION (*expr_p
);
1948 tree expr
= *expr_p
;
1950 /* Create a stack of the subexpressions so later we can walk them in
1951 order from inner to outer. */
1952 stack
= VEC_alloc (tree
, heap
, 10);
1954 /* We can handle anything that get_inner_reference can deal with. */
1955 for (p
= expr_p
; ; p
= &TREE_OPERAND (*p
, 0))
1958 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
1959 if (TREE_CODE (*p
) == INDIRECT_REF
)
1960 *p
= fold_indirect_ref_loc (loc
, *p
);
1962 if (handled_component_p (*p
))
1964 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
1965 additional COMPONENT_REFs. */
1966 else if ((TREE_CODE (*p
) == VAR_DECL
|| TREE_CODE (*p
) == PARM_DECL
)
1967 && gimplify_var_or_parm_decl (p
) == GS_OK
)
1972 VEC_safe_push (tree
, heap
, stack
, *p
);
1975 gcc_assert (VEC_length (tree
, stack
));
1977 /* Now STACK is a stack of pointers to all the refs we've walked through
1978 and P points to the innermost expression.
1980 Java requires that we elaborated nodes in source order. That
1981 means we must gimplify the inner expression followed by each of
1982 the indices, in order. But we can't gimplify the inner
1983 expression until we deal with any variable bounds, sizes, or
1984 positions in order to deal with PLACEHOLDER_EXPRs.
1986 So we do this in three steps. First we deal with the annotations
1987 for any variables in the components, then we gimplify the base,
1988 then we gimplify any indices, from left to right. */
1989 for (i
= VEC_length (tree
, stack
) - 1; i
>= 0; i
--)
1991 tree t
= VEC_index (tree
, stack
, i
);
1993 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
1995 /* Gimplify the low bound and element type size and put them into
1996 the ARRAY_REF. If these values are set, they have already been
1998 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2000 tree low
= unshare_expr (array_ref_low_bound (t
));
2001 if (!is_gimple_min_invariant (low
))
2003 TREE_OPERAND (t
, 2) = low
;
2004 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2005 post_p
, is_gimple_reg
,
2007 ret
= MIN (ret
, tret
);
2011 if (!TREE_OPERAND (t
, 3))
2013 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0)));
2014 tree elmt_size
= unshare_expr (array_ref_element_size (t
));
2015 tree factor
= size_int (TYPE_ALIGN_UNIT (elmt_type
));
2017 /* Divide the element size by the alignment of the element
2019 elmt_size
= size_binop_loc (loc
, EXACT_DIV_EXPR
, elmt_size
, factor
);
2021 if (!is_gimple_min_invariant (elmt_size
))
2023 TREE_OPERAND (t
, 3) = elmt_size
;
2024 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
,
2025 post_p
, is_gimple_reg
,
2027 ret
= MIN (ret
, tret
);
2031 else if (TREE_CODE (t
) == COMPONENT_REF
)
2033 /* Set the field offset into T and gimplify it. */
2034 if (!TREE_OPERAND (t
, 2))
2036 tree offset
= unshare_expr (component_ref_field_offset (t
));
2037 tree field
= TREE_OPERAND (t
, 1);
2039 = size_int (DECL_OFFSET_ALIGN (field
) / BITS_PER_UNIT
);
2041 /* Divide the offset by its alignment. */
2042 offset
= size_binop_loc (loc
, EXACT_DIV_EXPR
, offset
, factor
);
2044 if (!is_gimple_min_invariant (offset
))
2046 TREE_OPERAND (t
, 2) = offset
;
2047 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2048 post_p
, is_gimple_reg
,
2050 ret
= MIN (ret
, tret
);
2056 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2057 so as to match the min_lval predicate. Failure to do so may result
2058 in the creation of large aggregate temporaries. */
2059 tret
= gimplify_expr (p
, pre_p
, post_p
, is_gimple_min_lval
,
2060 fallback
| fb_lvalue
);
2061 ret
= MIN (ret
, tret
);
2063 /* And finally, the indices and operands to BIT_FIELD_REF. During this
2064 loop we also remove any useless conversions. */
2065 for (; VEC_length (tree
, stack
) > 0; )
2067 tree t
= VEC_pop (tree
, stack
);
2069 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2071 /* Gimplify the dimension. */
2072 if (!is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
2074 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2075 is_gimple_val
, fb_rvalue
);
2076 ret
= MIN (ret
, tret
);
2079 else if (TREE_CODE (t
) == BIT_FIELD_REF
)
2081 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2082 is_gimple_val
, fb_rvalue
);
2083 ret
= MIN (ret
, tret
);
2084 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2085 is_gimple_val
, fb_rvalue
);
2086 ret
= MIN (ret
, tret
);
2089 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t
, 0));
2091 /* The innermost expression P may have originally had
2092 TREE_SIDE_EFFECTS set which would have caused all the outer
2093 expressions in *EXPR_P leading to P to also have had
2094 TREE_SIDE_EFFECTS set. */
2095 recalculate_side_effects (t
);
2098 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2099 if ((fallback
& fb_rvalue
) && TREE_CODE (*expr_p
) == COMPONENT_REF
)
2101 canonicalize_component_ref (expr_p
);
2104 VEC_free (tree
, heap
, stack
);
2106 gcc_assert (*expr_p
== expr
|| ret
!= GS_ALL_DONE
);
2111 /* Gimplify the self modifying expression pointed to by EXPR_P
2114 PRE_P points to the list where side effects that must happen before
2115 *EXPR_P should be stored.
2117 POST_P points to the list where side effects that must happen after
2118 *EXPR_P should be stored.
2120 WANT_VALUE is nonzero iff we want to use the value of this expression
2121 in another expression. */
2123 static enum gimplify_status
2124 gimplify_self_mod_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2127 enum tree_code code
;
2128 tree lhs
, lvalue
, rhs
, t1
;
2129 gimple_seq post
= NULL
, *orig_post_p
= post_p
;
2131 enum tree_code arith_code
;
2132 enum gimplify_status ret
;
2133 location_t loc
= EXPR_LOCATION (*expr_p
);
2135 code
= TREE_CODE (*expr_p
);
2137 gcc_assert (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
2138 || code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
);
2140 /* Prefix or postfix? */
2141 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
2142 /* Faster to treat as prefix if result is not used. */
2143 postfix
= want_value
;
2147 /* For postfix, make sure the inner expression's post side effects
2148 are executed after side effects from this expression. */
2152 /* Add or subtract? */
2153 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2154 arith_code
= PLUS_EXPR
;
2156 arith_code
= MINUS_EXPR
;
2158 /* Gimplify the LHS into a GIMPLE lvalue. */
2159 lvalue
= TREE_OPERAND (*expr_p
, 0);
2160 ret
= gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
2161 if (ret
== GS_ERROR
)
2164 /* Extract the operands to the arithmetic operation. */
2166 rhs
= TREE_OPERAND (*expr_p
, 1);
2168 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2169 that as the result value and in the postqueue operation. We also
2170 make sure to make lvalue a minimal lval, see
2171 gcc.c-torture/execute/20040313-1.c for an example where this matters. */
2174 if (!is_gimple_min_lval (lvalue
))
2176 mark_addressable (lvalue
);
2177 lvalue
= build_fold_addr_expr_loc (input_location
, lvalue
);
2178 gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
2179 lvalue
= build_fold_indirect_ref_loc (input_location
, lvalue
);
2181 ret
= gimplify_expr (&lhs
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
2182 if (ret
== GS_ERROR
)
2186 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2187 if (POINTER_TYPE_P (TREE_TYPE (lhs
)))
2189 rhs
= fold_convert_loc (loc
, sizetype
, rhs
);
2190 if (arith_code
== MINUS_EXPR
)
2191 rhs
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
2192 arith_code
= POINTER_PLUS_EXPR
;
2195 t1
= build2 (arith_code
, TREE_TYPE (*expr_p
), lhs
, rhs
);
2199 gimplify_assign (lvalue
, t1
, orig_post_p
);
2200 gimplify_seq_add_seq (orig_post_p
, post
);
2206 *expr_p
= build2 (MODIFY_EXPR
, TREE_TYPE (lvalue
), lvalue
, t1
);
2212 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2215 maybe_with_size_expr (tree
*expr_p
)
2217 tree expr
= *expr_p
;
2218 tree type
= TREE_TYPE (expr
);
2221 /* If we've already wrapped this or the type is error_mark_node, we can't do
2223 if (TREE_CODE (expr
) == WITH_SIZE_EXPR
2224 || type
== error_mark_node
)
2227 /* If the size isn't known or is a constant, we have nothing to do. */
2228 size
= TYPE_SIZE_UNIT (type
);
2229 if (!size
|| TREE_CODE (size
) == INTEGER_CST
)
2232 /* Otherwise, make a WITH_SIZE_EXPR. */
2233 size
= unshare_expr (size
);
2234 size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (size
, expr
);
2235 *expr_p
= build2 (WITH_SIZE_EXPR
, type
, expr
, size
);
2239 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2240 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2243 static enum gimplify_status
2244 gimplify_arg (tree
*arg_p
, gimple_seq
*pre_p
, location_t call_location
)
2246 bool (*test
) (tree
);
2249 /* In general, we allow lvalues for function arguments to avoid
2250 extra overhead of copying large aggregates out of even larger
2251 aggregates into temporaries only to copy the temporaries to
2252 the argument list. Make optimizers happy by pulling out to
2253 temporaries those types that fit in registers. */
2254 if (is_gimple_reg_type (TREE_TYPE (*arg_p
)))
2255 test
= is_gimple_val
, fb
= fb_rvalue
;
2257 test
= is_gimple_lvalue
, fb
= fb_either
;
2259 /* If this is a variable sized type, we must remember the size. */
2260 maybe_with_size_expr (arg_p
);
2262 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2263 /* Make sure arguments have the same location as the function call
2265 protected_set_expr_location (*arg_p
, call_location
);
2267 /* There is a sequence point before a function call. Side effects in
2268 the argument list must occur before the actual call. So, when
2269 gimplifying arguments, force gimplify_expr to use an internal
2270 post queue which is then appended to the end of PRE_P. */
2271 return gimplify_expr (arg_p
, pre_p
, NULL
, test
, fb
);
2275 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2276 WANT_VALUE is true if the result of the call is desired. */
2278 static enum gimplify_status
2279 gimplify_call_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
2281 tree fndecl
, parms
, p
;
2282 enum gimplify_status ret
;
2285 bool builtin_va_start_p
= FALSE
;
2286 location_t loc
= EXPR_LOCATION (*expr_p
);
2288 gcc_assert (TREE_CODE (*expr_p
) == CALL_EXPR
);
2290 /* For reliable diagnostics during inlining, it is necessary that
2291 every call_expr be annotated with file and line. */
2292 if (! EXPR_HAS_LOCATION (*expr_p
))
2293 SET_EXPR_LOCATION (*expr_p
, input_location
);
2295 /* This may be a call to a builtin function.
2297 Builtin function calls may be transformed into different
2298 (and more efficient) builtin function calls under certain
2299 circumstances. Unfortunately, gimplification can muck things
2300 up enough that the builtin expanders are not aware that certain
2301 transformations are still valid.
2303 So we attempt transformation/gimplification of the call before
2304 we gimplify the CALL_EXPR. At this time we do not manage to
2305 transform all calls in the same manner as the expanders do, but
2306 we do transform most of them. */
2307 fndecl
= get_callee_fndecl (*expr_p
);
2308 if (fndecl
&& DECL_BUILT_IN (fndecl
))
2310 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2312 if (new_tree
&& new_tree
!= *expr_p
)
2314 /* There was a transformation of this call which computes the
2315 same value, but in a more efficient way. Return and try
2321 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2322 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_VA_START
)
2324 builtin_va_start_p
= TRUE
;
2325 if (call_expr_nargs (*expr_p
) < 2)
2327 error ("too few arguments to function %<va_start%>");
2328 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2332 if (fold_builtin_next_arg (*expr_p
, true))
2334 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2340 /* There is a sequence point before the call, so any side effects in
2341 the calling expression must occur before the actual call. Force
2342 gimplify_expr to use an internal post queue. */
2343 ret
= gimplify_expr (&CALL_EXPR_FN (*expr_p
), pre_p
, NULL
,
2344 is_gimple_call_addr
, fb_rvalue
);
2346 nargs
= call_expr_nargs (*expr_p
);
2348 /* Get argument types for verification. */
2349 fndecl
= get_callee_fndecl (*expr_p
);
2352 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2353 else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p
))))
2354 parms
= TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p
))));
2356 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
2357 p
= DECL_ARGUMENTS (fndecl
);
2362 for (i
= 0; i
< nargs
&& p
; i
++, p
= TREE_CHAIN (p
))
2365 /* If the last argument is __builtin_va_arg_pack () and it is not
2366 passed as a named argument, decrease the number of CALL_EXPR
2367 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2370 && TREE_CODE (CALL_EXPR_ARG (*expr_p
, nargs
- 1)) == CALL_EXPR
)
2372 tree last_arg
= CALL_EXPR_ARG (*expr_p
, nargs
- 1);
2373 tree last_arg_fndecl
= get_callee_fndecl (last_arg
);
2376 && TREE_CODE (last_arg_fndecl
) == FUNCTION_DECL
2377 && DECL_BUILT_IN_CLASS (last_arg_fndecl
) == BUILT_IN_NORMAL
2378 && DECL_FUNCTION_CODE (last_arg_fndecl
) == BUILT_IN_VA_ARG_PACK
)
2380 tree call
= *expr_p
;
2383 *expr_p
= build_call_array_loc (loc
, TREE_TYPE (call
),
2384 CALL_EXPR_FN (call
),
2385 nargs
, CALL_EXPR_ARGP (call
));
2387 /* Copy all CALL_EXPR flags, location and block, except
2388 CALL_EXPR_VA_ARG_PACK flag. */
2389 CALL_EXPR_STATIC_CHAIN (*expr_p
) = CALL_EXPR_STATIC_CHAIN (call
);
2390 CALL_EXPR_TAILCALL (*expr_p
) = CALL_EXPR_TAILCALL (call
);
2391 CALL_EXPR_RETURN_SLOT_OPT (*expr_p
)
2392 = CALL_EXPR_RETURN_SLOT_OPT (call
);
2393 CALL_FROM_THUNK_P (*expr_p
) = CALL_FROM_THUNK_P (call
);
2394 CALL_CANNOT_INLINE_P (*expr_p
) = CALL_CANNOT_INLINE_P (call
);
2395 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (call
));
2396 TREE_BLOCK (*expr_p
) = TREE_BLOCK (call
);
2398 /* Set CALL_EXPR_VA_ARG_PACK. */
2399 CALL_EXPR_VA_ARG_PACK (*expr_p
) = 1;
2403 /* Finally, gimplify the function arguments. */
2406 for (i
= (PUSH_ARGS_REVERSED
? nargs
- 1 : 0);
2407 PUSH_ARGS_REVERSED
? i
>= 0 : i
< nargs
;
2408 PUSH_ARGS_REVERSED
? i
-- : i
++)
2410 enum gimplify_status t
;
2412 /* Avoid gimplifying the second argument to va_start, which needs to
2413 be the plain PARM_DECL. */
2414 if ((i
!= 1) || !builtin_va_start_p
)
2416 t
= gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
2417 EXPR_LOCATION (*expr_p
));
2425 /* Verify the function result. */
2426 if (want_value
&& fndecl
2427 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl
))))
2429 error_at (loc
, "using result of function returning %<void%>");
2433 /* Try this again in case gimplification exposed something. */
2434 if (ret
!= GS_ERROR
)
2436 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2438 if (new_tree
&& new_tree
!= *expr_p
)
2440 /* There was a transformation of this call which computes the
2441 same value, but in a more efficient way. Return and try
2449 *expr_p
= error_mark_node
;
2453 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2454 decl. This allows us to eliminate redundant or useless
2455 calls to "const" functions. */
2456 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
2458 int flags
= call_expr_flags (*expr_p
);
2459 if (flags
& (ECF_CONST
| ECF_PURE
)
2460 /* An infinite loop is considered a side effect. */
2461 && !(flags
& (ECF_LOOPING_CONST_OR_PURE
)))
2462 TREE_SIDE_EFFECTS (*expr_p
) = 0;
2465 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2466 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2467 form and delegate the creation of a GIMPLE_CALL to
2468 gimplify_modify_expr. This is always possible because when
2469 WANT_VALUE is true, the caller wants the result of this call into
2470 a temporary, which means that we will emit an INIT_EXPR in
2471 internal_get_tmp_var which will then be handled by
2472 gimplify_modify_expr. */
2475 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2476 have to do is replicate it as a GIMPLE_CALL tuple. */
2477 gimple_stmt_iterator gsi
;
2478 call
= gimple_build_call_from_tree (*expr_p
);
2479 gimplify_seq_add_stmt (pre_p
, call
);
2480 gsi
= gsi_last (*pre_p
);
2482 *expr_p
= NULL_TREE
;
2488 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2489 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2491 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2492 condition is true or false, respectively. If null, we should generate
2493 our own to skip over the evaluation of this specific expression.
2495 LOCUS is the source location of the COND_EXPR.
2497 This function is the tree equivalent of do_jump.
2499 shortcut_cond_r should only be called by shortcut_cond_expr. */
2502 shortcut_cond_r (tree pred
, tree
*true_label_p
, tree
*false_label_p
,
2505 tree local_label
= NULL_TREE
;
2506 tree t
, expr
= NULL
;
2508 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2509 retain the shortcut semantics. Just insert the gotos here;
2510 shortcut_cond_expr will append the real blocks later. */
2511 if (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2513 location_t new_locus
;
2515 /* Turn if (a && b) into
2517 if (a); else goto no;
2518 if (b) goto yes; else goto no;
2521 if (false_label_p
== NULL
)
2522 false_label_p
= &local_label
;
2524 /* Keep the original source location on the first 'if'. */
2525 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), NULL
, false_label_p
, locus
);
2526 append_to_statement_list (t
, &expr
);
2528 /* Set the source location of the && on the second 'if'. */
2529 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2530 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2532 append_to_statement_list (t
, &expr
);
2534 else if (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2536 location_t new_locus
;
2538 /* Turn if (a || b) into
2541 if (b) goto yes; else goto no;
2544 if (true_label_p
== NULL
)
2545 true_label_p
= &local_label
;
2547 /* Keep the original source location on the first 'if'. */
2548 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), true_label_p
, NULL
, locus
);
2549 append_to_statement_list (t
, &expr
);
2551 /* Set the source location of the || on the second 'if'. */
2552 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2553 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2555 append_to_statement_list (t
, &expr
);
2557 else if (TREE_CODE (pred
) == COND_EXPR
)
2559 location_t new_locus
;
2561 /* As long as we're messing with gotos, turn if (a ? b : c) into
2563 if (b) goto yes; else goto no;
2565 if (c) goto yes; else goto no; */
2567 /* Keep the original source location on the first 'if'. Set the source
2568 location of the ? on the second 'if'. */
2569 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2570 expr
= build3 (COND_EXPR
, void_type_node
, TREE_OPERAND (pred
, 0),
2571 shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
,
2572 false_label_p
, locus
),
2573 shortcut_cond_r (TREE_OPERAND (pred
, 2), true_label_p
,
2574 false_label_p
, new_locus
));
2578 expr
= build3 (COND_EXPR
, void_type_node
, pred
,
2579 build_and_jump (true_label_p
),
2580 build_and_jump (false_label_p
));
2581 SET_EXPR_LOCATION (expr
, locus
);
2586 t
= build1 (LABEL_EXPR
, void_type_node
, local_label
);
2587 append_to_statement_list (t
, &expr
);
2593 /* Given a conditional expression EXPR with short-circuit boolean
2594 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2595 predicate appart into the equivalent sequence of conditionals. */
2598 shortcut_cond_expr (tree expr
)
2600 tree pred
= TREE_OPERAND (expr
, 0);
2601 tree then_
= TREE_OPERAND (expr
, 1);
2602 tree else_
= TREE_OPERAND (expr
, 2);
2603 tree true_label
, false_label
, end_label
, t
;
2605 tree
*false_label_p
;
2606 bool emit_end
, emit_false
, jump_over_else
;
2607 bool then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2608 bool else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2610 /* First do simple transformations. */
2613 /* If there is no 'else', turn
2616 if (a) if (b) then c. */
2617 while (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2619 /* Keep the original source location on the first 'if'. */
2620 location_t locus
= EXPR_LOC_OR_HERE (expr
);
2621 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2622 /* Set the source location of the && on the second 'if'. */
2623 if (EXPR_HAS_LOCATION (pred
))
2624 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2625 then_
= shortcut_cond_expr (expr
);
2626 then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2627 pred
= TREE_OPERAND (pred
, 0);
2628 expr
= build3 (COND_EXPR
, void_type_node
, pred
, then_
, NULL_TREE
);
2629 SET_EXPR_LOCATION (expr
, locus
);
2635 /* If there is no 'then', turn
2638 if (a); else if (b); else d. */
2639 while (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2641 /* Keep the original source location on the first 'if'. */
2642 location_t locus
= EXPR_LOC_OR_HERE (expr
);
2643 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2644 /* Set the source location of the || on the second 'if'. */
2645 if (EXPR_HAS_LOCATION (pred
))
2646 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2647 else_
= shortcut_cond_expr (expr
);
2648 else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2649 pred
= TREE_OPERAND (pred
, 0);
2650 expr
= build3 (COND_EXPR
, void_type_node
, pred
, NULL_TREE
, else_
);
2651 SET_EXPR_LOCATION (expr
, locus
);
2655 /* If we're done, great. */
2656 if (TREE_CODE (pred
) != TRUTH_ANDIF_EXPR
2657 && TREE_CODE (pred
) != TRUTH_ORIF_EXPR
)
2660 /* Otherwise we need to mess with gotos. Change
2663 if (a); else goto no;
2666 and recursively gimplify the condition. */
2668 true_label
= false_label
= end_label
= NULL_TREE
;
2670 /* If our arms just jump somewhere, hijack those labels so we don't
2671 generate jumps to jumps. */
2674 && TREE_CODE (then_
) == GOTO_EXPR
2675 && TREE_CODE (GOTO_DESTINATION (then_
)) == LABEL_DECL
)
2677 true_label
= GOTO_DESTINATION (then_
);
2683 && TREE_CODE (else_
) == GOTO_EXPR
2684 && TREE_CODE (GOTO_DESTINATION (else_
)) == LABEL_DECL
)
2686 false_label
= GOTO_DESTINATION (else_
);
2691 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2693 true_label_p
= &true_label
;
2695 true_label_p
= NULL
;
2697 /* The 'else' branch also needs a label if it contains interesting code. */
2698 if (false_label
|| else_se
)
2699 false_label_p
= &false_label
;
2701 false_label_p
= NULL
;
2703 /* If there was nothing else in our arms, just forward the label(s). */
2704 if (!then_se
&& !else_se
)
2705 return shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2706 EXPR_LOC_OR_HERE (expr
));
2708 /* If our last subexpression already has a terminal label, reuse it. */
2710 t
= expr_last (else_
);
2712 t
= expr_last (then_
);
2715 if (t
&& TREE_CODE (t
) == LABEL_EXPR
)
2716 end_label
= LABEL_EXPR_LABEL (t
);
2718 /* If we don't care about jumping to the 'else' branch, jump to the end
2719 if the condition is false. */
2721 false_label_p
= &end_label
;
2723 /* We only want to emit these labels if we aren't hijacking them. */
2724 emit_end
= (end_label
== NULL_TREE
);
2725 emit_false
= (false_label
== NULL_TREE
);
2727 /* We only emit the jump over the else clause if we have to--if the
2728 then clause may fall through. Otherwise we can wind up with a
2729 useless jump and a useless label at the end of gimplified code,
2730 which will cause us to think that this conditional as a whole
2731 falls through even if it doesn't. If we then inline a function
2732 which ends with such a condition, that can cause us to issue an
2733 inappropriate warning about control reaching the end of a
2734 non-void function. */
2735 jump_over_else
= block_may_fallthru (then_
);
2737 pred
= shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2738 EXPR_LOC_OR_HERE (expr
));
2741 append_to_statement_list (pred
, &expr
);
2743 append_to_statement_list (then_
, &expr
);
2748 tree last
= expr_last (expr
);
2749 t
= build_and_jump (&end_label
);
2750 if (EXPR_HAS_LOCATION (last
))
2751 SET_EXPR_LOCATION (t
, EXPR_LOCATION (last
));
2752 append_to_statement_list (t
, &expr
);
2756 t
= build1 (LABEL_EXPR
, void_type_node
, false_label
);
2757 append_to_statement_list (t
, &expr
);
2759 append_to_statement_list (else_
, &expr
);
2761 if (emit_end
&& end_label
)
2763 t
= build1 (LABEL_EXPR
, void_type_node
, end_label
);
2764 append_to_statement_list (t
, &expr
);
2770 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2773 gimple_boolify (tree expr
)
2775 tree type
= TREE_TYPE (expr
);
2776 location_t loc
= EXPR_LOCATION (expr
);
2778 if (TREE_CODE (expr
) == NE_EXPR
2779 && TREE_CODE (TREE_OPERAND (expr
, 0)) == CALL_EXPR
2780 && integer_zerop (TREE_OPERAND (expr
, 1)))
2782 tree call
= TREE_OPERAND (expr
, 0);
2783 tree fn
= get_callee_fndecl (call
);
2785 /* For __builtin_expect ((long) (x), y) recurse into x as well
2786 if x is truth_value_p. */
2788 && DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2789 && DECL_FUNCTION_CODE (fn
) == BUILT_IN_EXPECT
2790 && call_expr_nargs (call
) == 2)
2792 tree arg
= CALL_EXPR_ARG (call
, 0);
2795 if (TREE_CODE (arg
) == NOP_EXPR
2796 && TREE_TYPE (arg
) == TREE_TYPE (call
))
2797 arg
= TREE_OPERAND (arg
, 0);
2798 if (truth_value_p (TREE_CODE (arg
)))
2800 arg
= gimple_boolify (arg
);
2801 CALL_EXPR_ARG (call
, 0)
2802 = fold_convert_loc (loc
, TREE_TYPE (call
), arg
);
2808 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
2811 switch (TREE_CODE (expr
))
2813 case TRUTH_AND_EXPR
:
2815 case TRUTH_XOR_EXPR
:
2816 case TRUTH_ANDIF_EXPR
:
2817 case TRUTH_ORIF_EXPR
:
2818 /* Also boolify the arguments of truth exprs. */
2819 TREE_OPERAND (expr
, 1) = gimple_boolify (TREE_OPERAND (expr
, 1));
2822 case TRUTH_NOT_EXPR
:
2823 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
2826 case EQ_EXPR
: case NE_EXPR
:
2827 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2828 /* These expressions always produce boolean results. */
2829 TREE_TYPE (expr
) = boolean_type_node
;
2833 /* Other expressions that get here must have boolean values, but
2834 might need to be converted to the appropriate mode. */
2835 return fold_convert_loc (loc
, boolean_type_node
, expr
);
2839 /* Given a conditional expression *EXPR_P without side effects, gimplify
2840 its operands. New statements are inserted to PRE_P. */
2842 static enum gimplify_status
2843 gimplify_pure_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
)
2845 tree expr
= *expr_p
, cond
;
2846 enum gimplify_status ret
, tret
;
2847 enum tree_code code
;
2849 cond
= gimple_boolify (COND_EXPR_COND (expr
));
2851 /* We need to handle && and || specially, as their gimplification
2852 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
2853 code
= TREE_CODE (cond
);
2854 if (code
== TRUTH_ANDIF_EXPR
)
2855 TREE_SET_CODE (cond
, TRUTH_AND_EXPR
);
2856 else if (code
== TRUTH_ORIF_EXPR
)
2857 TREE_SET_CODE (cond
, TRUTH_OR_EXPR
);
2858 ret
= gimplify_expr (&cond
, pre_p
, NULL
, is_gimple_condexpr
, fb_rvalue
);
2859 COND_EXPR_COND (*expr_p
) = cond
;
2861 tret
= gimplify_expr (&COND_EXPR_THEN (expr
), pre_p
, NULL
,
2862 is_gimple_val
, fb_rvalue
);
2863 ret
= MIN (ret
, tret
);
2864 tret
= gimplify_expr (&COND_EXPR_ELSE (expr
), pre_p
, NULL
,
2865 is_gimple_val
, fb_rvalue
);
2867 return MIN (ret
, tret
);
2870 /* Returns true if evaluating EXPR could trap.
2871 EXPR is GENERIC, while tree_could_trap_p can be called
2875 generic_expr_could_trap_p (tree expr
)
2879 if (!expr
|| is_gimple_val (expr
))
2882 if (!EXPR_P (expr
) || tree_could_trap_p (expr
))
2885 n
= TREE_OPERAND_LENGTH (expr
);
2886 for (i
= 0; i
< n
; i
++)
2887 if (generic_expr_could_trap_p (TREE_OPERAND (expr
, i
)))
2893 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2902 The second form is used when *EXPR_P is of type void.
2904 PRE_P points to the list where side effects that must happen before
2905 *EXPR_P should be stored. */
2907 static enum gimplify_status
2908 gimplify_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
, fallback_t fallback
)
2910 tree expr
= *expr_p
;
2911 tree type
= TREE_TYPE (expr
);
2912 location_t loc
= EXPR_LOCATION (expr
);
2913 tree tmp
, arm1
, arm2
;
2914 enum gimplify_status ret
;
2915 tree label_true
, label_false
, label_cont
;
2916 bool have_then_clause_p
, have_else_clause_p
;
2918 enum tree_code pred_code
;
2919 gimple_seq seq
= NULL
;
2921 /* If this COND_EXPR has a value, copy the values into a temporary within
2923 if (!VOID_TYPE_P (type
))
2925 tree then_
= TREE_OPERAND (expr
, 1), else_
= TREE_OPERAND (expr
, 2);
2928 /* If either an rvalue is ok or we do not require an lvalue, create the
2929 temporary. But we cannot do that if the type is addressable. */
2930 if (((fallback
& fb_rvalue
) || !(fallback
& fb_lvalue
))
2931 && !TREE_ADDRESSABLE (type
))
2933 if (gimplify_ctxp
->allow_rhs_cond_expr
2934 /* If either branch has side effects or could trap, it can't be
2935 evaluated unconditionally. */
2936 && !TREE_SIDE_EFFECTS (then_
)
2937 && !generic_expr_could_trap_p (then_
)
2938 && !TREE_SIDE_EFFECTS (else_
)
2939 && !generic_expr_could_trap_p (else_
))
2940 return gimplify_pure_cond_expr (expr_p
, pre_p
);
2942 tmp
= create_tmp_var (type
, "iftmp");
2946 /* Otherwise, only create and copy references to the values. */
2949 type
= build_pointer_type (type
);
2951 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
2952 then_
= build_fold_addr_expr_loc (loc
, then_
);
2954 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
2955 else_
= build_fold_addr_expr_loc (loc
, else_
);
2958 = build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0), then_
, else_
);
2960 tmp
= create_tmp_var (type
, "iftmp");
2961 result
= build_simple_mem_ref_loc (loc
, tmp
);
2964 /* Build the new then clause, `tmp = then_;'. But don't build the
2965 assignment if the value is void; in C++ it can be if it's a throw. */
2966 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
2967 TREE_OPERAND (expr
, 1) = build2 (MODIFY_EXPR
, type
, tmp
, then_
);
2969 /* Similarly, build the new else clause, `tmp = else_;'. */
2970 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
2971 TREE_OPERAND (expr
, 2) = build2 (MODIFY_EXPR
, type
, tmp
, else_
);
2973 TREE_TYPE (expr
) = void_type_node
;
2974 recalculate_side_effects (expr
);
2976 /* Move the COND_EXPR to the prequeue. */
2977 gimplify_stmt (&expr
, pre_p
);
2983 /* Make sure the condition has BOOLEAN_TYPE. */
2984 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
2986 /* Break apart && and || conditions. */
2987 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ANDIF_EXPR
2988 || TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ORIF_EXPR
)
2990 expr
= shortcut_cond_expr (expr
);
2992 if (expr
!= *expr_p
)
2996 /* We can't rely on gimplify_expr to re-gimplify the expanded
2997 form properly, as cleanups might cause the target labels to be
2998 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
2999 set up a conditional context. */
3000 gimple_push_condition ();
3001 gimplify_stmt (expr_p
, &seq
);
3002 gimple_pop_condition (pre_p
);
3003 gimple_seq_add_seq (pre_p
, seq
);
3009 /* Now do the normal gimplification. */
3011 /* Gimplify condition. */
3012 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, NULL
, is_gimple_condexpr
,
3014 if (ret
== GS_ERROR
)
3016 gcc_assert (TREE_OPERAND (expr
, 0) != NULL_TREE
);
3018 gimple_push_condition ();
3020 have_then_clause_p
= have_else_clause_p
= false;
3021 if (TREE_OPERAND (expr
, 1) != NULL
3022 && TREE_CODE (TREE_OPERAND (expr
, 1)) == GOTO_EXPR
3023 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 1))) == LABEL_DECL
3024 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 1)))
3025 == current_function_decl
)
3026 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3027 have different locations, otherwise we end up with incorrect
3028 location information on the branches. */
3030 || !EXPR_HAS_LOCATION (expr
)
3031 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 1))
3032 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 1))))
3034 label_true
= GOTO_DESTINATION (TREE_OPERAND (expr
, 1));
3035 have_then_clause_p
= true;
3038 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
3039 if (TREE_OPERAND (expr
, 2) != NULL
3040 && TREE_CODE (TREE_OPERAND (expr
, 2)) == GOTO_EXPR
3041 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 2))) == LABEL_DECL
3042 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 2)))
3043 == current_function_decl
)
3044 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3045 have different locations, otherwise we end up with incorrect
3046 location information on the branches. */
3048 || !EXPR_HAS_LOCATION (expr
)
3049 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 2))
3050 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 2))))
3052 label_false
= GOTO_DESTINATION (TREE_OPERAND (expr
, 2));
3053 have_else_clause_p
= true;
3056 label_false
= create_artificial_label (UNKNOWN_LOCATION
);
3058 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr
), &pred_code
, &arm1
,
3061 gimple_cond
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
,
3064 gimplify_seq_add_stmt (&seq
, gimple_cond
);
3065 label_cont
= NULL_TREE
;
3066 if (!have_then_clause_p
)
3068 /* For if (...) {} else { code; } put label_true after
3070 if (TREE_OPERAND (expr
, 1) == NULL_TREE
3071 && !have_else_clause_p
3072 && TREE_OPERAND (expr
, 2) != NULL_TREE
)
3073 label_cont
= label_true
;
3076 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_true
));
3077 have_then_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 1), &seq
);
3078 /* For if (...) { code; } else {} or
3079 if (...) { code; } else goto label; or
3080 if (...) { code; return; } else { ... }
3081 label_cont isn't needed. */
3082 if (!have_else_clause_p
3083 && TREE_OPERAND (expr
, 2) != NULL_TREE
3084 && gimple_seq_may_fallthru (seq
))
3087 label_cont
= create_artificial_label (UNKNOWN_LOCATION
);
3089 g
= gimple_build_goto (label_cont
);
3091 /* GIMPLE_COND's are very low level; they have embedded
3092 gotos. This particular embedded goto should not be marked
3093 with the location of the original COND_EXPR, as it would
3094 correspond to the COND_EXPR's condition, not the ELSE or the
3095 THEN arms. To avoid marking it with the wrong location, flag
3096 it as "no location". */
3097 gimple_set_do_not_emit_location (g
);
3099 gimplify_seq_add_stmt (&seq
, g
);
3103 if (!have_else_clause_p
)
3105 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_false
));
3106 have_else_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 2), &seq
);
3109 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_cont
));
3111 gimple_pop_condition (pre_p
);
3112 gimple_seq_add_seq (pre_p
, seq
);
3114 if (ret
== GS_ERROR
)
3116 else if (have_then_clause_p
|| have_else_clause_p
)
3120 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3121 expr
= TREE_OPERAND (expr
, 0);
3122 gimplify_stmt (&expr
, pre_p
);
3129 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3130 to be marked addressable.
3132 We cannot rely on such an expression being directly markable if a temporary
3133 has been created by the gimplification. In this case, we create another
3134 temporary and initialize it with a copy, which will become a store after we
3135 mark it addressable. This can happen if the front-end passed us something
3136 that it could not mark addressable yet, like a Fortran pass-by-reference
3137 parameter (int) floatvar. */
3140 prepare_gimple_addressable (tree
*expr_p
, gimple_seq
*seq_p
)
3142 while (handled_component_p (*expr_p
))
3143 expr_p
= &TREE_OPERAND (*expr_p
, 0);
3144 if (is_gimple_reg (*expr_p
))
3145 *expr_p
= get_initialized_tmp_var (*expr_p
, seq_p
, NULL
);
3148 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3149 a call to __builtin_memcpy. */
3151 static enum gimplify_status
3152 gimplify_modify_expr_to_memcpy (tree
*expr_p
, tree size
, bool want_value
,
3155 tree t
, to
, to_ptr
, from
, from_ptr
;
3157 location_t loc
= EXPR_LOCATION (*expr_p
);
3159 to
= TREE_OPERAND (*expr_p
, 0);
3160 from
= TREE_OPERAND (*expr_p
, 1);
3162 /* Mark the RHS addressable. Beware that it may not be possible to do so
3163 directly if a temporary has been created by the gimplification. */
3164 prepare_gimple_addressable (&from
, seq_p
);
3166 mark_addressable (from
);
3167 from_ptr
= build_fold_addr_expr_loc (loc
, from
);
3168 gimplify_arg (&from_ptr
, seq_p
, loc
);
3170 mark_addressable (to
);
3171 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3172 gimplify_arg (&to_ptr
, seq_p
, loc
);
3174 t
= implicit_built_in_decls
[BUILT_IN_MEMCPY
];
3176 gs
= gimple_build_call (t
, 3, to_ptr
, from_ptr
, size
);
3180 /* tmp = memcpy() */
3181 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3182 gimple_call_set_lhs (gs
, t
);
3183 gimplify_seq_add_stmt (seq_p
, gs
);
3185 *expr_p
= build_simple_mem_ref (t
);
3189 gimplify_seq_add_stmt (seq_p
, gs
);
3194 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3195 a call to __builtin_memset. In this case we know that the RHS is
3196 a CONSTRUCTOR with an empty element list. */
3198 static enum gimplify_status
3199 gimplify_modify_expr_to_memset (tree
*expr_p
, tree size
, bool want_value
,
3202 tree t
, from
, to
, to_ptr
;
3204 location_t loc
= EXPR_LOCATION (*expr_p
);
3206 /* Assert our assumptions, to abort instead of producing wrong code
3207 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3208 not be immediately exposed. */
3209 from
= TREE_OPERAND (*expr_p
, 1);
3210 if (TREE_CODE (from
) == WITH_SIZE_EXPR
)
3211 from
= TREE_OPERAND (from
, 0);
3213 gcc_assert (TREE_CODE (from
) == CONSTRUCTOR
3214 && VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (from
)));
3217 to
= TREE_OPERAND (*expr_p
, 0);
3219 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3220 gimplify_arg (&to_ptr
, seq_p
, loc
);
3221 t
= implicit_built_in_decls
[BUILT_IN_MEMSET
];
3223 gs
= gimple_build_call (t
, 3, to_ptr
, integer_zero_node
, size
);
3227 /* tmp = memset() */
3228 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3229 gimple_call_set_lhs (gs
, t
);
3230 gimplify_seq_add_stmt (seq_p
, gs
);
3232 *expr_p
= build1 (INDIRECT_REF
, TREE_TYPE (to
), t
);
3236 gimplify_seq_add_stmt (seq_p
, gs
);
3241 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3242 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3243 assignment. Returns non-null if we detect a potential overlap. */
3245 struct gimplify_init_ctor_preeval_data
3247 /* The base decl of the lhs object. May be NULL, in which case we
3248 have to assume the lhs is indirect. */
3251 /* The alias set of the lhs object. */
3252 alias_set_type lhs_alias_set
;
3256 gimplify_init_ctor_preeval_1 (tree
*tp
, int *walk_subtrees
, void *xdata
)
3258 struct gimplify_init_ctor_preeval_data
*data
3259 = (struct gimplify_init_ctor_preeval_data
*) xdata
;
3262 /* If we find the base object, obviously we have overlap. */
3263 if (data
->lhs_base_decl
== t
)
3266 /* If the constructor component is indirect, determine if we have a
3267 potential overlap with the lhs. The only bits of information we
3268 have to go on at this point are addressability and alias sets. */
3269 if ((INDIRECT_REF_P (t
)
3270 || TREE_CODE (t
) == MEM_REF
)
3271 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3272 && alias_sets_conflict_p (data
->lhs_alias_set
, get_alias_set (t
)))
3275 /* If the constructor component is a call, determine if it can hide a
3276 potential overlap with the lhs through an INDIRECT_REF like above.
3277 ??? Ugh - this is completely broken. In fact this whole analysis
3278 doesn't look conservative. */
3279 if (TREE_CODE (t
) == CALL_EXPR
)
3281 tree type
, fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t
)));
3283 for (type
= TYPE_ARG_TYPES (fntype
); type
; type
= TREE_CHAIN (type
))
3284 if (POINTER_TYPE_P (TREE_VALUE (type
))
3285 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3286 && alias_sets_conflict_p (data
->lhs_alias_set
,
3288 (TREE_TYPE (TREE_VALUE (type
)))))
3292 if (IS_TYPE_OR_DECL_P (t
))
3297 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3298 force values that overlap with the lhs (as described by *DATA)
3299 into temporaries. */
3302 gimplify_init_ctor_preeval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3303 struct gimplify_init_ctor_preeval_data
*data
)
3305 enum gimplify_status one
;
3307 /* If the value is constant, then there's nothing to pre-evaluate. */
3308 if (TREE_CONSTANT (*expr_p
))
3310 /* Ensure it does not have side effects, it might contain a reference to
3311 the object we're initializing. */
3312 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p
));
3316 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3317 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p
)))
3320 /* Recurse for nested constructors. */
3321 if (TREE_CODE (*expr_p
) == CONSTRUCTOR
)
3323 unsigned HOST_WIDE_INT ix
;
3324 constructor_elt
*ce
;
3325 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (*expr_p
);
3327 FOR_EACH_VEC_ELT (constructor_elt
, v
, ix
, ce
)
3328 gimplify_init_ctor_preeval (&ce
->value
, pre_p
, post_p
, data
);
3333 /* If this is a variable sized type, we must remember the size. */
3334 maybe_with_size_expr (expr_p
);
3336 /* Gimplify the constructor element to something appropriate for the rhs
3337 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3338 the gimplifier will consider this a store to memory. Doing this
3339 gimplification now means that we won't have to deal with complicated
3340 language-specific trees, nor trees like SAVE_EXPR that can induce
3341 exponential search behavior. */
3342 one
= gimplify_expr (expr_p
, pre_p
, post_p
, is_gimple_mem_rhs
, fb_rvalue
);
3343 if (one
== GS_ERROR
)
3349 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3350 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3351 always be true for all scalars, since is_gimple_mem_rhs insists on a
3352 temporary variable for them. */
3353 if (DECL_P (*expr_p
))
3356 /* If this is of variable size, we have no choice but to assume it doesn't
3357 overlap since we can't make a temporary for it. */
3358 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p
))) != INTEGER_CST
)
3361 /* Otherwise, we must search for overlap ... */
3362 if (!walk_tree (expr_p
, gimplify_init_ctor_preeval_1
, data
, NULL
))
3365 /* ... and if found, force the value into a temporary. */
3366 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
3369 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3370 a RANGE_EXPR in a CONSTRUCTOR for an array.
3374 object[var] = value;
3381 We increment var _after_ the loop exit check because we might otherwise
3382 fail if upper == TYPE_MAX_VALUE (type for upper).
3384 Note that we never have to deal with SAVE_EXPRs here, because this has
3385 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3387 static void gimplify_init_ctor_eval (tree
, VEC(constructor_elt
,gc
) *,
3388 gimple_seq
*, bool);
3391 gimplify_init_ctor_eval_range (tree object
, tree lower
, tree upper
,
3392 tree value
, tree array_elt_type
,
3393 gimple_seq
*pre_p
, bool cleared
)
3395 tree loop_entry_label
, loop_exit_label
, fall_thru_label
;
3396 tree var
, var_type
, cref
, tmp
;
3398 loop_entry_label
= create_artificial_label (UNKNOWN_LOCATION
);
3399 loop_exit_label
= create_artificial_label (UNKNOWN_LOCATION
);
3400 fall_thru_label
= create_artificial_label (UNKNOWN_LOCATION
);
3402 /* Create and initialize the index variable. */
3403 var_type
= TREE_TYPE (upper
);
3404 var
= create_tmp_var (var_type
, NULL
);
3405 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, lower
));
3407 /* Add the loop entry label. */
3408 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_entry_label
));
3410 /* Build the reference. */
3411 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3412 var
, NULL_TREE
, NULL_TREE
);
3414 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3415 the store. Otherwise just assign value to the reference. */
3417 if (TREE_CODE (value
) == CONSTRUCTOR
)
3418 /* NB we might have to call ourself recursively through
3419 gimplify_init_ctor_eval if the value is a constructor. */
3420 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3423 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (cref
, value
));
3425 /* We exit the loop when the index var is equal to the upper bound. */
3426 gimplify_seq_add_stmt (pre_p
,
3427 gimple_build_cond (EQ_EXPR
, var
, upper
,
3428 loop_exit_label
, fall_thru_label
));
3430 gimplify_seq_add_stmt (pre_p
, gimple_build_label (fall_thru_label
));
3432 /* Otherwise, increment the index var... */
3433 tmp
= build2 (PLUS_EXPR
, var_type
, var
,
3434 fold_convert (var_type
, integer_one_node
));
3435 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, tmp
));
3437 /* ...and jump back to the loop entry. */
3438 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (loop_entry_label
));
3440 /* Add the loop exit label. */
3441 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_exit_label
));
3444 /* Return true if FDECL is accessing a field that is zero sized. */
3447 zero_sized_field_decl (const_tree fdecl
)
3449 if (TREE_CODE (fdecl
) == FIELD_DECL
&& DECL_SIZE (fdecl
)
3450 && integer_zerop (DECL_SIZE (fdecl
)))
3455 /* Return true if TYPE is zero sized. */
3458 zero_sized_type (const_tree type
)
3460 if (AGGREGATE_TYPE_P (type
) && TYPE_SIZE (type
)
3461 && integer_zerop (TYPE_SIZE (type
)))
3466 /* A subroutine of gimplify_init_constructor. Generate individual
3467 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3468 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3469 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3473 gimplify_init_ctor_eval (tree object
, VEC(constructor_elt
,gc
) *elts
,
3474 gimple_seq
*pre_p
, bool cleared
)
3476 tree array_elt_type
= NULL
;
3477 unsigned HOST_WIDE_INT ix
;
3478 tree purpose
, value
;
3480 if (TREE_CODE (TREE_TYPE (object
)) == ARRAY_TYPE
)
3481 array_elt_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object
)));
3483 FOR_EACH_CONSTRUCTOR_ELT (elts
, ix
, purpose
, value
)
3487 /* NULL values are created above for gimplification errors. */
3491 if (cleared
&& initializer_zerop (value
))
3494 /* ??? Here's to hoping the front end fills in all of the indices,
3495 so we don't have to figure out what's missing ourselves. */
3496 gcc_assert (purpose
);
3498 /* Skip zero-sized fields, unless value has side-effects. This can
3499 happen with calls to functions returning a zero-sized type, which
3500 we shouldn't discard. As a number of downstream passes don't
3501 expect sets of zero-sized fields, we rely on the gimplification of
3502 the MODIFY_EXPR we make below to drop the assignment statement. */
3503 if (! TREE_SIDE_EFFECTS (value
) && zero_sized_field_decl (purpose
))
3506 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3508 if (TREE_CODE (purpose
) == RANGE_EXPR
)
3510 tree lower
= TREE_OPERAND (purpose
, 0);
3511 tree upper
= TREE_OPERAND (purpose
, 1);
3513 /* If the lower bound is equal to upper, just treat it as if
3514 upper was the index. */
3515 if (simple_cst_equal (lower
, upper
))
3519 gimplify_init_ctor_eval_range (object
, lower
, upper
, value
,
3520 array_elt_type
, pre_p
, cleared
);
3527 /* Do not use bitsizetype for ARRAY_REF indices. */
3528 if (TYPE_DOMAIN (TREE_TYPE (object
)))
3529 purpose
= fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object
))),
3531 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3532 purpose
, NULL_TREE
, NULL_TREE
);
3536 gcc_assert (TREE_CODE (purpose
) == FIELD_DECL
);
3537 cref
= build3 (COMPONENT_REF
, TREE_TYPE (purpose
),
3538 unshare_expr (object
), purpose
, NULL_TREE
);
3541 if (TREE_CODE (value
) == CONSTRUCTOR
3542 && TREE_CODE (TREE_TYPE (value
)) != VECTOR_TYPE
)
3543 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3547 tree init
= build2 (INIT_EXPR
, TREE_TYPE (cref
), cref
, value
);
3548 gimplify_and_add (init
, pre_p
);
3555 /* Returns the appropriate RHS predicate for this LHS. */
3558 rhs_predicate_for (tree lhs
)
3560 if (is_gimple_reg (lhs
))
3561 return is_gimple_reg_rhs_or_call
;
3563 return is_gimple_mem_rhs_or_call
;
3566 /* Gimplify a C99 compound literal expression. This just means adding
3567 the DECL_EXPR before the current statement and using its anonymous
3570 static enum gimplify_status
3571 gimplify_compound_literal_expr (tree
*expr_p
, gimple_seq
*pre_p
)
3573 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p
);
3574 tree decl
= DECL_EXPR_DECL (decl_s
);
3575 /* Mark the decl as addressable if the compound literal
3576 expression is addressable now, otherwise it is marked too late
3577 after we gimplify the initialization expression. */
3578 if (TREE_ADDRESSABLE (*expr_p
))
3579 TREE_ADDRESSABLE (decl
) = 1;
3581 /* Preliminarily mark non-addressed complex variables as eligible
3582 for promotion to gimple registers. We'll transform their uses
3584 if ((TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
3585 || TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
)
3586 && !TREE_THIS_VOLATILE (decl
)
3587 && !needs_to_live_in_memory (decl
))
3588 DECL_GIMPLE_REG_P (decl
) = 1;
3590 /* This decl isn't mentioned in the enclosing block, so add it to the
3591 list of temps. FIXME it seems a bit of a kludge to say that
3592 anonymous artificial vars aren't pushed, but everything else is. */
3593 if (DECL_NAME (decl
) == NULL_TREE
&& !DECL_SEEN_IN_BIND_EXPR_P (decl
))
3594 gimple_add_tmp_var (decl
);
3596 gimplify_and_add (decl_s
, pre_p
);
3601 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3602 return a new CONSTRUCTOR if something changed. */
3605 optimize_compound_literals_in_ctor (tree orig_ctor
)
3607 tree ctor
= orig_ctor
;
3608 VEC(constructor_elt
,gc
) *elts
= CONSTRUCTOR_ELTS (ctor
);
3609 unsigned int idx
, num
= VEC_length (constructor_elt
, elts
);
3611 for (idx
= 0; idx
< num
; idx
++)
3613 tree value
= VEC_index (constructor_elt
, elts
, idx
)->value
;
3614 tree newval
= value
;
3615 if (TREE_CODE (value
) == CONSTRUCTOR
)
3616 newval
= optimize_compound_literals_in_ctor (value
);
3617 else if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
3619 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (value
);
3620 tree decl
= DECL_EXPR_DECL (decl_s
);
3621 tree init
= DECL_INITIAL (decl
);
3623 if (!TREE_ADDRESSABLE (value
)
3624 && !TREE_ADDRESSABLE (decl
)
3626 newval
= optimize_compound_literals_in_ctor (init
);
3628 if (newval
== value
)
3631 if (ctor
== orig_ctor
)
3633 ctor
= copy_node (orig_ctor
);
3634 CONSTRUCTOR_ELTS (ctor
) = VEC_copy (constructor_elt
, gc
, elts
);
3635 elts
= CONSTRUCTOR_ELTS (ctor
);
3637 VEC_index (constructor_elt
, elts
, idx
)->value
= newval
;
3644 /* A subroutine of gimplify_modify_expr. Break out elements of a
3645 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3647 Note that we still need to clear any elements that don't have explicit
3648 initializers, so if not all elements are initialized we keep the
3649 original MODIFY_EXPR, we just remove all of the constructor elements.
3651 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3652 GS_ERROR if we would have to create a temporary when gimplifying
3653 this constructor. Otherwise, return GS_OK.
3655 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3657 static enum gimplify_status
3658 gimplify_init_constructor (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3659 bool want_value
, bool notify_temp_creation
)
3661 tree object
, ctor
, type
;
3662 enum gimplify_status ret
;
3663 VEC(constructor_elt
,gc
) *elts
;
3665 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == CONSTRUCTOR
);
3667 if (!notify_temp_creation
)
3669 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
3670 is_gimple_lvalue
, fb_lvalue
);
3671 if (ret
== GS_ERROR
)
3675 object
= TREE_OPERAND (*expr_p
, 0);
3676 ctor
= TREE_OPERAND (*expr_p
, 1) =
3677 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p
, 1));
3678 type
= TREE_TYPE (ctor
);
3679 elts
= CONSTRUCTOR_ELTS (ctor
);
3682 switch (TREE_CODE (type
))
3686 case QUAL_UNION_TYPE
:
3689 struct gimplify_init_ctor_preeval_data preeval_data
;
3690 HOST_WIDE_INT num_type_elements
, num_ctor_elements
;
3691 HOST_WIDE_INT num_nonzero_elements
;
3692 bool cleared
, valid_const_initializer
;
3694 /* Aggregate types must lower constructors to initialization of
3695 individual elements. The exception is that a CONSTRUCTOR node
3696 with no elements indicates zero-initialization of the whole. */
3697 if (VEC_empty (constructor_elt
, elts
))
3699 if (notify_temp_creation
)
3704 /* Fetch information about the constructor to direct later processing.
3705 We might want to make static versions of it in various cases, and
3706 can only do so if it known to be a valid constant initializer. */
3707 valid_const_initializer
3708 = categorize_ctor_elements (ctor
, &num_nonzero_elements
,
3709 &num_ctor_elements
, &cleared
);
3711 /* If a const aggregate variable is being initialized, then it
3712 should never be a lose to promote the variable to be static. */
3713 if (valid_const_initializer
3714 && num_nonzero_elements
> 1
3715 && TREE_READONLY (object
)
3716 && TREE_CODE (object
) == VAR_DECL
3717 && (flag_merge_constants
>= 2 || !TREE_ADDRESSABLE (object
)))
3719 if (notify_temp_creation
)
3721 DECL_INITIAL (object
) = ctor
;
3722 TREE_STATIC (object
) = 1;
3723 if (!DECL_NAME (object
))
3724 DECL_NAME (object
) = create_tmp_var_name ("C");
3725 walk_tree (&DECL_INITIAL (object
), force_labels_r
, NULL
, NULL
);
3727 /* ??? C++ doesn't automatically append a .<number> to the
3728 assembler name, and even when it does, it looks a FE private
3729 data structures to figure out what that number should be,
3730 which are not set for this variable. I suppose this is
3731 important for local statics for inline functions, which aren't
3732 "local" in the object file sense. So in order to get a unique
3733 TU-local symbol, we must invoke the lhd version now. */
3734 lhd_set_decl_assembler_name (object
);
3736 *expr_p
= NULL_TREE
;
3740 /* If there are "lots" of initialized elements, even discounting
3741 those that are not address constants (and thus *must* be
3742 computed at runtime), then partition the constructor into
3743 constant and non-constant parts. Block copy the constant
3744 parts in, then generate code for the non-constant parts. */
3745 /* TODO. There's code in cp/typeck.c to do this. */
3747 num_type_elements
= count_type_elements (type
, true);
3749 /* If count_type_elements could not determine number of type elements
3750 for a constant-sized object, assume clearing is needed.
3751 Don't do this for variable-sized objects, as store_constructor
3752 will ignore the clearing of variable-sized objects. */
3753 if (num_type_elements
< 0 && int_size_in_bytes (type
) >= 0)
3755 /* If there are "lots" of zeros, then block clear the object first. */
3756 else if (num_type_elements
- num_nonzero_elements
3757 > CLEAR_RATIO (optimize_function_for_speed_p (cfun
))
3758 && num_nonzero_elements
< num_type_elements
/4)
3760 /* ??? This bit ought not be needed. For any element not present
3761 in the initializer, we should simply set them to zero. Except
3762 we'd need to *find* the elements that are not present, and that
3763 requires trickery to avoid quadratic compile-time behavior in
3764 large cases or excessive memory use in small cases. */
3765 else if (num_ctor_elements
< num_type_elements
)
3768 /* If there are "lots" of initialized elements, and all of them
3769 are valid address constants, then the entire initializer can
3770 be dropped to memory, and then memcpy'd out. Don't do this
3771 for sparse arrays, though, as it's more efficient to follow
3772 the standard CONSTRUCTOR behavior of memset followed by
3773 individual element initialization. Also don't do this for small
3774 all-zero initializers (which aren't big enough to merit
3775 clearing), and don't try to make bitwise copies of
3776 TREE_ADDRESSABLE types. */
3777 if (valid_const_initializer
3778 && !(cleared
|| num_nonzero_elements
== 0)
3779 && !TREE_ADDRESSABLE (type
))
3781 HOST_WIDE_INT size
= int_size_in_bytes (type
);
3784 /* ??? We can still get unbounded array types, at least
3785 from the C++ front end. This seems wrong, but attempt
3786 to work around it for now. */
3789 size
= int_size_in_bytes (TREE_TYPE (object
));
3791 TREE_TYPE (ctor
) = type
= TREE_TYPE (object
);
3794 /* Find the maximum alignment we can assume for the object. */
3795 /* ??? Make use of DECL_OFFSET_ALIGN. */
3796 if (DECL_P (object
))
3797 align
= DECL_ALIGN (object
);
3799 align
= TYPE_ALIGN (type
);
3802 && num_nonzero_elements
> 1
3803 && !can_move_by_pieces (size
, align
))
3805 if (notify_temp_creation
)
3808 walk_tree (&ctor
, force_labels_r
, NULL
, NULL
);
3809 ctor
= tree_output_constant_def (ctor
);
3810 if (!useless_type_conversion_p (type
, TREE_TYPE (ctor
)))
3811 ctor
= build1 (VIEW_CONVERT_EXPR
, type
, ctor
);
3812 TREE_OPERAND (*expr_p
, 1) = ctor
;
3814 /* This is no longer an assignment of a CONSTRUCTOR, but
3815 we still may have processing to do on the LHS. So
3816 pretend we didn't do anything here to let that happen. */
3817 return GS_UNHANDLED
;
3821 /* If the target is volatile, we have non-zero elements and more than
3822 one field to assign, initialize the target from a temporary. */
3823 if (TREE_THIS_VOLATILE (object
)
3824 && !TREE_ADDRESSABLE (type
)
3825 && num_nonzero_elements
> 0
3826 && VEC_length (constructor_elt
, elts
) > 1)
3828 tree temp
= create_tmp_var (TYPE_MAIN_VARIANT (type
), NULL
);
3829 TREE_OPERAND (*expr_p
, 0) = temp
;
3830 *expr_p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*expr_p
),
3832 build2 (MODIFY_EXPR
, void_type_node
,
3837 if (notify_temp_creation
)
3840 /* If there are nonzero elements and if needed, pre-evaluate to capture
3841 elements overlapping with the lhs into temporaries. We must do this
3842 before clearing to fetch the values before they are zeroed-out. */
3843 if (num_nonzero_elements
> 0 && TREE_CODE (*expr_p
) != INIT_EXPR
)
3845 preeval_data
.lhs_base_decl
= get_base_address (object
);
3846 if (!DECL_P (preeval_data
.lhs_base_decl
))
3847 preeval_data
.lhs_base_decl
= NULL
;
3848 preeval_data
.lhs_alias_set
= get_alias_set (object
);
3850 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p
, 1),
3851 pre_p
, post_p
, &preeval_data
);
3856 /* Zap the CONSTRUCTOR element list, which simplifies this case.
3857 Note that we still have to gimplify, in order to handle the
3858 case of variable sized types. Avoid shared tree structures. */
3859 CONSTRUCTOR_ELTS (ctor
) = NULL
;
3860 TREE_SIDE_EFFECTS (ctor
) = 0;
3861 object
= unshare_expr (object
);
3862 gimplify_stmt (expr_p
, pre_p
);
3865 /* If we have not block cleared the object, or if there are nonzero
3866 elements in the constructor, add assignments to the individual
3867 scalar fields of the object. */
3868 if (!cleared
|| num_nonzero_elements
> 0)
3869 gimplify_init_ctor_eval (object
, elts
, pre_p
, cleared
);
3871 *expr_p
= NULL_TREE
;
3879 if (notify_temp_creation
)
3882 /* Extract the real and imaginary parts out of the ctor. */
3883 gcc_assert (VEC_length (constructor_elt
, elts
) == 2);
3884 r
= VEC_index (constructor_elt
, elts
, 0)->value
;
3885 i
= VEC_index (constructor_elt
, elts
, 1)->value
;
3886 if (r
== NULL
|| i
== NULL
)
3888 tree zero
= build_zero_cst (TREE_TYPE (type
));
3895 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
3896 represent creation of a complex value. */
3897 if (TREE_CONSTANT (r
) && TREE_CONSTANT (i
))
3899 ctor
= build_complex (type
, r
, i
);
3900 TREE_OPERAND (*expr_p
, 1) = ctor
;
3904 ctor
= build2 (COMPLEX_EXPR
, type
, r
, i
);
3905 TREE_OPERAND (*expr_p
, 1) = ctor
;
3906 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1),
3909 rhs_predicate_for (TREE_OPERAND (*expr_p
, 0)),
3917 unsigned HOST_WIDE_INT ix
;
3918 constructor_elt
*ce
;
3920 if (notify_temp_creation
)
3923 /* Go ahead and simplify constant constructors to VECTOR_CST. */
3924 if (TREE_CONSTANT (ctor
))
3926 bool constant_p
= true;
3929 /* Even when ctor is constant, it might contain non-*_CST
3930 elements, such as addresses or trapping values like
3931 1.0/0.0 - 1.0/0.0. Such expressions don't belong
3932 in VECTOR_CST nodes. */
3933 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
3934 if (!CONSTANT_CLASS_P (value
))
3942 TREE_OPERAND (*expr_p
, 1) = build_vector_from_ctor (type
, elts
);
3946 /* Don't reduce an initializer constant even if we can't
3947 make a VECTOR_CST. It won't do anything for us, and it'll
3948 prevent us from representing it as a single constant. */
3949 if (initializer_constant_valid_p (ctor
, type
))
3952 TREE_CONSTANT (ctor
) = 0;
3955 /* Vector types use CONSTRUCTOR all the way through gimple
3956 compilation as a general initializer. */
3957 FOR_EACH_VEC_ELT (constructor_elt
, elts
, ix
, ce
)
3959 enum gimplify_status tret
;
3960 tret
= gimplify_expr (&ce
->value
, pre_p
, post_p
, is_gimple_val
,
3962 if (tret
== GS_ERROR
)
3965 if (!is_gimple_reg (TREE_OPERAND (*expr_p
, 0)))
3966 TREE_OPERAND (*expr_p
, 1) = get_formal_tmp_var (ctor
, pre_p
);
3971 /* So how did we get a CONSTRUCTOR for a scalar type? */
3975 if (ret
== GS_ERROR
)
3977 else if (want_value
)
3984 /* If we have gimplified both sides of the initializer but have
3985 not emitted an assignment, do so now. */
3988 tree lhs
= TREE_OPERAND (*expr_p
, 0);
3989 tree rhs
= TREE_OPERAND (*expr_p
, 1);
3990 gimple init
= gimple_build_assign (lhs
, rhs
);
3991 gimplify_seq_add_stmt (pre_p
, init
);
3999 /* Given a pointer value OP0, return a simplified version of an
4000 indirection through OP0, or NULL_TREE if no simplification is
4001 possible. Note that the resulting type may be different from
4002 the type pointed to in the sense that it is still compatible
4003 from the langhooks point of view. */
4006 gimple_fold_indirect_ref (tree t
)
4008 tree ptype
= TREE_TYPE (t
), type
= TREE_TYPE (ptype
);
4013 subtype
= TREE_TYPE (sub
);
4014 if (!POINTER_TYPE_P (subtype
))
4017 if (TREE_CODE (sub
) == ADDR_EXPR
)
4019 tree op
= TREE_OPERAND (sub
, 0);
4020 tree optype
= TREE_TYPE (op
);
4022 if (useless_type_conversion_p (type
, optype
))
4025 /* *(foo *)&fooarray => fooarray[0] */
4026 if (TREE_CODE (optype
) == ARRAY_TYPE
4027 && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype
))) == INTEGER_CST
4028 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4030 tree type_domain
= TYPE_DOMAIN (optype
);
4031 tree min_val
= size_zero_node
;
4032 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
4033 min_val
= TYPE_MIN_VALUE (type_domain
);
4034 if (TREE_CODE (min_val
) == INTEGER_CST
)
4035 return build4 (ARRAY_REF
, type
, op
, min_val
, NULL_TREE
, NULL_TREE
);
4037 /* *(foo *)&complexfoo => __real__ complexfoo */
4038 else if (TREE_CODE (optype
) == COMPLEX_TYPE
4039 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4040 return fold_build1 (REALPART_EXPR
, type
, op
);
4041 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
4042 else if (TREE_CODE (optype
) == VECTOR_TYPE
4043 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4045 tree part_width
= TYPE_SIZE (type
);
4046 tree index
= bitsize_int (0);
4047 return fold_build3 (BIT_FIELD_REF
, type
, op
, part_width
, index
);
4051 /* *(p + CST) -> ... */
4052 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
4053 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
4055 tree addr
= TREE_OPERAND (sub
, 0);
4056 tree off
= TREE_OPERAND (sub
, 1);
4060 addrtype
= TREE_TYPE (addr
);
4062 /* ((foo*)&vectorfoo)[1] -> BIT_FIELD_REF<vectorfoo,...> */
4063 if (TREE_CODE (addr
) == ADDR_EXPR
4064 && TREE_CODE (TREE_TYPE (addrtype
)) == VECTOR_TYPE
4065 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
))))
4067 HOST_WIDE_INT offset
= tree_low_cst (off
, 0);
4068 tree part_width
= TYPE_SIZE (type
);
4069 unsigned HOST_WIDE_INT part_widthi
4070 = tree_low_cst (part_width
, 0) / BITS_PER_UNIT
;
4071 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
4072 tree index
= bitsize_int (indexi
);
4073 if (offset
/ part_widthi
4074 <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype
)))
4075 return fold_build3 (BIT_FIELD_REF
, type
, TREE_OPERAND (addr
, 0),
4079 /* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
4080 if (TREE_CODE (addr
) == ADDR_EXPR
4081 && TREE_CODE (TREE_TYPE (addrtype
)) == COMPLEX_TYPE
4082 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
))))
4084 tree size
= TYPE_SIZE_UNIT (type
);
4085 if (tree_int_cst_equal (size
, off
))
4086 return fold_build1 (IMAGPART_EXPR
, type
, TREE_OPERAND (addr
, 0));
4089 /* *(p + CST) -> MEM_REF <p, CST>. */
4090 if (TREE_CODE (addr
) != ADDR_EXPR
4091 || DECL_P (TREE_OPERAND (addr
, 0)))
4092 return fold_build2 (MEM_REF
, type
,
4094 build_int_cst_wide (ptype
,
4095 TREE_INT_CST_LOW (off
),
4096 TREE_INT_CST_HIGH (off
)));
4099 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
4100 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
4101 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (subtype
)))) == INTEGER_CST
4102 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (subtype
))))
4105 tree min_val
= size_zero_node
;
4107 sub
= gimple_fold_indirect_ref (sub
);
4109 sub
= build1 (INDIRECT_REF
, TREE_TYPE (subtype
), osub
);
4110 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
4111 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
4112 min_val
= TYPE_MIN_VALUE (type_domain
);
4113 if (TREE_CODE (min_val
) == INTEGER_CST
)
4114 return build4 (ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
, NULL_TREE
);
4120 /* Given a pointer value OP0, return a simplified version of an
4121 indirection through OP0, or NULL_TREE if no simplification is
4122 possible. This may only be applied to a rhs of an expression.
4123 Note that the resulting type may be different from the type pointed
4124 to in the sense that it is still compatible from the langhooks
4128 gimple_fold_indirect_ref_rhs (tree t
)
4130 return gimple_fold_indirect_ref (t
);
4133 /* Subroutine of gimplify_modify_expr to do simplifications of
4134 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4135 something changes. */
4137 static enum gimplify_status
4138 gimplify_modify_expr_rhs (tree
*expr_p
, tree
*from_p
, tree
*to_p
,
4139 gimple_seq
*pre_p
, gimple_seq
*post_p
,
4142 enum gimplify_status ret
= GS_UNHANDLED
;
4148 switch (TREE_CODE (*from_p
))
4151 /* If we're assigning from a read-only variable initialized with
4152 a constructor, do the direct assignment from the constructor,
4153 but only if neither source nor target are volatile since this
4154 latter assignment might end up being done on a per-field basis. */
4155 if (DECL_INITIAL (*from_p
)
4156 && TREE_READONLY (*from_p
)
4157 && !TREE_THIS_VOLATILE (*from_p
)
4158 && !TREE_THIS_VOLATILE (*to_p
)
4159 && TREE_CODE (DECL_INITIAL (*from_p
)) == CONSTRUCTOR
)
4161 tree old_from
= *from_p
;
4162 enum gimplify_status subret
;
4164 /* Move the constructor into the RHS. */
4165 *from_p
= unshare_expr (DECL_INITIAL (*from_p
));
4167 /* Let's see if gimplify_init_constructor will need to put
4169 subret
= gimplify_init_constructor (expr_p
, NULL
, NULL
,
4171 if (subret
== GS_ERROR
)
4173 /* If so, revert the change. */
4185 /* If we have code like
4189 where the type of "x" is a (possibly cv-qualified variant
4190 of "A"), treat the entire expression as identical to "x".
4191 This kind of code arises in C++ when an object is bound
4192 to a const reference, and if "x" is a TARGET_EXPR we want
4193 to take advantage of the optimization below. */
4194 bool volatile_p
= TREE_THIS_VOLATILE (*from_p
);
4195 tree t
= gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p
, 0));
4198 if (TREE_THIS_VOLATILE (t
) != volatile_p
)
4200 if (TREE_CODE_CLASS (TREE_CODE (t
)) == tcc_declaration
)
4201 t
= build_simple_mem_ref_loc (EXPR_LOCATION (*from_p
),
4202 build_fold_addr_expr (t
));
4203 if (REFERENCE_CLASS_P (t
))
4204 TREE_THIS_VOLATILE (t
) = volatile_p
;
4215 /* If we are initializing something from a TARGET_EXPR, strip the
4216 TARGET_EXPR and initialize it directly, if possible. This can't
4217 be done if the initializer is void, since that implies that the
4218 temporary is set in some non-trivial way.
4220 ??? What about code that pulls out the temp and uses it
4221 elsewhere? I think that such code never uses the TARGET_EXPR as
4222 an initializer. If I'm wrong, we'll die because the temp won't
4223 have any RTL. In that case, I guess we'll need to replace
4224 references somehow. */
4225 tree init
= TARGET_EXPR_INITIAL (*from_p
);
4228 && !VOID_TYPE_P (TREE_TYPE (init
)))
4238 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4240 gimplify_compound_expr (from_p
, pre_p
, true);
4246 /* If we already made some changes, let the front end have a
4247 crack at this before we break it down. */
4248 if (ret
!= GS_UNHANDLED
)
4250 /* If we're initializing from a CONSTRUCTOR, break this into
4251 individual MODIFY_EXPRs. */
4252 return gimplify_init_constructor (expr_p
, pre_p
, post_p
, want_value
,
4256 /* If we're assigning to a non-register type, push the assignment
4257 down into the branches. This is mandatory for ADDRESSABLE types,
4258 since we cannot generate temporaries for such, but it saves a
4259 copy in other cases as well. */
4260 if (!is_gimple_reg_type (TREE_TYPE (*from_p
)))
4262 /* This code should mirror the code in gimplify_cond_expr. */
4263 enum tree_code code
= TREE_CODE (*expr_p
);
4264 tree cond
= *from_p
;
4265 tree result
= *to_p
;
4267 ret
= gimplify_expr (&result
, pre_p
, post_p
,
4268 is_gimple_lvalue
, fb_lvalue
);
4269 if (ret
!= GS_ERROR
)
4272 if (TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
)
4273 TREE_OPERAND (cond
, 1)
4274 = build2 (code
, void_type_node
, result
,
4275 TREE_OPERAND (cond
, 1));
4276 if (TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
4277 TREE_OPERAND (cond
, 2)
4278 = build2 (code
, void_type_node
, unshare_expr (result
),
4279 TREE_OPERAND (cond
, 2));
4281 TREE_TYPE (cond
) = void_type_node
;
4282 recalculate_side_effects (cond
);
4286 gimplify_and_add (cond
, pre_p
);
4287 *expr_p
= unshare_expr (result
);
4296 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4297 return slot so that we don't generate a temporary. */
4298 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p
)
4299 && aggregate_value_p (*from_p
, *from_p
))
4303 if (!(rhs_predicate_for (*to_p
))(*from_p
))
4304 /* If we need a temporary, *to_p isn't accurate. */
4306 else if (TREE_CODE (*to_p
) == RESULT_DECL
4307 && DECL_NAME (*to_p
) == NULL_TREE
4308 && needs_to_live_in_memory (*to_p
))
4309 /* It's OK to use the return slot directly unless it's an NRV. */
4311 else if (is_gimple_reg_type (TREE_TYPE (*to_p
))
4312 || (DECL_P (*to_p
) && DECL_REGISTER (*to_p
)))
4313 /* Don't force regs into memory. */
4315 else if (TREE_CODE (*expr_p
) == INIT_EXPR
)
4316 /* It's OK to use the target directly if it's being
4319 else if (!is_gimple_non_addressable (*to_p
))
4320 /* Don't use the original target if it's already addressable;
4321 if its address escapes, and the called function uses the
4322 NRV optimization, a conforming program could see *to_p
4323 change before the called function returns; see c++/19317.
4324 When optimizing, the return_slot pass marks more functions
4325 as safe after we have escape info. */
4332 CALL_EXPR_RETURN_SLOT_OPT (*from_p
) = 1;
4333 mark_addressable (*to_p
);
4338 case WITH_SIZE_EXPR
:
4339 /* Likewise for calls that return an aggregate of non-constant size,
4340 since we would not be able to generate a temporary at all. */
4341 if (TREE_CODE (TREE_OPERAND (*from_p
, 0)) == CALL_EXPR
)
4343 *from_p
= TREE_OPERAND (*from_p
, 0);
4344 /* We don't change ret in this case because the
4345 WITH_SIZE_EXPR might have been added in
4346 gimplify_modify_expr, so returning GS_OK would lead to an
4352 /* If we're initializing from a container, push the initialization
4354 case CLEANUP_POINT_EXPR
:
4356 case STATEMENT_LIST
:
4358 tree wrap
= *from_p
;
4361 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_min_lval
,
4363 if (ret
!= GS_ERROR
)
4366 t
= voidify_wrapper_expr (wrap
, *expr_p
);
4367 gcc_assert (t
== *expr_p
);
4371 gimplify_and_add (wrap
, pre_p
);
4372 *expr_p
= unshare_expr (*to_p
);
4379 case COMPOUND_LITERAL_EXPR
:
4381 tree complit
= TREE_OPERAND (*expr_p
, 1);
4382 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (complit
);
4383 tree decl
= DECL_EXPR_DECL (decl_s
);
4384 tree init
= DECL_INITIAL (decl
);
4386 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4387 into struct T x = { 0, 1, 2 } if the address of the
4388 compound literal has never been taken. */
4389 if (!TREE_ADDRESSABLE (complit
)
4390 && !TREE_ADDRESSABLE (decl
)
4393 *expr_p
= copy_node (*expr_p
);
4394 TREE_OPERAND (*expr_p
, 1) = init
;
4409 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4410 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4411 DECL_GIMPLE_REG_P set.
4413 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4414 other, unmodified part of the complex object just before the total store.
4415 As a consequence, if the object is still uninitialized, an undefined value
4416 will be loaded into a register, which may result in a spurious exception
4417 if the register is floating-point and the value happens to be a signaling
4418 NaN for example. Then the fully-fledged complex operations lowering pass
4419 followed by a DCE pass are necessary in order to fix things up. */
4421 static enum gimplify_status
4422 gimplify_modify_expr_complex_part (tree
*expr_p
, gimple_seq
*pre_p
,
4425 enum tree_code code
, ocode
;
4426 tree lhs
, rhs
, new_rhs
, other
, realpart
, imagpart
;
4428 lhs
= TREE_OPERAND (*expr_p
, 0);
4429 rhs
= TREE_OPERAND (*expr_p
, 1);
4430 code
= TREE_CODE (lhs
);
4431 lhs
= TREE_OPERAND (lhs
, 0);
4433 ocode
= code
== REALPART_EXPR
? IMAGPART_EXPR
: REALPART_EXPR
;
4434 other
= build1 (ocode
, TREE_TYPE (rhs
), lhs
);
4435 other
= get_formal_tmp_var (other
, pre_p
);
4437 realpart
= code
== REALPART_EXPR
? rhs
: other
;
4438 imagpart
= code
== REALPART_EXPR
? other
: rhs
;
4440 if (TREE_CONSTANT (realpart
) && TREE_CONSTANT (imagpart
))
4441 new_rhs
= build_complex (TREE_TYPE (lhs
), realpart
, imagpart
);
4443 new_rhs
= build2 (COMPLEX_EXPR
, TREE_TYPE (lhs
), realpart
, imagpart
);
4445 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (lhs
, new_rhs
));
4446 *expr_p
= (want_value
) ? rhs
: NULL_TREE
;
4452 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4458 PRE_P points to the list where side effects that must happen before
4459 *EXPR_P should be stored.
4461 POST_P points to the list where side effects that must happen after
4462 *EXPR_P should be stored.
4464 WANT_VALUE is nonzero iff we want to use the value of this expression
4465 in another expression. */
4467 static enum gimplify_status
4468 gimplify_modify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4471 tree
*from_p
= &TREE_OPERAND (*expr_p
, 1);
4472 tree
*to_p
= &TREE_OPERAND (*expr_p
, 0);
4473 enum gimplify_status ret
= GS_UNHANDLED
;
4475 location_t loc
= EXPR_LOCATION (*expr_p
);
4477 gcc_assert (TREE_CODE (*expr_p
) == MODIFY_EXPR
4478 || TREE_CODE (*expr_p
) == INIT_EXPR
);
4480 /* Insert pointer conversions required by the middle-end that are not
4481 required by the frontend. This fixes middle-end type checking for
4482 for example gcc.dg/redecl-6.c. */
4483 if (POINTER_TYPE_P (TREE_TYPE (*to_p
)))
4485 STRIP_USELESS_TYPE_CONVERSION (*from_p
);
4486 if (!useless_type_conversion_p (TREE_TYPE (*to_p
), TREE_TYPE (*from_p
)))
4487 *from_p
= fold_convert_loc (loc
, TREE_TYPE (*to_p
), *from_p
);
4490 /* See if any simplifications can be done based on what the RHS is. */
4491 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4493 if (ret
!= GS_UNHANDLED
)
4496 /* For zero sized types only gimplify the left hand side and right hand
4497 side as statements and throw away the assignment. Do this after
4498 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4500 if (zero_sized_type (TREE_TYPE (*from_p
)) && !want_value
)
4502 gimplify_stmt (from_p
, pre_p
);
4503 gimplify_stmt (to_p
, pre_p
);
4504 *expr_p
= NULL_TREE
;
4508 /* If the value being copied is of variable width, compute the length
4509 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4510 before gimplifying any of the operands so that we can resolve any
4511 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4512 the size of the expression to be copied, not of the destination, so
4513 that is what we must do here. */
4514 maybe_with_size_expr (from_p
);
4516 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4517 if (ret
== GS_ERROR
)
4520 /* As a special case, we have to temporarily allow for assignments
4521 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4522 a toplevel statement, when gimplifying the GENERIC expression
4523 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4524 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4526 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4527 prevent gimplify_expr from trying to create a new temporary for
4528 foo's LHS, we tell it that it should only gimplify until it
4529 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4530 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4531 and all we need to do here is set 'a' to be its LHS. */
4532 ret
= gimplify_expr (from_p
, pre_p
, post_p
, rhs_predicate_for (*to_p
),
4534 if (ret
== GS_ERROR
)
4537 /* Now see if the above changed *from_p to something we handle specially. */
4538 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4540 if (ret
!= GS_UNHANDLED
)
4543 /* If we've got a variable sized assignment between two lvalues (i.e. does
4544 not involve a call), then we can make things a bit more straightforward
4545 by converting the assignment to memcpy or memset. */
4546 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
4548 tree from
= TREE_OPERAND (*from_p
, 0);
4549 tree size
= TREE_OPERAND (*from_p
, 1);
4551 if (TREE_CODE (from
) == CONSTRUCTOR
)
4552 return gimplify_modify_expr_to_memset (expr_p
, size
, want_value
, pre_p
);
4554 if (is_gimple_addressable (from
))
4557 return gimplify_modify_expr_to_memcpy (expr_p
, size
, want_value
,
4562 /* Transform partial stores to non-addressable complex variables into
4563 total stores. This allows us to use real instead of virtual operands
4564 for these variables, which improves optimization. */
4565 if ((TREE_CODE (*to_p
) == REALPART_EXPR
4566 || TREE_CODE (*to_p
) == IMAGPART_EXPR
)
4567 && is_gimple_reg (TREE_OPERAND (*to_p
, 0)))
4568 return gimplify_modify_expr_complex_part (expr_p
, pre_p
, want_value
);
4570 /* Try to alleviate the effects of the gimplification creating artificial
4571 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
4572 if (!gimplify_ctxp
->into_ssa
4573 && TREE_CODE (*from_p
) == VAR_DECL
4574 && DECL_IGNORED_P (*from_p
)
4576 && !DECL_IGNORED_P (*to_p
))
4578 if (!DECL_NAME (*from_p
) && DECL_NAME (*to_p
))
4580 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p
)));
4581 DECL_DEBUG_EXPR_IS_FROM (*from_p
) = 1;
4582 SET_DECL_DEBUG_EXPR (*from_p
, *to_p
);
4585 if (want_value
&& TREE_THIS_VOLATILE (*to_p
))
4586 *from_p
= get_initialized_tmp_var (*from_p
, pre_p
, post_p
);
4588 if (TREE_CODE (*from_p
) == CALL_EXPR
)
4590 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4591 instead of a GIMPLE_ASSIGN. */
4592 assign
= gimple_build_call_from_tree (*from_p
);
4593 if (!gimple_call_noreturn_p (assign
))
4594 gimple_call_set_lhs (assign
, *to_p
);
4598 assign
= gimple_build_assign (*to_p
, *from_p
);
4599 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
4602 gimplify_seq_add_stmt (pre_p
, assign
);
4604 if (gimplify_ctxp
->into_ssa
&& is_gimple_reg (*to_p
))
4606 /* If we've somehow already got an SSA_NAME on the LHS, then
4607 we've probably modified it twice. Not good. */
4608 gcc_assert (TREE_CODE (*to_p
) != SSA_NAME
);
4609 *to_p
= make_ssa_name (*to_p
, assign
);
4610 gimple_set_lhs (assign
, *to_p
);
4615 *expr_p
= TREE_THIS_VOLATILE (*to_p
) ? *from_p
: unshare_expr (*to_p
);
4624 /* Gimplify a comparison between two variable-sized objects. Do this
4625 with a call to BUILT_IN_MEMCMP. */
4627 static enum gimplify_status
4628 gimplify_variable_sized_compare (tree
*expr_p
)
4630 location_t loc
= EXPR_LOCATION (*expr_p
);
4631 tree op0
= TREE_OPERAND (*expr_p
, 0);
4632 tree op1
= TREE_OPERAND (*expr_p
, 1);
4633 tree t
, arg
, dest
, src
, expr
;
4635 arg
= TYPE_SIZE_UNIT (TREE_TYPE (op0
));
4636 arg
= unshare_expr (arg
);
4637 arg
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg
, op0
);
4638 src
= build_fold_addr_expr_loc (loc
, op1
);
4639 dest
= build_fold_addr_expr_loc (loc
, op0
);
4640 t
= implicit_built_in_decls
[BUILT_IN_MEMCMP
];
4641 t
= build_call_expr_loc (loc
, t
, 3, dest
, src
, arg
);
4644 = build2 (TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), t
, integer_zero_node
);
4645 SET_EXPR_LOCATION (expr
, loc
);
4651 /* Gimplify a comparison between two aggregate objects of integral scalar
4652 mode as a comparison between the bitwise equivalent scalar values. */
4654 static enum gimplify_status
4655 gimplify_scalar_mode_aggregate_compare (tree
*expr_p
)
4657 location_t loc
= EXPR_LOCATION (*expr_p
);
4658 tree op0
= TREE_OPERAND (*expr_p
, 0);
4659 tree op1
= TREE_OPERAND (*expr_p
, 1);
4661 tree type
= TREE_TYPE (op0
);
4662 tree scalar_type
= lang_hooks
.types
.type_for_mode (TYPE_MODE (type
), 1);
4664 op0
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op0
);
4665 op1
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op1
);
4668 = fold_build2_loc (loc
, TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), op0
, op1
);
4673 /* Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions. EXPR_P
4674 points to the expression to gimplify.
4676 Expressions of the form 'a && b' are gimplified to:
4678 a && b ? true : false
4680 LOCUS is the source location to be put on the generated COND_EXPR.
4681 gimplify_cond_expr will do the rest. */
4683 static enum gimplify_status
4684 gimplify_boolean_expr (tree
*expr_p
, location_t locus
)
4686 /* Preserve the original type of the expression. */
4687 tree type
= TREE_TYPE (*expr_p
);
4689 *expr_p
= build3 (COND_EXPR
, type
, *expr_p
,
4690 fold_convert_loc (locus
, type
, boolean_true_node
),
4691 fold_convert_loc (locus
, type
, boolean_false_node
));
4693 SET_EXPR_LOCATION (*expr_p
, locus
);
4698 /* Gimplifies an expression sequence. This function gimplifies each
4699 expression and re-writes the original expression with the last
4700 expression of the sequence in GIMPLE form.
4702 PRE_P points to the list where the side effects for all the
4703 expressions in the sequence will be emitted.
4705 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
4707 static enum gimplify_status
4708 gimplify_compound_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
4714 tree
*sub_p
= &TREE_OPERAND (t
, 0);
4716 if (TREE_CODE (*sub_p
) == COMPOUND_EXPR
)
4717 gimplify_compound_expr (sub_p
, pre_p
, false);
4719 gimplify_stmt (sub_p
, pre_p
);
4721 t
= TREE_OPERAND (t
, 1);
4723 while (TREE_CODE (t
) == COMPOUND_EXPR
);
4730 gimplify_stmt (expr_p
, pre_p
);
4736 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
4737 gimplify. After gimplification, EXPR_P will point to a new temporary
4738 that holds the original value of the SAVE_EXPR node.
4740 PRE_P points to the list where side effects that must happen before
4741 *EXPR_P should be stored. */
4743 static enum gimplify_status
4744 gimplify_save_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4746 enum gimplify_status ret
= GS_ALL_DONE
;
4749 gcc_assert (TREE_CODE (*expr_p
) == SAVE_EXPR
);
4750 val
= TREE_OPERAND (*expr_p
, 0);
4752 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
4753 if (!SAVE_EXPR_RESOLVED_P (*expr_p
))
4755 /* The operand may be a void-valued expression such as SAVE_EXPRs
4756 generated by the Java frontend for class initialization. It is
4757 being executed only for its side-effects. */
4758 if (TREE_TYPE (val
) == void_type_node
)
4760 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
4761 is_gimple_stmt
, fb_none
);
4765 val
= get_initialized_tmp_var (val
, pre_p
, post_p
);
4767 TREE_OPERAND (*expr_p
, 0) = val
;
4768 SAVE_EXPR_RESOLVED_P (*expr_p
) = 1;
4776 /* Re-write the ADDR_EXPR node pointed to by EXPR_P
4783 PRE_P points to the list where side effects that must happen before
4784 *EXPR_P should be stored.
4786 POST_P points to the list where side effects that must happen after
4787 *EXPR_P should be stored. */
4789 static enum gimplify_status
4790 gimplify_addr_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4792 tree expr
= *expr_p
;
4793 tree op0
= TREE_OPERAND (expr
, 0);
4794 enum gimplify_status ret
;
4795 location_t loc
= EXPR_LOCATION (*expr_p
);
4797 switch (TREE_CODE (op0
))
4801 /* Check if we are dealing with an expression of the form '&*ptr'.
4802 While the front end folds away '&*ptr' into 'ptr', these
4803 expressions may be generated internally by the compiler (e.g.,
4804 builtins like __builtin_va_end). */
4805 /* Caution: the silent array decomposition semantics we allow for
4806 ADDR_EXPR means we can't always discard the pair. */
4807 /* Gimplification of the ADDR_EXPR operand may drop
4808 cv-qualification conversions, so make sure we add them if
4811 tree op00
= TREE_OPERAND (op0
, 0);
4812 tree t_expr
= TREE_TYPE (expr
);
4813 tree t_op00
= TREE_TYPE (op00
);
4815 if (!useless_type_conversion_p (t_expr
, t_op00
))
4816 op00
= fold_convert_loc (loc
, TREE_TYPE (expr
), op00
);
4822 case VIEW_CONVERT_EXPR
:
4823 /* Take the address of our operand and then convert it to the type of
4826 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
4827 all clear. The impact of this transformation is even less clear. */
4829 /* If the operand is a useless conversion, look through it. Doing so
4830 guarantees that the ADDR_EXPR and its operand will remain of the
4832 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0
, 0)))
4833 op0
= TREE_OPERAND (op0
, 0);
4835 *expr_p
= fold_convert_loc (loc
, TREE_TYPE (expr
),
4836 build_fold_addr_expr_loc (loc
,
4837 TREE_OPERAND (op0
, 0)));
4842 /* We use fb_either here because the C frontend sometimes takes
4843 the address of a call that returns a struct; see
4844 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
4845 the implied temporary explicit. */
4847 /* Make the operand addressable. */
4848 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, post_p
,
4849 is_gimple_addressable
, fb_either
);
4850 if (ret
== GS_ERROR
)
4853 /* Then mark it. Beware that it may not be possible to do so directly
4854 if a temporary has been created by the gimplification. */
4855 prepare_gimple_addressable (&TREE_OPERAND (expr
, 0), pre_p
);
4857 op0
= TREE_OPERAND (expr
, 0);
4859 /* For various reasons, the gimplification of the expression
4860 may have made a new INDIRECT_REF. */
4861 if (TREE_CODE (op0
) == INDIRECT_REF
)
4862 goto do_indirect_ref
;
4864 mark_addressable (TREE_OPERAND (expr
, 0));
4866 /* The FEs may end up building ADDR_EXPRs early on a decl with
4867 an incomplete type. Re-build ADDR_EXPRs in canonical form
4869 if (!types_compatible_p (TREE_TYPE (op0
), TREE_TYPE (TREE_TYPE (expr
))))
4870 *expr_p
= build_fold_addr_expr (op0
);
4872 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
4873 recompute_tree_invariant_for_addr_expr (*expr_p
);
4875 /* If we re-built the ADDR_EXPR add a conversion to the original type
4877 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
4878 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
4886 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
4887 value; output operands should be a gimple lvalue. */
4889 static enum gimplify_status
4890 gimplify_asm_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4894 const char **oconstraints
;
4897 const char *constraint
;
4898 bool allows_mem
, allows_reg
, is_inout
;
4899 enum gimplify_status ret
, tret
;
4901 VEC(tree
, gc
) *inputs
;
4902 VEC(tree
, gc
) *outputs
;
4903 VEC(tree
, gc
) *clobbers
;
4904 VEC(tree
, gc
) *labels
;
4908 noutputs
= list_length (ASM_OUTPUTS (expr
));
4909 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
4911 inputs
= outputs
= clobbers
= labels
= NULL
;
4914 link_next
= NULL_TREE
;
4915 for (i
= 0, link
= ASM_OUTPUTS (expr
); link
; ++i
, link
= link_next
)
4918 size_t constraint_len
;
4920 link_next
= TREE_CHAIN (link
);
4924 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
4925 constraint_len
= strlen (constraint
);
4926 if (constraint_len
== 0)
4929 ok
= parse_output_constraint (&constraint
, i
, 0, 0,
4930 &allows_mem
, &allows_reg
, &is_inout
);
4937 if (!allows_reg
&& allows_mem
)
4938 mark_addressable (TREE_VALUE (link
));
4940 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
4941 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
4942 fb_lvalue
| fb_mayfail
);
4943 if (tret
== GS_ERROR
)
4945 error ("invalid lvalue in asm output %d", i
);
4949 VEC_safe_push (tree
, gc
, outputs
, link
);
4950 TREE_CHAIN (link
) = NULL_TREE
;
4954 /* An input/output operand. To give the optimizers more
4955 flexibility, split it into separate input and output
4960 /* Turn the in/out constraint into an output constraint. */
4961 char *p
= xstrdup (constraint
);
4963 TREE_VALUE (TREE_PURPOSE (link
)) = build_string (constraint_len
, p
);
4965 /* And add a matching input constraint. */
4968 sprintf (buf
, "%d", i
);
4970 /* If there are multiple alternatives in the constraint,
4971 handle each of them individually. Those that allow register
4972 will be replaced with operand number, the others will stay
4974 if (strchr (p
, ',') != NULL
)
4976 size_t len
= 0, buflen
= strlen (buf
);
4977 char *beg
, *end
, *str
, *dst
;
4981 end
= strchr (beg
, ',');
4983 end
= strchr (beg
, '\0');
4984 if ((size_t) (end
- beg
) < buflen
)
4987 len
+= end
- beg
+ 1;
4994 str
= (char *) alloca (len
);
4995 for (beg
= p
+ 1, dst
= str
;;)
4998 bool mem_p
, reg_p
, inout_p
;
5000 end
= strchr (beg
, ',');
5005 parse_output_constraint (&tem
, i
, 0, 0,
5006 &mem_p
, ®_p
, &inout_p
);
5011 memcpy (dst
, buf
, buflen
);
5020 memcpy (dst
, beg
, len
);
5029 input
= build_string (dst
- str
, str
);
5032 input
= build_string (strlen (buf
), buf
);
5035 input
= build_string (constraint_len
- 1, constraint
+ 1);
5039 input
= build_tree_list (build_tree_list (NULL_TREE
, input
),
5040 unshare_expr (TREE_VALUE (link
)));
5041 ASM_INPUTS (expr
) = chainon (ASM_INPUTS (expr
), input
);
5045 link_next
= NULL_TREE
;
5046 for (link
= ASM_INPUTS (expr
); link
; ++i
, link
= link_next
)
5048 link_next
= TREE_CHAIN (link
);
5049 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5050 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
5051 oconstraints
, &allows_mem
, &allows_reg
);
5053 /* If we can't make copies, we can only accept memory. */
5054 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link
))))
5060 error ("impossible constraint in %<asm%>");
5061 error ("non-memory input %d must stay in memory", i
);
5066 /* If the operand is a memory input, it should be an lvalue. */
5067 if (!allows_reg
&& allows_mem
)
5069 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5070 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
5071 mark_addressable (TREE_VALUE (link
));
5072 if (tret
== GS_ERROR
)
5074 if (EXPR_HAS_LOCATION (TREE_VALUE (link
)))
5075 input_location
= EXPR_LOCATION (TREE_VALUE (link
));
5076 error ("memory input %d is not directly addressable", i
);
5082 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5083 is_gimple_asm_val
, fb_rvalue
);
5084 if (tret
== GS_ERROR
)
5088 TREE_CHAIN (link
) = NULL_TREE
;
5089 VEC_safe_push (tree
, gc
, inputs
, link
);
5092 for (link
= ASM_CLOBBERS (expr
); link
; ++i
, link
= TREE_CHAIN (link
))
5093 VEC_safe_push (tree
, gc
, clobbers
, link
);
5095 for (link
= ASM_LABELS (expr
); link
; ++i
, link
= TREE_CHAIN (link
))
5096 VEC_safe_push (tree
, gc
, labels
, link
);
5098 /* Do not add ASMs with errors to the gimple IL stream. */
5099 if (ret
!= GS_ERROR
)
5101 stmt
= gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr
)),
5102 inputs
, outputs
, clobbers
, labels
);
5104 gimple_asm_set_volatile (stmt
, ASM_VOLATILE_P (expr
));
5105 gimple_asm_set_input (stmt
, ASM_INPUT_P (expr
));
5107 gimplify_seq_add_stmt (pre_p
, stmt
);
5113 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
5114 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
5115 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
5116 return to this function.
5118 FIXME should we complexify the prequeue handling instead? Or use flags
5119 for all the cleanups and let the optimizer tighten them up? The current
5120 code seems pretty fragile; it will break on a cleanup within any
5121 non-conditional nesting. But any such nesting would be broken, anyway;
5122 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
5123 and continues out of it. We can do that at the RTL level, though, so
5124 having an optimizer to tighten up try/finally regions would be a Good
5127 static enum gimplify_status
5128 gimplify_cleanup_point_expr (tree
*expr_p
, gimple_seq
*pre_p
)
5130 gimple_stmt_iterator iter
;
5131 gimple_seq body_sequence
= NULL
;
5133 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
5135 /* We only care about the number of conditions between the innermost
5136 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5137 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5138 int old_conds
= gimplify_ctxp
->conditions
;
5139 gimple_seq old_cleanups
= gimplify_ctxp
->conditional_cleanups
;
5140 gimplify_ctxp
->conditions
= 0;
5141 gimplify_ctxp
->conditional_cleanups
= NULL
;
5143 gimplify_stmt (&TREE_OPERAND (*expr_p
, 0), &body_sequence
);
5145 gimplify_ctxp
->conditions
= old_conds
;
5146 gimplify_ctxp
->conditional_cleanups
= old_cleanups
;
5148 for (iter
= gsi_start (body_sequence
); !gsi_end_p (iter
); )
5150 gimple wce
= gsi_stmt (iter
);
5152 if (gimple_code (wce
) == GIMPLE_WITH_CLEANUP_EXPR
)
5154 if (gsi_one_before_end_p (iter
))
5156 /* Note that gsi_insert_seq_before and gsi_remove do not
5157 scan operands, unlike some other sequence mutators. */
5158 if (!gimple_wce_cleanup_eh_only (wce
))
5159 gsi_insert_seq_before_without_update (&iter
,
5160 gimple_wce_cleanup (wce
),
5162 gsi_remove (&iter
, true);
5169 enum gimple_try_flags kind
;
5171 if (gimple_wce_cleanup_eh_only (wce
))
5172 kind
= GIMPLE_TRY_CATCH
;
5174 kind
= GIMPLE_TRY_FINALLY
;
5175 seq
= gsi_split_seq_after (iter
);
5177 gtry
= gimple_build_try (seq
, gimple_wce_cleanup (wce
), kind
);
5178 /* Do not use gsi_replace here, as it may scan operands.
5179 We want to do a simple structural modification only. */
5180 *gsi_stmt_ptr (&iter
) = gtry
;
5181 iter
= gsi_start (seq
);
5188 gimplify_seq_add_seq (pre_p
, body_sequence
);
5201 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5202 is the cleanup action required. EH_ONLY is true if the cleanup should
5203 only be executed if an exception is thrown, not on normal exit. */
5206 gimple_push_cleanup (tree var
, tree cleanup
, bool eh_only
, gimple_seq
*pre_p
)
5209 gimple_seq cleanup_stmts
= NULL
;
5211 /* Errors can result in improperly nested cleanups. Which results in
5212 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5216 if (gimple_conditional_context ())
5218 /* If we're in a conditional context, this is more complex. We only
5219 want to run the cleanup if we actually ran the initialization that
5220 necessitates it, but we want to run it after the end of the
5221 conditional context. So we wrap the try/finally around the
5222 condition and use a flag to determine whether or not to actually
5223 run the destructor. Thus
5227 becomes (approximately)
5231 if (test) { A::A(temp); flag = 1; val = f(temp); }
5234 if (flag) A::~A(temp);
5238 tree flag
= create_tmp_var (boolean_type_node
, "cleanup");
5239 gimple ffalse
= gimple_build_assign (flag
, boolean_false_node
);
5240 gimple ftrue
= gimple_build_assign (flag
, boolean_true_node
);
5242 cleanup
= build3 (COND_EXPR
, void_type_node
, flag
, cleanup
, NULL
);
5243 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5244 wce
= gimple_build_wce (cleanup_stmts
);
5246 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, ffalse
);
5247 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
5248 gimplify_seq_add_stmt (pre_p
, ftrue
);
5250 /* Because of this manipulation, and the EH edges that jump
5251 threading cannot redirect, the temporary (VAR) will appear
5252 to be used uninitialized. Don't warn. */
5253 TREE_NO_WARNING (var
) = 1;
5257 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5258 wce
= gimple_build_wce (cleanup_stmts
);
5259 gimple_wce_set_cleanup_eh_only (wce
, eh_only
);
5260 gimplify_seq_add_stmt (pre_p
, wce
);
5264 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5266 static enum gimplify_status
5267 gimplify_target_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5269 tree targ
= *expr_p
;
5270 tree temp
= TARGET_EXPR_SLOT (targ
);
5271 tree init
= TARGET_EXPR_INITIAL (targ
);
5272 enum gimplify_status ret
;
5276 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5277 to the temps list. Handle also variable length TARGET_EXPRs. */
5278 if (TREE_CODE (DECL_SIZE (temp
)) != INTEGER_CST
)
5280 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp
)))
5281 gimplify_type_sizes (TREE_TYPE (temp
), pre_p
);
5282 gimplify_vla_decl (temp
, pre_p
);
5285 gimple_add_tmp_var (temp
);
5287 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5288 expression is supposed to initialize the slot. */
5289 if (VOID_TYPE_P (TREE_TYPE (init
)))
5290 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5293 tree init_expr
= build2 (INIT_EXPR
, void_type_node
, temp
, init
);
5295 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5297 ggc_free (init_expr
);
5299 if (ret
== GS_ERROR
)
5301 /* PR c++/28266 Make sure this is expanded only once. */
5302 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5306 gimplify_and_add (init
, pre_p
);
5308 /* If needed, push the cleanup for the temp. */
5309 if (TARGET_EXPR_CLEANUP (targ
))
5310 gimple_push_cleanup (temp
, TARGET_EXPR_CLEANUP (targ
),
5311 CLEANUP_EH_ONLY (targ
), pre_p
);
5313 /* Only expand this once. */
5314 TREE_OPERAND (targ
, 3) = init
;
5315 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5318 /* We should have expanded this before. */
5319 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp
));
5325 /* Gimplification of expression trees. */
5327 /* Gimplify an expression which appears at statement context. The
5328 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5329 NULL, a new sequence is allocated.
5331 Return true if we actually added a statement to the queue. */
5334 gimplify_stmt (tree
*stmt_p
, gimple_seq
*seq_p
)
5336 gimple_seq_node last
;
5339 *seq_p
= gimple_seq_alloc ();
5341 last
= gimple_seq_last (*seq_p
);
5342 gimplify_expr (stmt_p
, seq_p
, NULL
, is_gimple_stmt
, fb_none
);
5343 return last
!= gimple_seq_last (*seq_p
);
5347 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5348 to CTX. If entries already exist, force them to be some flavor of private.
5349 If there is no enclosing parallel, do nothing. */
5352 omp_firstprivatize_variable (struct gimplify_omp_ctx
*ctx
, tree decl
)
5356 if (decl
== NULL
|| !DECL_P (decl
))
5361 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5364 if (n
->value
& GOVD_SHARED
)
5365 n
->value
= GOVD_FIRSTPRIVATE
| (n
->value
& GOVD_SEEN
);
5369 else if (ctx
->region_type
!= ORT_WORKSHARE
)
5370 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
5372 ctx
= ctx
->outer_context
;
5377 /* Similarly for each of the type sizes of TYPE. */
5380 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx
*ctx
, tree type
)
5382 if (type
== NULL
|| type
== error_mark_node
)
5384 type
= TYPE_MAIN_VARIANT (type
);
5386 if (pointer_set_insert (ctx
->privatized_types
, type
))
5389 switch (TREE_CODE (type
))
5395 case FIXED_POINT_TYPE
:
5396 omp_firstprivatize_variable (ctx
, TYPE_MIN_VALUE (type
));
5397 omp_firstprivatize_variable (ctx
, TYPE_MAX_VALUE (type
));
5401 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5402 omp_firstprivatize_type_sizes (ctx
, TYPE_DOMAIN (type
));
5407 case QUAL_UNION_TYPE
:
5410 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
5411 if (TREE_CODE (field
) == FIELD_DECL
)
5413 omp_firstprivatize_variable (ctx
, DECL_FIELD_OFFSET (field
));
5414 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (field
));
5420 case REFERENCE_TYPE
:
5421 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5428 omp_firstprivatize_variable (ctx
, TYPE_SIZE (type
));
5429 omp_firstprivatize_variable (ctx
, TYPE_SIZE_UNIT (type
));
5430 lang_hooks
.types
.omp_firstprivatize_type_sizes (ctx
, type
);
5433 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
5436 omp_add_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned int flags
)
5439 unsigned int nflags
;
5442 if (decl
== error_mark_node
|| TREE_TYPE (decl
) == error_mark_node
)
5445 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5446 there are constructors involved somewhere. */
5447 if (TREE_ADDRESSABLE (TREE_TYPE (decl
))
5448 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
5451 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5454 /* We shouldn't be re-adding the decl with the same data
5456 gcc_assert ((n
->value
& GOVD_DATA_SHARE_CLASS
& flags
) == 0);
5457 /* The only combination of data sharing classes we should see is
5458 FIRSTPRIVATE and LASTPRIVATE. */
5459 nflags
= n
->value
| flags
;
5460 gcc_assert ((nflags
& GOVD_DATA_SHARE_CLASS
)
5461 == (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
));
5466 /* When adding a variable-sized variable, we have to handle all sorts
5467 of additional bits of data: the pointer replacement variable, and
5468 the parameters of the type. */
5469 if (DECL_SIZE (decl
) && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5471 /* Add the pointer replacement variable as PRIVATE if the variable
5472 replacement is private, else FIRSTPRIVATE since we'll need the
5473 address of the original variable either for SHARED, or for the
5474 copy into or out of the context. */
5475 if (!(flags
& GOVD_LOCAL
))
5477 nflags
= flags
& GOVD_PRIVATE
? GOVD_PRIVATE
: GOVD_FIRSTPRIVATE
;
5478 nflags
|= flags
& GOVD_SEEN
;
5479 t
= DECL_VALUE_EXPR (decl
);
5480 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5481 t
= TREE_OPERAND (t
, 0);
5482 gcc_assert (DECL_P (t
));
5483 omp_add_variable (ctx
, t
, nflags
);
5486 /* Add all of the variable and type parameters (which should have
5487 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5488 omp_firstprivatize_variable (ctx
, DECL_SIZE_UNIT (decl
));
5489 omp_firstprivatize_variable (ctx
, DECL_SIZE (decl
));
5490 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5492 /* The variable-sized variable itself is never SHARED, only some form
5493 of PRIVATE. The sharing would take place via the pointer variable
5494 which we remapped above. */
5495 if (flags
& GOVD_SHARED
)
5496 flags
= GOVD_PRIVATE
| GOVD_DEBUG_PRIVATE
5497 | (flags
& (GOVD_SEEN
| GOVD_EXPLICIT
));
5499 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5500 alloca statement we generate for the variable, so make sure it
5501 is available. This isn't automatically needed for the SHARED
5502 case, since we won't be allocating local storage then.
5503 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5504 in this case omp_notice_variable will be called later
5505 on when it is gimplified. */
5506 else if (! (flags
& GOVD_LOCAL
))
5507 omp_notice_variable (ctx
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)), true);
5509 else if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
5511 gcc_assert ((flags
& GOVD_LOCAL
) == 0);
5512 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5514 /* Similar to the direct variable sized case above, we'll need the
5515 size of references being privatized. */
5516 if ((flags
& GOVD_SHARED
) == 0)
5518 t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
5519 if (TREE_CODE (t
) != INTEGER_CST
)
5520 omp_notice_variable (ctx
, t
, true);
5524 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, flags
);
5527 /* Notice a threadprivate variable DECL used in OpenMP context CTX.
5528 This just prints out diagnostics about threadprivate variable uses
5529 in untied tasks. If DECL2 is non-NULL, prevent this warning
5530 on that variable. */
5533 omp_notice_threadprivate_variable (struct gimplify_omp_ctx
*ctx
, tree decl
,
5538 if (ctx
->region_type
!= ORT_UNTIED_TASK
)
5540 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5543 error ("threadprivate variable %qE used in untied task", DECL_NAME (decl
));
5544 error_at (ctx
->location
, "enclosing task");
5545 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, 0);
5548 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl2
, 0);
5552 /* Record the fact that DECL was used within the OpenMP context CTX.
5553 IN_CODE is true when real code uses DECL, and false when we should
5554 merely emit default(none) errors. Return true if DECL is going to
5555 be remapped and thus DECL shouldn't be gimplified into its
5556 DECL_VALUE_EXPR (if any). */
5559 omp_notice_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, bool in_code
)
5562 unsigned flags
= in_code
? GOVD_SEEN
: 0;
5563 bool ret
= false, shared
;
5565 if (decl
== error_mark_node
|| TREE_TYPE (decl
) == error_mark_node
)
5568 /* Threadprivate variables are predetermined. */
5569 if (is_global_var (decl
))
5571 if (DECL_THREAD_LOCAL_P (decl
))
5572 return omp_notice_threadprivate_variable (ctx
, decl
, NULL_TREE
);
5574 if (DECL_HAS_VALUE_EXPR_P (decl
))
5576 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
5578 if (value
&& DECL_P (value
) && DECL_THREAD_LOCAL_P (value
))
5579 return omp_notice_threadprivate_variable (ctx
, decl
, value
);
5583 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5586 enum omp_clause_default_kind default_kind
, kind
;
5587 struct gimplify_omp_ctx
*octx
;
5589 if (ctx
->region_type
== ORT_WORKSHARE
)
5592 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
5593 remapped firstprivate instead of shared. To some extent this is
5594 addressed in omp_firstprivatize_type_sizes, but not effectively. */
5595 default_kind
= ctx
->default_kind
;
5596 kind
= lang_hooks
.decls
.omp_predetermined_sharing (decl
);
5597 if (kind
!= OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
5598 default_kind
= kind
;
5600 switch (default_kind
)
5602 case OMP_CLAUSE_DEFAULT_NONE
:
5603 error ("%qE not specified in enclosing parallel",
5604 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5605 if ((ctx
->region_type
& ORT_TASK
) != 0)
5606 error_at (ctx
->location
, "enclosing task");
5608 error_at (ctx
->location
, "enclosing parallel");
5610 case OMP_CLAUSE_DEFAULT_SHARED
:
5611 flags
|= GOVD_SHARED
;
5613 case OMP_CLAUSE_DEFAULT_PRIVATE
:
5614 flags
|= GOVD_PRIVATE
;
5616 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
5617 flags
|= GOVD_FIRSTPRIVATE
;
5619 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
5620 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
5621 gcc_assert ((ctx
->region_type
& ORT_TASK
) != 0);
5622 if (ctx
->outer_context
)
5623 omp_notice_variable (ctx
->outer_context
, decl
, in_code
);
5624 for (octx
= ctx
->outer_context
; octx
; octx
= octx
->outer_context
)
5628 n2
= splay_tree_lookup (octx
->variables
, (splay_tree_key
) decl
);
5629 if (n2
&& (n2
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
)
5631 flags
|= GOVD_FIRSTPRIVATE
;
5634 if ((octx
->region_type
& ORT_PARALLEL
) != 0)
5637 if (flags
& GOVD_FIRSTPRIVATE
)
5640 && (TREE_CODE (decl
) == PARM_DECL
5641 || (!is_global_var (decl
)
5642 && DECL_CONTEXT (decl
) == current_function_decl
)))
5644 flags
|= GOVD_FIRSTPRIVATE
;
5647 flags
|= GOVD_SHARED
;
5653 if ((flags
& GOVD_PRIVATE
)
5654 && lang_hooks
.decls
.omp_private_outer_ref (decl
))
5655 flags
|= GOVD_PRIVATE_OUTER_REF
;
5657 omp_add_variable (ctx
, decl
, flags
);
5659 shared
= (flags
& GOVD_SHARED
) != 0;
5660 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
5664 if ((n
->value
& (GOVD_SEEN
| GOVD_LOCAL
)) == 0
5665 && (flags
& (GOVD_SEEN
| GOVD_LOCAL
)) == GOVD_SEEN
5667 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5670 tree t
= DECL_VALUE_EXPR (decl
);
5671 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5672 t
= TREE_OPERAND (t
, 0);
5673 gcc_assert (DECL_P (t
));
5674 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
5675 n2
->value
|= GOVD_SEEN
;
5678 shared
= ((flags
| n
->value
) & GOVD_SHARED
) != 0;
5679 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
5681 /* If nothing changed, there's nothing left to do. */
5682 if ((n
->value
& flags
) == flags
)
5688 /* If the variable is private in the current context, then we don't
5689 need to propagate anything to an outer context. */
5690 if ((flags
& GOVD_PRIVATE
) && !(flags
& GOVD_PRIVATE_OUTER_REF
))
5692 if (ctx
->outer_context
5693 && omp_notice_variable (ctx
->outer_context
, decl
, in_code
))
5698 /* Verify that DECL is private within CTX. If there's specific information
5699 to the contrary in the innermost scope, generate an error. */
5702 omp_is_private (struct gimplify_omp_ctx
*ctx
, tree decl
)
5706 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5709 if (n
->value
& GOVD_SHARED
)
5711 if (ctx
== gimplify_omp_ctxp
)
5713 error ("iteration variable %qE should be private",
5715 n
->value
= GOVD_PRIVATE
;
5721 else if ((n
->value
& GOVD_EXPLICIT
) != 0
5722 && (ctx
== gimplify_omp_ctxp
5723 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
5724 && gimplify_omp_ctxp
->outer_context
== ctx
)))
5726 if ((n
->value
& GOVD_FIRSTPRIVATE
) != 0)
5727 error ("iteration variable %qE should not be firstprivate",
5729 else if ((n
->value
& GOVD_REDUCTION
) != 0)
5730 error ("iteration variable %qE should not be reduction",
5733 return (ctx
== gimplify_omp_ctxp
5734 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
5735 && gimplify_omp_ctxp
->outer_context
== ctx
));
5738 if (ctx
->region_type
!= ORT_WORKSHARE
)
5740 else if (ctx
->outer_context
)
5741 return omp_is_private (ctx
->outer_context
, decl
);
5745 /* Return true if DECL is private within a parallel region
5746 that binds to the current construct's context or in parallel
5747 region's REDUCTION clause. */
5750 omp_check_private (struct gimplify_omp_ctx
*ctx
, tree decl
)
5756 ctx
= ctx
->outer_context
;
5758 return !(is_global_var (decl
)
5759 /* References might be private, but might be shared too. */
5760 || lang_hooks
.decls
.omp_privatize_by_reference (decl
));
5762 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
5764 return (n
->value
& GOVD_SHARED
) == 0;
5766 while (ctx
->region_type
== ORT_WORKSHARE
);
5770 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
5771 and previous omp contexts. */
5774 gimplify_scan_omp_clauses (tree
*list_p
, gimple_seq
*pre_p
,
5775 enum omp_region_type region_type
)
5777 struct gimplify_omp_ctx
*ctx
, *outer_ctx
;
5778 struct gimplify_ctx gctx
;
5781 ctx
= new_omp_context (region_type
);
5782 outer_ctx
= ctx
->outer_context
;
5784 while ((c
= *list_p
) != NULL
)
5786 bool remove
= false;
5787 bool notice_outer
= true;
5788 const char *check_non_private
= NULL
;
5792 switch (OMP_CLAUSE_CODE (c
))
5794 case OMP_CLAUSE_PRIVATE
:
5795 flags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
5796 if (lang_hooks
.decls
.omp_private_outer_ref (OMP_CLAUSE_DECL (c
)))
5798 flags
|= GOVD_PRIVATE_OUTER_REF
;
5799 OMP_CLAUSE_PRIVATE_OUTER_REF (c
) = 1;
5802 notice_outer
= false;
5804 case OMP_CLAUSE_SHARED
:
5805 flags
= GOVD_SHARED
| GOVD_EXPLICIT
;
5807 case OMP_CLAUSE_FIRSTPRIVATE
:
5808 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
5809 check_non_private
= "firstprivate";
5811 case OMP_CLAUSE_LASTPRIVATE
:
5812 flags
= GOVD_LASTPRIVATE
| GOVD_SEEN
| GOVD_EXPLICIT
;
5813 check_non_private
= "lastprivate";
5815 case OMP_CLAUSE_REDUCTION
:
5816 flags
= GOVD_REDUCTION
| GOVD_SEEN
| GOVD_EXPLICIT
;
5817 check_non_private
= "reduction";
5821 decl
= OMP_CLAUSE_DECL (c
);
5822 if (decl
== error_mark_node
|| TREE_TYPE (decl
) == error_mark_node
)
5827 omp_add_variable (ctx
, decl
, flags
);
5828 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
5829 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
5831 omp_add_variable (ctx
, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
),
5832 GOVD_LOCAL
| GOVD_SEEN
);
5833 gimplify_omp_ctxp
= ctx
;
5834 push_gimplify_context (&gctx
);
5836 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = gimple_seq_alloc ();
5837 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = gimple_seq_alloc ();
5839 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c
),
5840 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
5841 pop_gimplify_context
5842 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
)));
5843 push_gimplify_context (&gctx
);
5844 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c
),
5845 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
5846 pop_gimplify_context
5847 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
)));
5848 OMP_CLAUSE_REDUCTION_INIT (c
) = NULL_TREE
;
5849 OMP_CLAUSE_REDUCTION_MERGE (c
) = NULL_TREE
;
5851 gimplify_omp_ctxp
= outer_ctx
;
5853 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
5854 && OMP_CLAUSE_LASTPRIVATE_STMT (c
))
5856 gimplify_omp_ctxp
= ctx
;
5857 push_gimplify_context (&gctx
);
5858 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c
)) != BIND_EXPR
)
5860 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
5862 TREE_SIDE_EFFECTS (bind
) = 1;
5863 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LASTPRIVATE_STMT (c
);
5864 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = bind
;
5866 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c
),
5867 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
5868 pop_gimplify_context
5869 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
)));
5870 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = NULL_TREE
;
5872 gimplify_omp_ctxp
= outer_ctx
;
5878 case OMP_CLAUSE_COPYIN
:
5879 case OMP_CLAUSE_COPYPRIVATE
:
5880 decl
= OMP_CLAUSE_DECL (c
);
5881 if (decl
== error_mark_node
|| TREE_TYPE (decl
) == error_mark_node
)
5888 omp_notice_variable (outer_ctx
, decl
, true);
5889 if (check_non_private
5890 && region_type
== ORT_WORKSHARE
5891 && omp_check_private (ctx
, decl
))
5893 error ("%s variable %qE is private in outer context",
5894 check_non_private
, DECL_NAME (decl
));
5900 OMP_CLAUSE_OPERAND (c
, 0)
5901 = gimple_boolify (OMP_CLAUSE_OPERAND (c
, 0));
5904 case OMP_CLAUSE_SCHEDULE
:
5905 case OMP_CLAUSE_NUM_THREADS
:
5906 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
5907 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
5911 case OMP_CLAUSE_NOWAIT
:
5912 case OMP_CLAUSE_ORDERED
:
5913 case OMP_CLAUSE_UNTIED
:
5914 case OMP_CLAUSE_COLLAPSE
:
5917 case OMP_CLAUSE_DEFAULT
:
5918 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
5926 *list_p
= OMP_CLAUSE_CHAIN (c
);
5928 list_p
= &OMP_CLAUSE_CHAIN (c
);
5931 gimplify_omp_ctxp
= ctx
;
5934 /* For all variables that were not actually used within the context,
5935 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
5938 gimplify_adjust_omp_clauses_1 (splay_tree_node n
, void *data
)
5940 tree
*list_p
= (tree
*) data
;
5941 tree decl
= (tree
) n
->key
;
5942 unsigned flags
= n
->value
;
5943 enum omp_clause_code code
;
5947 if (flags
& (GOVD_EXPLICIT
| GOVD_LOCAL
))
5949 if ((flags
& GOVD_SEEN
) == 0)
5951 if (flags
& GOVD_DEBUG_PRIVATE
)
5953 gcc_assert ((flags
& GOVD_DATA_SHARE_CLASS
) == GOVD_PRIVATE
);
5954 private_debug
= true;
5958 = lang_hooks
.decls
.omp_private_debug_clause (decl
,
5959 !!(flags
& GOVD_SHARED
));
5961 code
= OMP_CLAUSE_PRIVATE
;
5962 else if (flags
& GOVD_SHARED
)
5964 if (is_global_var (decl
))
5966 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
5970 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
5971 if (on
&& (on
->value
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
5972 | GOVD_PRIVATE
| GOVD_REDUCTION
)) != 0)
5974 ctx
= ctx
->outer_context
;
5979 code
= OMP_CLAUSE_SHARED
;
5981 else if (flags
& GOVD_PRIVATE
)
5982 code
= OMP_CLAUSE_PRIVATE
;
5983 else if (flags
& GOVD_FIRSTPRIVATE
)
5984 code
= OMP_CLAUSE_FIRSTPRIVATE
;
5988 clause
= build_omp_clause (input_location
, code
);
5989 OMP_CLAUSE_DECL (clause
) = decl
;
5990 OMP_CLAUSE_CHAIN (clause
) = *list_p
;
5992 OMP_CLAUSE_PRIVATE_DEBUG (clause
) = 1;
5993 else if (code
== OMP_CLAUSE_PRIVATE
&& (flags
& GOVD_PRIVATE_OUTER_REF
))
5994 OMP_CLAUSE_PRIVATE_OUTER_REF (clause
) = 1;
5996 lang_hooks
.decls
.omp_finish_clause (clause
);
6002 gimplify_adjust_omp_clauses (tree
*list_p
)
6004 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6007 while ((c
= *list_p
) != NULL
)
6010 bool remove
= false;
6012 switch (OMP_CLAUSE_CODE (c
))
6014 case OMP_CLAUSE_PRIVATE
:
6015 case OMP_CLAUSE_SHARED
:
6016 case OMP_CLAUSE_FIRSTPRIVATE
:
6017 decl
= OMP_CLAUSE_DECL (c
);
6018 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6019 remove
= !(n
->value
& GOVD_SEEN
);
6022 bool shared
= OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
;
6023 if ((n
->value
& GOVD_DEBUG_PRIVATE
)
6024 || lang_hooks
.decls
.omp_private_debug_clause (decl
, shared
))
6026 gcc_assert ((n
->value
& GOVD_DEBUG_PRIVATE
) == 0
6027 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
6029 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_PRIVATE
);
6030 OMP_CLAUSE_PRIVATE_DEBUG (c
) = 1;
6035 case OMP_CLAUSE_LASTPRIVATE
:
6036 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
6037 accurately reflect the presence of a FIRSTPRIVATE clause. */
6038 decl
= OMP_CLAUSE_DECL (c
);
6039 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6040 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
6041 = (n
->value
& GOVD_FIRSTPRIVATE
) != 0;
6044 case OMP_CLAUSE_REDUCTION
:
6045 case OMP_CLAUSE_COPYIN
:
6046 case OMP_CLAUSE_COPYPRIVATE
:
6048 case OMP_CLAUSE_NUM_THREADS
:
6049 case OMP_CLAUSE_SCHEDULE
:
6050 case OMP_CLAUSE_NOWAIT
:
6051 case OMP_CLAUSE_ORDERED
:
6052 case OMP_CLAUSE_DEFAULT
:
6053 case OMP_CLAUSE_UNTIED
:
6054 case OMP_CLAUSE_COLLAPSE
:
6062 *list_p
= OMP_CLAUSE_CHAIN (c
);
6064 list_p
= &OMP_CLAUSE_CHAIN (c
);
6067 /* Add in any implicit data sharing. */
6068 splay_tree_foreach (ctx
->variables
, gimplify_adjust_omp_clauses_1
, list_p
);
6070 gimplify_omp_ctxp
= ctx
->outer_context
;
6071 delete_omp_context (ctx
);
6074 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
6075 gimplification of the body, as well as scanning the body for used
6076 variables. We need to do this scan now, because variable-sized
6077 decls will be decomposed during gimplification. */
6080 gimplify_omp_parallel (tree
*expr_p
, gimple_seq
*pre_p
)
6082 tree expr
= *expr_p
;
6084 gimple_seq body
= NULL
;
6085 struct gimplify_ctx gctx
;
6087 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
), pre_p
,
6088 OMP_PARALLEL_COMBINED (expr
)
6089 ? ORT_COMBINED_PARALLEL
6092 push_gimplify_context (&gctx
);
6094 g
= gimplify_and_return_first (OMP_PARALLEL_BODY (expr
), &body
);
6095 if (gimple_code (g
) == GIMPLE_BIND
)
6096 pop_gimplify_context (g
);
6098 pop_gimplify_context (NULL
);
6100 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
));
6102 g
= gimple_build_omp_parallel (body
,
6103 OMP_PARALLEL_CLAUSES (expr
),
6104 NULL_TREE
, NULL_TREE
);
6105 if (OMP_PARALLEL_COMBINED (expr
))
6106 gimple_omp_set_subcode (g
, GF_OMP_PARALLEL_COMBINED
);
6107 gimplify_seq_add_stmt (pre_p
, g
);
6108 *expr_p
= NULL_TREE
;
6111 /* Gimplify the contents of an OMP_TASK statement. This involves
6112 gimplification of the body, as well as scanning the body for used
6113 variables. We need to do this scan now, because variable-sized
6114 decls will be decomposed during gimplification. */
6117 gimplify_omp_task (tree
*expr_p
, gimple_seq
*pre_p
)
6119 tree expr
= *expr_p
;
6121 gimple_seq body
= NULL
;
6122 struct gimplify_ctx gctx
;
6124 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr
), pre_p
,
6125 find_omp_clause (OMP_TASK_CLAUSES (expr
),
6127 ? ORT_UNTIED_TASK
: ORT_TASK
);
6129 push_gimplify_context (&gctx
);
6131 g
= gimplify_and_return_first (OMP_TASK_BODY (expr
), &body
);
6132 if (gimple_code (g
) == GIMPLE_BIND
)
6133 pop_gimplify_context (g
);
6135 pop_gimplify_context (NULL
);
6137 gimplify_adjust_omp_clauses (&OMP_TASK_CLAUSES (expr
));
6139 g
= gimple_build_omp_task (body
,
6140 OMP_TASK_CLAUSES (expr
),
6141 NULL_TREE
, NULL_TREE
,
6142 NULL_TREE
, NULL_TREE
, NULL_TREE
);
6143 gimplify_seq_add_stmt (pre_p
, g
);
6144 *expr_p
= NULL_TREE
;
6147 /* Gimplify the gross structure of an OMP_FOR statement. */
6149 static enum gimplify_status
6150 gimplify_omp_for (tree
*expr_p
, gimple_seq
*pre_p
)
6152 tree for_stmt
, decl
, var
, t
;
6153 enum gimplify_status ret
= GS_ALL_DONE
;
6154 enum gimplify_status tret
;
6156 gimple_seq for_body
, for_pre_body
;
6161 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
), pre_p
,
6164 /* Handle OMP_FOR_INIT. */
6165 for_pre_body
= NULL
;
6166 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
6167 OMP_FOR_PRE_BODY (for_stmt
) = NULL_TREE
;
6169 for_body
= gimple_seq_alloc ();
6170 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6171 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt
)));
6172 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6173 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt
)));
6174 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6176 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6177 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6178 decl
= TREE_OPERAND (t
, 0);
6179 gcc_assert (DECL_P (decl
));
6180 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl
))
6181 || POINTER_TYPE_P (TREE_TYPE (decl
)));
6183 /* Make sure the iteration variable is private. */
6184 if (omp_is_private (gimplify_omp_ctxp
, decl
))
6185 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
6187 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_PRIVATE
| GOVD_SEEN
);
6189 /* If DECL is not a gimple register, create a temporary variable to act
6190 as an iteration counter. This is valid, since DECL cannot be
6191 modified in the body of the loop. */
6192 if (!is_gimple_reg (decl
))
6194 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
6195 TREE_OPERAND (t
, 0) = var
;
6197 gimplify_seq_add_stmt (&for_body
, gimple_build_assign (decl
, var
));
6199 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
6204 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6205 is_gimple_val
, fb_rvalue
);
6206 ret
= MIN (ret
, tret
);
6207 if (ret
== GS_ERROR
)
6210 /* Handle OMP_FOR_COND. */
6211 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
6212 gcc_assert (COMPARISON_CLASS_P (t
));
6213 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6215 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6216 is_gimple_val
, fb_rvalue
);
6217 ret
= MIN (ret
, tret
);
6219 /* Handle OMP_FOR_INCR. */
6220 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6221 switch (TREE_CODE (t
))
6223 case PREINCREMENT_EXPR
:
6224 case POSTINCREMENT_EXPR
:
6225 t
= build_int_cst (TREE_TYPE (decl
), 1);
6226 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6227 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6228 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6231 case PREDECREMENT_EXPR
:
6232 case POSTDECREMENT_EXPR
:
6233 t
= build_int_cst (TREE_TYPE (decl
), -1);
6234 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6235 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6236 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6240 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6241 TREE_OPERAND (t
, 0) = var
;
6243 t
= TREE_OPERAND (t
, 1);
6244 switch (TREE_CODE (t
))
6247 if (TREE_OPERAND (t
, 1) == decl
)
6249 TREE_OPERAND (t
, 1) = TREE_OPERAND (t
, 0);
6250 TREE_OPERAND (t
, 0) = var
;
6256 case POINTER_PLUS_EXPR
:
6257 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6258 TREE_OPERAND (t
, 0) = var
;
6264 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6265 is_gimple_val
, fb_rvalue
);
6266 ret
= MIN (ret
, tret
);
6273 if (var
!= decl
|| TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1)
6276 for (c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
6277 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6278 && OMP_CLAUSE_DECL (c
) == decl
6279 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) == NULL
)
6281 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6282 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6283 gcc_assert (TREE_OPERAND (t
, 0) == var
);
6284 t
= TREE_OPERAND (t
, 1);
6285 gcc_assert (TREE_CODE (t
) == PLUS_EXPR
6286 || TREE_CODE (t
) == MINUS_EXPR
6287 || TREE_CODE (t
) == POINTER_PLUS_EXPR
);
6288 gcc_assert (TREE_OPERAND (t
, 0) == var
);
6289 t
= build2 (TREE_CODE (t
), TREE_TYPE (decl
), decl
,
6290 TREE_OPERAND (t
, 1));
6291 gimplify_assign (decl
, t
,
6292 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6297 gimplify_and_add (OMP_FOR_BODY (for_stmt
), &for_body
);
6299 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
));
6301 gfor
= gimple_build_omp_for (for_body
, OMP_FOR_CLAUSES (for_stmt
),
6302 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)),
6305 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6307 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6308 gimple_omp_for_set_index (gfor
, i
, TREE_OPERAND (t
, 0));
6309 gimple_omp_for_set_initial (gfor
, i
, TREE_OPERAND (t
, 1));
6310 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
6311 gimple_omp_for_set_cond (gfor
, i
, TREE_CODE (t
));
6312 gimple_omp_for_set_final (gfor
, i
, TREE_OPERAND (t
, 1));
6313 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6314 gimple_omp_for_set_incr (gfor
, i
, TREE_OPERAND (t
, 1));
6317 gimplify_seq_add_stmt (pre_p
, gfor
);
6318 return ret
== GS_ALL_DONE
? GS_ALL_DONE
: GS_ERROR
;
6321 /* Gimplify the gross structure of other OpenMP worksharing constructs.
6322 In particular, OMP_SECTIONS and OMP_SINGLE. */
6325 gimplify_omp_workshare (tree
*expr_p
, gimple_seq
*pre_p
)
6327 tree expr
= *expr_p
;
6329 gimple_seq body
= NULL
;
6331 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr
), pre_p
, ORT_WORKSHARE
);
6332 gimplify_and_add (OMP_BODY (expr
), &body
);
6333 gimplify_adjust_omp_clauses (&OMP_CLAUSES (expr
));
6335 if (TREE_CODE (expr
) == OMP_SECTIONS
)
6336 stmt
= gimple_build_omp_sections (body
, OMP_CLAUSES (expr
));
6337 else if (TREE_CODE (expr
) == OMP_SINGLE
)
6338 stmt
= gimple_build_omp_single (body
, OMP_CLAUSES (expr
));
6342 gimplify_seq_add_stmt (pre_p
, stmt
);
6345 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
6346 stabilized the lhs of the atomic operation as *ADDR. Return true if
6347 EXPR is this stabilized form. */
6350 goa_lhs_expr_p (tree expr
, tree addr
)
6352 /* Also include casts to other type variants. The C front end is fond
6353 of adding these for e.g. volatile variables. This is like
6354 STRIP_TYPE_NOPS but includes the main variant lookup. */
6355 STRIP_USELESS_TYPE_CONVERSION (expr
);
6357 if (TREE_CODE (expr
) == INDIRECT_REF
)
6359 expr
= TREE_OPERAND (expr
, 0);
6361 && (CONVERT_EXPR_P (expr
)
6362 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
6363 && TREE_CODE (expr
) == TREE_CODE (addr
)
6364 && types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (addr
)))
6366 expr
= TREE_OPERAND (expr
, 0);
6367 addr
= TREE_OPERAND (addr
, 0);
6371 return (TREE_CODE (addr
) == ADDR_EXPR
6372 && TREE_CODE (expr
) == ADDR_EXPR
6373 && TREE_OPERAND (addr
, 0) == TREE_OPERAND (expr
, 0));
6375 if (TREE_CODE (addr
) == ADDR_EXPR
&& expr
== TREE_OPERAND (addr
, 0))
6380 /* Walk *EXPR_P and replace
6381 appearances of *LHS_ADDR with LHS_VAR. If an expression does not involve
6382 the lhs, evaluate it into a temporary. Return 1 if the lhs appeared as
6383 a subexpression, 0 if it did not, or -1 if an error was encountered. */
6386 goa_stabilize_expr (tree
*expr_p
, gimple_seq
*pre_p
, tree lhs_addr
,
6389 tree expr
= *expr_p
;
6392 if (goa_lhs_expr_p (expr
, lhs_addr
))
6397 if (is_gimple_val (expr
))
6401 switch (TREE_CODE_CLASS (TREE_CODE (expr
)))
6404 case tcc_comparison
:
6405 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
, lhs_addr
,
6408 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
, lhs_addr
,
6411 case tcc_expression
:
6412 switch (TREE_CODE (expr
))
6414 case TRUTH_ANDIF_EXPR
:
6415 case TRUTH_ORIF_EXPR
:
6416 case TRUTH_AND_EXPR
:
6418 case TRUTH_XOR_EXPR
:
6419 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
,
6421 case TRUTH_NOT_EXPR
:
6422 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
6435 enum gimplify_status gs
;
6436 gs
= gimplify_expr (expr_p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
6437 if (gs
!= GS_ALL_DONE
)
6445 /* Gimplify an OMP_ATOMIC statement. */
6447 static enum gimplify_status
6448 gimplify_omp_atomic (tree
*expr_p
, gimple_seq
*pre_p
)
6450 tree addr
= TREE_OPERAND (*expr_p
, 0);
6451 tree rhs
= TREE_OPERAND (*expr_p
, 1);
6452 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
6455 tmp_load
= create_tmp_reg (type
, NULL
);
6456 if (goa_stabilize_expr (&rhs
, pre_p
, addr
, tmp_load
) < 0)
6459 if (gimplify_expr (&addr
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
6463 gimplify_seq_add_stmt (pre_p
, gimple_build_omp_atomic_load (tmp_load
, addr
));
6464 if (gimplify_expr (&rhs
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
6467 gimplify_seq_add_stmt (pre_p
, gimple_build_omp_atomic_store (rhs
));
6474 /* Converts the GENERIC expression tree *EXPR_P to GIMPLE. If the
6475 expression produces a value to be used as an operand inside a GIMPLE
6476 statement, the value will be stored back in *EXPR_P. This value will
6477 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
6478 an SSA_NAME. The corresponding sequence of GIMPLE statements is
6479 emitted in PRE_P and POST_P.
6481 Additionally, this process may overwrite parts of the input
6482 expression during gimplification. Ideally, it should be
6483 possible to do non-destructive gimplification.
6485 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
6486 the expression needs to evaluate to a value to be used as
6487 an operand in a GIMPLE statement, this value will be stored in
6488 *EXPR_P on exit. This happens when the caller specifies one
6489 of fb_lvalue or fb_rvalue fallback flags.
6491 PRE_P will contain the sequence of GIMPLE statements corresponding
6492 to the evaluation of EXPR and all the side-effects that must
6493 be executed before the main expression. On exit, the last
6494 statement of PRE_P is the core statement being gimplified. For
6495 instance, when gimplifying 'if (++a)' the last statement in
6496 PRE_P will be 'if (t.1)' where t.1 is the result of
6497 pre-incrementing 'a'.
6499 POST_P will contain the sequence of GIMPLE statements corresponding
6500 to the evaluation of all the side-effects that must be executed
6501 after the main expression. If this is NULL, the post
6502 side-effects are stored at the end of PRE_P.
6504 The reason why the output is split in two is to handle post
6505 side-effects explicitly. In some cases, an expression may have
6506 inner and outer post side-effects which need to be emitted in
6507 an order different from the one given by the recursive
6508 traversal. For instance, for the expression (*p--)++ the post
6509 side-effects of '--' must actually occur *after* the post
6510 side-effects of '++'. However, gimplification will first visit
6511 the inner expression, so if a separate POST sequence was not
6512 used, the resulting sequence would be:
6519 However, the post-decrement operation in line #2 must not be
6520 evaluated until after the store to *p at line #4, so the
6521 correct sequence should be:
6528 So, by specifying a separate post queue, it is possible
6529 to emit the post side-effects in the correct order.
6530 If POST_P is NULL, an internal queue will be used. Before
6531 returning to the caller, the sequence POST_P is appended to
6532 the main output sequence PRE_P.
6534 GIMPLE_TEST_F points to a function that takes a tree T and
6535 returns nonzero if T is in the GIMPLE form requested by the
6536 caller. The GIMPLE predicates are in gimple.c.
6538 FALLBACK tells the function what sort of a temporary we want if
6539 gimplification cannot produce an expression that complies with
6542 fb_none means that no temporary should be generated
6543 fb_rvalue means that an rvalue is OK to generate
6544 fb_lvalue means that an lvalue is OK to generate
6545 fb_either means that either is OK, but an lvalue is preferable.
6546 fb_mayfail means that gimplification may fail (in which case
6547 GS_ERROR will be returned)
6549 The return value is either GS_ERROR or GS_ALL_DONE, since this
6550 function iterates until EXPR is completely gimplified or an error
6553 enum gimplify_status
6554 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
6555 bool (*gimple_test_f
) (tree
), fallback_t fallback
)
6558 gimple_seq internal_pre
= NULL
;
6559 gimple_seq internal_post
= NULL
;
6562 location_t saved_location
;
6563 enum gimplify_status ret
;
6564 gimple_stmt_iterator pre_last_gsi
, post_last_gsi
;
6566 save_expr
= *expr_p
;
6567 if (save_expr
== NULL_TREE
)
6570 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
6571 is_statement
= gimple_test_f
== is_gimple_stmt
;
6575 /* Consistency checks. */
6576 if (gimple_test_f
== is_gimple_reg
)
6577 gcc_assert (fallback
& (fb_rvalue
| fb_lvalue
));
6578 else if (gimple_test_f
== is_gimple_val
6579 || gimple_test_f
== is_gimple_call_addr
6580 || gimple_test_f
== is_gimple_condexpr
6581 || gimple_test_f
== is_gimple_mem_rhs
6582 || gimple_test_f
== is_gimple_mem_rhs_or_call
6583 || gimple_test_f
== is_gimple_reg_rhs
6584 || gimple_test_f
== is_gimple_reg_rhs_or_call
6585 || gimple_test_f
== is_gimple_asm_val
6586 || gimple_test_f
== is_gimple_mem_ref_addr
)
6587 gcc_assert (fallback
& fb_rvalue
);
6588 else if (gimple_test_f
== is_gimple_min_lval
6589 || gimple_test_f
== is_gimple_lvalue
)
6590 gcc_assert (fallback
& fb_lvalue
);
6591 else if (gimple_test_f
== is_gimple_addressable
)
6592 gcc_assert (fallback
& fb_either
);
6593 else if (gimple_test_f
== is_gimple_stmt
)
6594 gcc_assert (fallback
== fb_none
);
6597 /* We should have recognized the GIMPLE_TEST_F predicate to
6598 know what kind of fallback to use in case a temporary is
6599 needed to hold the value or address of *EXPR_P. */
6603 /* We used to check the predicate here and return immediately if it
6604 succeeds. This is wrong; the design is for gimplification to be
6605 idempotent, and for the predicates to only test for valid forms, not
6606 whether they are fully simplified. */
6608 pre_p
= &internal_pre
;
6611 post_p
= &internal_post
;
6613 /* Remember the last statements added to PRE_P and POST_P. Every
6614 new statement added by the gimplification helpers needs to be
6615 annotated with location information. To centralize the
6616 responsibility, we remember the last statement that had been
6617 added to both queues before gimplifying *EXPR_P. If
6618 gimplification produces new statements in PRE_P and POST_P, those
6619 statements will be annotated with the same location information
6621 pre_last_gsi
= gsi_last (*pre_p
);
6622 post_last_gsi
= gsi_last (*post_p
);
6624 saved_location
= input_location
;
6625 if (save_expr
!= error_mark_node
6626 && EXPR_HAS_LOCATION (*expr_p
))
6627 input_location
= EXPR_LOCATION (*expr_p
);
6629 /* Loop over the specific gimplifiers until the toplevel node
6630 remains the same. */
6633 /* Strip away as many useless type conversions as possible
6635 STRIP_USELESS_TYPE_CONVERSION (*expr_p
);
6637 /* Remember the expr. */
6638 save_expr
= *expr_p
;
6640 /* Die, die, die, my darling. */
6641 if (save_expr
== error_mark_node
6642 || (TREE_TYPE (save_expr
)
6643 && TREE_TYPE (save_expr
) == error_mark_node
))
6649 /* Do any language-specific gimplification. */
6650 ret
= ((enum gimplify_status
)
6651 lang_hooks
.gimplify_expr (expr_p
, pre_p
, post_p
));
6654 if (*expr_p
== NULL_TREE
)
6656 if (*expr_p
!= save_expr
)
6659 else if (ret
!= GS_UNHANDLED
)
6662 /* Make sure that all the cases set 'ret' appropriately. */
6664 switch (TREE_CODE (*expr_p
))
6666 /* First deal with the special cases. */
6668 case POSTINCREMENT_EXPR
:
6669 case POSTDECREMENT_EXPR
:
6670 case PREINCREMENT_EXPR
:
6671 case PREDECREMENT_EXPR
:
6672 ret
= gimplify_self_mod_expr (expr_p
, pre_p
, post_p
,
6673 fallback
!= fb_none
);
6677 case ARRAY_RANGE_REF
:
6681 case VIEW_CONVERT_EXPR
:
6682 ret
= gimplify_compound_lval (expr_p
, pre_p
, post_p
,
6683 fallback
? fallback
: fb_rvalue
);
6687 ret
= gimplify_cond_expr (expr_p
, pre_p
, fallback
);
6689 /* C99 code may assign to an array in a structure value of a
6690 conditional expression, and this has undefined behavior
6691 only on execution, so create a temporary if an lvalue is
6693 if (fallback
== fb_lvalue
)
6695 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
6696 mark_addressable (*expr_p
);
6702 ret
= gimplify_call_expr (expr_p
, pre_p
, fallback
!= fb_none
);
6704 /* C99 code may assign to an array in a structure returned
6705 from a function, and this has undefined behavior only on
6706 execution, so create a temporary if an lvalue is
6708 if (fallback
== fb_lvalue
)
6710 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
6711 mark_addressable (*expr_p
);
6720 ret
= gimplify_compound_expr (expr_p
, pre_p
, fallback
!= fb_none
);
6723 case COMPOUND_LITERAL_EXPR
:
6724 ret
= gimplify_compound_literal_expr (expr_p
, pre_p
);
6729 ret
= gimplify_modify_expr (expr_p
, pre_p
, post_p
,
6730 fallback
!= fb_none
);
6733 case TRUTH_ANDIF_EXPR
:
6734 case TRUTH_ORIF_EXPR
:
6735 /* Pass the source location of the outer expression. */
6736 ret
= gimplify_boolean_expr (expr_p
, saved_location
);
6739 case TRUTH_NOT_EXPR
:
6740 if (TREE_CODE (TREE_TYPE (*expr_p
)) != BOOLEAN_TYPE
)
6742 tree type
= TREE_TYPE (*expr_p
);
6743 *expr_p
= fold_convert (type
, gimple_boolify (*expr_p
));
6748 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
6749 is_gimple_val
, fb_rvalue
);
6750 recalculate_side_effects (*expr_p
);
6754 ret
= gimplify_addr_expr (expr_p
, pre_p
, post_p
);
6758 ret
= gimplify_va_arg_expr (expr_p
, pre_p
, post_p
);
6762 if (IS_EMPTY_STMT (*expr_p
))
6768 if (VOID_TYPE_P (TREE_TYPE (*expr_p
))
6769 || fallback
== fb_none
)
6771 /* Just strip a conversion to void (or in void context) and
6773 *expr_p
= TREE_OPERAND (*expr_p
, 0);
6778 ret
= gimplify_conversion (expr_p
);
6779 if (ret
== GS_ERROR
)
6781 if (*expr_p
!= save_expr
)
6785 case FIX_TRUNC_EXPR
:
6786 /* unary_expr: ... | '(' cast ')' val | ... */
6787 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
6788 is_gimple_val
, fb_rvalue
);
6789 recalculate_side_effects (*expr_p
);
6794 bool volatilep
= TREE_THIS_VOLATILE (*expr_p
);
6795 bool notrap
= TREE_THIS_NOTRAP (*expr_p
);
6796 tree saved_ptr_type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 0));
6798 *expr_p
= fold_indirect_ref_loc (input_location
, *expr_p
);
6799 if (*expr_p
!= save_expr
)
6805 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
6806 is_gimple_reg
, fb_rvalue
);
6807 if (ret
== GS_ERROR
)
6810 recalculate_side_effects (*expr_p
);
6811 *expr_p
= fold_build2_loc (input_location
, MEM_REF
,
6812 TREE_TYPE (*expr_p
),
6813 TREE_OPERAND (*expr_p
, 0),
6814 build_int_cst (saved_ptr_type
, 0));
6815 TREE_THIS_VOLATILE (*expr_p
) = volatilep
;
6816 TREE_THIS_NOTRAP (*expr_p
) = notrap
;
6821 /* We arrive here through the various re-gimplifcation paths. */
6823 /* First try re-folding the whole thing. */
6824 tmp
= fold_binary (MEM_REF
, TREE_TYPE (*expr_p
),
6825 TREE_OPERAND (*expr_p
, 0),
6826 TREE_OPERAND (*expr_p
, 1));
6830 recalculate_side_effects (*expr_p
);
6834 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
6835 is_gimple_mem_ref_addr
, fb_rvalue
);
6836 if (ret
== GS_ERROR
)
6838 recalculate_side_effects (*expr_p
);
6842 /* Constants need not be gimplified. */
6853 /* If we require an lvalue, such as for ADDR_EXPR, retain the
6854 CONST_DECL node. Otherwise the decl is replaceable by its
6856 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
6857 if (fallback
& fb_lvalue
)
6861 *expr_p
= DECL_INITIAL (*expr_p
);
6867 ret
= gimplify_decl_expr (expr_p
, pre_p
);
6871 ret
= gimplify_bind_expr (expr_p
, pre_p
);
6875 ret
= gimplify_loop_expr (expr_p
, pre_p
);
6879 ret
= gimplify_switch_expr (expr_p
, pre_p
);
6883 ret
= gimplify_exit_expr (expr_p
);
6887 /* If the target is not LABEL, then it is a computed jump
6888 and the target needs to be gimplified. */
6889 if (TREE_CODE (GOTO_DESTINATION (*expr_p
)) != LABEL_DECL
)
6891 ret
= gimplify_expr (&GOTO_DESTINATION (*expr_p
), pre_p
,
6892 NULL
, is_gimple_val
, fb_rvalue
);
6893 if (ret
== GS_ERROR
)
6896 gimplify_seq_add_stmt (pre_p
,
6897 gimple_build_goto (GOTO_DESTINATION (*expr_p
)));
6902 gimplify_seq_add_stmt (pre_p
,
6903 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p
),
6904 PREDICT_EXPR_OUTCOME (*expr_p
)));
6910 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p
))
6911 == current_function_decl
);
6912 gimplify_seq_add_stmt (pre_p
,
6913 gimple_build_label (LABEL_EXPR_LABEL (*expr_p
)));
6916 case CASE_LABEL_EXPR
:
6917 ret
= gimplify_case_label_expr (expr_p
, pre_p
);
6921 ret
= gimplify_return_expr (*expr_p
, pre_p
);
6925 /* Don't reduce this in place; let gimplify_init_constructor work its
6926 magic. Buf if we're just elaborating this for side effects, just
6927 gimplify any element that has side-effects. */
6928 if (fallback
== fb_none
)
6930 unsigned HOST_WIDE_INT ix
;
6932 tree temp
= NULL_TREE
;
6933 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p
), ix
, val
)
6934 if (TREE_SIDE_EFFECTS (val
))
6935 append_to_statement_list (val
, &temp
);
6938 ret
= temp
? GS_OK
: GS_ALL_DONE
;
6940 /* C99 code may assign to an array in a constructed
6941 structure or union, and this has undefined behavior only
6942 on execution, so create a temporary if an lvalue is
6944 else if (fallback
== fb_lvalue
)
6946 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
6947 mark_addressable (*expr_p
);
6954 /* The following are special cases that are not handled by the
6955 original GIMPLE grammar. */
6957 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
6960 ret
= gimplify_save_expr (expr_p
, pre_p
, post_p
);
6965 enum gimplify_status r0
, r1
, r2
;
6967 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
6968 post_p
, is_gimple_lvalue
, fb_either
);
6969 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
6970 post_p
, is_gimple_val
, fb_rvalue
);
6971 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
6972 post_p
, is_gimple_val
, fb_rvalue
);
6973 recalculate_side_effects (*expr_p
);
6975 ret
= MIN (r0
, MIN (r1
, r2
));
6979 case TARGET_MEM_REF
:
6981 enum gimplify_status r0
= GS_ALL_DONE
, r1
= GS_ALL_DONE
;
6983 if (TMR_BASE (*expr_p
))
6984 r0
= gimplify_expr (&TMR_BASE (*expr_p
), pre_p
,
6985 post_p
, is_gimple_mem_ref_addr
, fb_either
);
6986 if (TMR_INDEX (*expr_p
))
6987 r1
= gimplify_expr (&TMR_INDEX (*expr_p
), pre_p
,
6988 post_p
, is_gimple_val
, fb_rvalue
);
6989 if (TMR_INDEX2 (*expr_p
))
6990 r1
= gimplify_expr (&TMR_INDEX2 (*expr_p
), pre_p
,
6991 post_p
, is_gimple_val
, fb_rvalue
);
6992 /* TMR_STEP and TMR_OFFSET are always integer constants. */
6997 case NON_LVALUE_EXPR
:
6998 /* This should have been stripped above. */
7002 ret
= gimplify_asm_expr (expr_p
, pre_p
, post_p
);
7005 case TRY_FINALLY_EXPR
:
7006 case TRY_CATCH_EXPR
:
7008 gimple_seq eval
, cleanup
;
7011 eval
= cleanup
= NULL
;
7012 gimplify_and_add (TREE_OPERAND (*expr_p
, 0), &eval
);
7013 gimplify_and_add (TREE_OPERAND (*expr_p
, 1), &cleanup
);
7014 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
7015 if (gimple_seq_empty_p (cleanup
))
7017 gimple_seq_add_seq (pre_p
, eval
);
7021 try_
= gimple_build_try (eval
, cleanup
,
7022 TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
7023 ? GIMPLE_TRY_FINALLY
7024 : GIMPLE_TRY_CATCH
);
7025 if (TREE_CODE (*expr_p
) == TRY_CATCH_EXPR
)
7026 gimple_try_set_catch_is_cleanup (try_
,
7027 TRY_CATCH_IS_CLEANUP (*expr_p
));
7028 gimplify_seq_add_stmt (pre_p
, try_
);
7033 case CLEANUP_POINT_EXPR
:
7034 ret
= gimplify_cleanup_point_expr (expr_p
, pre_p
);
7038 ret
= gimplify_target_expr (expr_p
, pre_p
, post_p
);
7044 gimple_seq handler
= NULL
;
7045 gimplify_and_add (CATCH_BODY (*expr_p
), &handler
);
7046 c
= gimple_build_catch (CATCH_TYPES (*expr_p
), handler
);
7047 gimplify_seq_add_stmt (pre_p
, c
);
7052 case EH_FILTER_EXPR
:
7055 gimple_seq failure
= NULL
;
7057 gimplify_and_add (EH_FILTER_FAILURE (*expr_p
), &failure
);
7058 ehf
= gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p
), failure
);
7059 gimple_set_no_warning (ehf
, TREE_NO_WARNING (*expr_p
));
7060 gimplify_seq_add_stmt (pre_p
, ehf
);
7067 enum gimplify_status r0
, r1
;
7068 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
,
7069 post_p
, is_gimple_val
, fb_rvalue
);
7070 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
,
7071 post_p
, is_gimple_val
, fb_rvalue
);
7072 TREE_SIDE_EFFECTS (*expr_p
) = 0;
7078 /* We get here when taking the address of a label. We mark
7079 the label as "forced"; meaning it can never be removed and
7080 it is a potential target for any computed goto. */
7081 FORCED_LABEL (*expr_p
) = 1;
7085 case STATEMENT_LIST
:
7086 ret
= gimplify_statement_list (expr_p
, pre_p
);
7089 case WITH_SIZE_EXPR
:
7091 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7092 post_p
== &internal_post
? NULL
: post_p
,
7093 gimple_test_f
, fallback
);
7094 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
7095 is_gimple_val
, fb_rvalue
);
7102 ret
= gimplify_var_or_parm_decl (expr_p
);
7106 /* When within an OpenMP context, notice uses of variables. */
7107 if (gimplify_omp_ctxp
)
7108 omp_notice_variable (gimplify_omp_ctxp
, *expr_p
, true);
7113 /* Allow callbacks into the gimplifier during optimization. */
7118 gimplify_omp_parallel (expr_p
, pre_p
);
7123 gimplify_omp_task (expr_p
, pre_p
);
7128 ret
= gimplify_omp_for (expr_p
, pre_p
);
7133 gimplify_omp_workshare (expr_p
, pre_p
);
7142 gimple_seq body
= NULL
;
7145 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
7146 switch (TREE_CODE (*expr_p
))
7149 g
= gimple_build_omp_section (body
);
7152 g
= gimple_build_omp_master (body
);
7155 g
= gimple_build_omp_ordered (body
);
7158 g
= gimple_build_omp_critical (body
,
7159 OMP_CRITICAL_NAME (*expr_p
));
7164 gimplify_seq_add_stmt (pre_p
, g
);
7170 ret
= gimplify_omp_atomic (expr_p
, pre_p
);
7173 case TRUTH_AND_EXPR
:
7175 case TRUTH_XOR_EXPR
:
7176 /* Classified as tcc_expression. */
7180 /* Classified as tcc_expression. */
7183 case POINTER_PLUS_EXPR
:
7184 /* Convert ((type *)A)+offset into &A->field_of_type_and_offset.
7185 The second is gimple immediate saving a need for extra statement.
7187 if (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == INTEGER_CST
7188 && (tmp
= maybe_fold_offset_to_address
7189 (EXPR_LOCATION (*expr_p
),
7190 TREE_OPERAND (*expr_p
, 0), TREE_OPERAND (*expr_p
, 1),
7191 TREE_TYPE (*expr_p
))))
7197 /* Convert (void *)&a + 4 into (void *)&a[1]. */
7198 if (TREE_CODE (TREE_OPERAND (*expr_p
, 0)) == NOP_EXPR
7199 && TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == INTEGER_CST
7200 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p
,
7202 && (tmp
= maybe_fold_offset_to_address
7203 (EXPR_LOCATION (*expr_p
),
7204 TREE_OPERAND (TREE_OPERAND (*expr_p
, 0), 0),
7205 TREE_OPERAND (*expr_p
, 1),
7206 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p
, 0),
7209 *expr_p
= fold_convert (TREE_TYPE (*expr_p
), tmp
);
7216 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p
)))
7218 case tcc_comparison
:
7219 /* Handle comparison of objects of non scalar mode aggregates
7220 with a call to memcmp. It would be nice to only have to do
7221 this for variable-sized objects, but then we'd have to allow
7222 the same nest of reference nodes we allow for MODIFY_EXPR and
7225 Compare scalar mode aggregates as scalar mode values. Using
7226 memcmp for them would be very inefficient at best, and is
7227 plain wrong if bitfields are involved. */
7229 tree type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 1));
7231 if (!AGGREGATE_TYPE_P (type
))
7233 else if (TYPE_MODE (type
) != BLKmode
)
7234 ret
= gimplify_scalar_mode_aggregate_compare (expr_p
);
7236 ret
= gimplify_variable_sized_compare (expr_p
);
7241 /* If *EXPR_P does not need to be special-cased, handle it
7242 according to its class. */
7244 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7245 post_p
, is_gimple_val
, fb_rvalue
);
7251 enum gimplify_status r0
, r1
;
7253 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7254 post_p
, is_gimple_val
, fb_rvalue
);
7255 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7256 post_p
, is_gimple_val
, fb_rvalue
);
7264 enum gimplify_status r0
, r1
, r2
;
7266 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7267 post_p
, is_gimple_val
, fb_rvalue
);
7268 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7269 post_p
, is_gimple_val
, fb_rvalue
);
7270 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
7271 post_p
, is_gimple_val
, fb_rvalue
);
7273 ret
= MIN (MIN (r0
, r1
), r2
);
7277 case tcc_declaration
:
7280 goto dont_recalculate
;
7286 recalculate_side_effects (*expr_p
);
7292 gcc_assert (*expr_p
|| ret
!= GS_OK
);
7294 while (ret
== GS_OK
);
7296 /* If we encountered an error_mark somewhere nested inside, either
7297 stub out the statement or propagate the error back out. */
7298 if (ret
== GS_ERROR
)
7305 /* This was only valid as a return value from the langhook, which
7306 we handled. Make sure it doesn't escape from any other context. */
7307 gcc_assert (ret
!= GS_UNHANDLED
);
7309 if (fallback
== fb_none
&& *expr_p
&& !is_gimple_stmt (*expr_p
))
7311 /* We aren't looking for a value, and we don't have a valid
7312 statement. If it doesn't have side-effects, throw it away. */
7313 if (!TREE_SIDE_EFFECTS (*expr_p
))
7315 else if (!TREE_THIS_VOLATILE (*expr_p
))
7317 /* This is probably a _REF that contains something nested that
7318 has side effects. Recurse through the operands to find it. */
7319 enum tree_code code
= TREE_CODE (*expr_p
);
7326 case VIEW_CONVERT_EXPR
:
7327 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7328 gimple_test_f
, fallback
);
7332 case ARRAY_RANGE_REF
:
7333 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7334 gimple_test_f
, fallback
);
7335 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
7336 gimple_test_f
, fallback
);
7340 /* Anything else with side-effects must be converted to
7341 a valid statement before we get here. */
7347 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p
))
7348 && TYPE_MODE (TREE_TYPE (*expr_p
)) != BLKmode
)
7350 /* Historically, the compiler has treated a bare reference
7351 to a non-BLKmode volatile lvalue as forcing a load. */
7352 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p
));
7354 /* Normally, we do not want to create a temporary for a
7355 TREE_ADDRESSABLE type because such a type should not be
7356 copied by bitwise-assignment. However, we make an
7357 exception here, as all we are doing here is ensuring that
7358 we read the bytes that make up the type. We use
7359 create_tmp_var_raw because create_tmp_var will abort when
7360 given a TREE_ADDRESSABLE type. */
7361 tree tmp
= create_tmp_var_raw (type
, "vol");
7362 gimple_add_tmp_var (tmp
);
7363 gimplify_assign (tmp
, *expr_p
, pre_p
);
7367 /* We can't do anything useful with a volatile reference to
7368 an incomplete type, so just throw it away. Likewise for
7369 a BLKmode type, since any implicit inner load should
7370 already have been turned into an explicit one by the
7371 gimplification process. */
7375 /* If we are gimplifying at the statement level, we're done. Tack
7376 everything together and return. */
7377 if (fallback
== fb_none
|| is_statement
)
7379 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
7380 it out for GC to reclaim it. */
7381 *expr_p
= NULL_TREE
;
7383 if (!gimple_seq_empty_p (internal_pre
)
7384 || !gimple_seq_empty_p (internal_post
))
7386 gimplify_seq_add_seq (&internal_pre
, internal_post
);
7387 gimplify_seq_add_seq (pre_p
, internal_pre
);
7390 /* The result of gimplifying *EXPR_P is going to be the last few
7391 statements in *PRE_P and *POST_P. Add location information
7392 to all the statements that were added by the gimplification
7394 if (!gimple_seq_empty_p (*pre_p
))
7395 annotate_all_with_location_after (*pre_p
, pre_last_gsi
, input_location
);
7397 if (!gimple_seq_empty_p (*post_p
))
7398 annotate_all_with_location_after (*post_p
, post_last_gsi
,
7404 #ifdef ENABLE_GIMPLE_CHECKING
7407 enum tree_code code
= TREE_CODE (*expr_p
);
7408 /* These expressions should already be in gimple IR form. */
7409 gcc_assert (code
!= MODIFY_EXPR
7411 && code
!= BIND_EXPR
7412 && code
!= CATCH_EXPR
7413 && (code
!= COND_EXPR
|| gimplify_ctxp
->allow_rhs_cond_expr
)
7414 && code
!= EH_FILTER_EXPR
7415 && code
!= GOTO_EXPR
7416 && code
!= LABEL_EXPR
7417 && code
!= LOOP_EXPR
7418 && code
!= SWITCH_EXPR
7419 && code
!= TRY_FINALLY_EXPR
7420 && code
!= OMP_CRITICAL
7422 && code
!= OMP_MASTER
7423 && code
!= OMP_ORDERED
7424 && code
!= OMP_PARALLEL
7425 && code
!= OMP_SECTIONS
7426 && code
!= OMP_SECTION
7427 && code
!= OMP_SINGLE
);
7431 /* Otherwise we're gimplifying a subexpression, so the resulting
7432 value is interesting. If it's a valid operand that matches
7433 GIMPLE_TEST_F, we're done. Unless we are handling some
7434 post-effects internally; if that's the case, we need to copy into
7435 a temporary before adding the post-effects to POST_P. */
7436 if (gimple_seq_empty_p (internal_post
) && (*gimple_test_f
) (*expr_p
))
7439 /* Otherwise, we need to create a new temporary for the gimplified
7442 /* We can't return an lvalue if we have an internal postqueue. The
7443 object the lvalue refers to would (probably) be modified by the
7444 postqueue; we need to copy the value out first, which means an
7446 if ((fallback
& fb_lvalue
)
7447 && gimple_seq_empty_p (internal_post
)
7448 && is_gimple_addressable (*expr_p
))
7450 /* An lvalue will do. Take the address of the expression, store it
7451 in a temporary, and replace the expression with an INDIRECT_REF of
7453 tmp
= build_fold_addr_expr_loc (input_location
, *expr_p
);
7454 gimplify_expr (&tmp
, pre_p
, post_p
, is_gimple_reg
, fb_rvalue
);
7455 *expr_p
= build_simple_mem_ref (tmp
);
7457 else if ((fallback
& fb_rvalue
) && is_gimple_reg_rhs_or_call (*expr_p
))
7459 /* An rvalue will do. Assign the gimplified expression into a
7460 new temporary TMP and replace the original expression with
7461 TMP. First, make sure that the expression has a type so that
7462 it can be assigned into a temporary. */
7463 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p
)));
7465 if (!gimple_seq_empty_p (internal_post
) || (fallback
& fb_lvalue
))
7466 /* The postqueue might change the value of the expression between
7467 the initialization and use of the temporary, so we can't use a
7468 formal temp. FIXME do we care? */
7470 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7471 if (TREE_CODE (TREE_TYPE (*expr_p
)) == COMPLEX_TYPE
7472 || TREE_CODE (TREE_TYPE (*expr_p
)) == VECTOR_TYPE
)
7473 DECL_GIMPLE_REG_P (*expr_p
) = 1;
7476 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
7480 #ifdef ENABLE_GIMPLE_CHECKING
7481 if (!(fallback
& fb_mayfail
))
7483 fprintf (stderr
, "gimplification failed:\n");
7484 print_generic_expr (stderr
, *expr_p
, 0);
7485 debug_tree (*expr_p
);
7486 internal_error ("gimplification failed");
7489 gcc_assert (fallback
& fb_mayfail
);
7491 /* If this is an asm statement, and the user asked for the
7492 impossible, don't die. Fail and let gimplify_asm_expr
7498 /* Make sure the temporary matches our predicate. */
7499 gcc_assert ((*gimple_test_f
) (*expr_p
));
7501 if (!gimple_seq_empty_p (internal_post
))
7503 annotate_all_with_location (internal_post
, input_location
);
7504 gimplify_seq_add_seq (pre_p
, internal_post
);
7508 input_location
= saved_location
;
7512 /* Look through TYPE for variable-sized objects and gimplify each such
7513 size that we find. Add to LIST_P any statements generated. */
7516 gimplify_type_sizes (tree type
, gimple_seq
*list_p
)
7520 if (type
== NULL
|| type
== error_mark_node
)
7523 /* We first do the main variant, then copy into any other variants. */
7524 type
= TYPE_MAIN_VARIANT (type
);
7526 /* Avoid infinite recursion. */
7527 if (TYPE_SIZES_GIMPLIFIED (type
))
7530 TYPE_SIZES_GIMPLIFIED (type
) = 1;
7532 switch (TREE_CODE (type
))
7538 case FIXED_POINT_TYPE
:
7539 gimplify_one_sizepos (&TYPE_MIN_VALUE (type
), list_p
);
7540 gimplify_one_sizepos (&TYPE_MAX_VALUE (type
), list_p
);
7542 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
7544 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (type
);
7545 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (type
);
7550 /* These types may not have declarations, so handle them here. */
7551 gimplify_type_sizes (TREE_TYPE (type
), list_p
);
7552 gimplify_type_sizes (TYPE_DOMAIN (type
), list_p
);
7553 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
7554 with assigned stack slots, for -O1+ -g they should be tracked
7556 if (!(TYPE_NAME (type
)
7557 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
7558 && DECL_IGNORED_P (TYPE_NAME (type
)))
7559 && TYPE_DOMAIN (type
)
7560 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type
)))
7562 t
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
7563 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
7564 DECL_IGNORED_P (t
) = 0;
7565 t
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
7566 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
7567 DECL_IGNORED_P (t
) = 0;
7573 case QUAL_UNION_TYPE
:
7574 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
7575 if (TREE_CODE (field
) == FIELD_DECL
)
7577 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field
), list_p
);
7578 gimplify_one_sizepos (&DECL_SIZE (field
), list_p
);
7579 gimplify_one_sizepos (&DECL_SIZE_UNIT (field
), list_p
);
7580 gimplify_type_sizes (TREE_TYPE (field
), list_p
);
7585 case REFERENCE_TYPE
:
7586 /* We used to recurse on the pointed-to type here, which turned out to
7587 be incorrect because its definition might refer to variables not
7588 yet initialized at this point if a forward declaration is involved.
7590 It was actually useful for anonymous pointed-to types to ensure
7591 that the sizes evaluation dominates every possible later use of the
7592 values. Restricting to such types here would be safe since there
7593 is no possible forward declaration around, but would introduce an
7594 undesirable middle-end semantic to anonymity. We then defer to
7595 front-ends the responsibility of ensuring that the sizes are
7596 evaluated both early and late enough, e.g. by attaching artificial
7597 type declarations to the tree. */
7604 gimplify_one_sizepos (&TYPE_SIZE (type
), list_p
);
7605 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type
), list_p
);
7607 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
7609 TYPE_SIZE (t
) = TYPE_SIZE (type
);
7610 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (type
);
7611 TYPE_SIZES_GIMPLIFIED (t
) = 1;
7615 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
7616 a size or position, has had all of its SAVE_EXPRs evaluated.
7617 We add any required statements to *STMT_P. */
7620 gimplify_one_sizepos (tree
*expr_p
, gimple_seq
*stmt_p
)
7622 tree type
, expr
= *expr_p
;
7624 /* We don't do anything if the value isn't there, is constant, or contains
7625 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
7626 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
7627 will want to replace it with a new variable, but that will cause problems
7628 if this type is from outside the function. It's OK to have that here. */
7629 if (expr
== NULL_TREE
|| TREE_CONSTANT (expr
)
7630 || TREE_CODE (expr
) == VAR_DECL
7631 || CONTAINS_PLACEHOLDER_P (expr
))
7634 type
= TREE_TYPE (expr
);
7635 *expr_p
= unshare_expr (expr
);
7637 gimplify_expr (expr_p
, stmt_p
, NULL
, is_gimple_val
, fb_rvalue
);
7640 /* Verify that we've an exact type match with the original expression.
7641 In particular, we do not wish to drop a "sizetype" in favour of a
7642 type of similar dimensions. We don't want to pollute the generic
7643 type-stripping code with this knowledge because it doesn't matter
7644 for the bulk of GENERIC/GIMPLE. It only matters that TYPE_SIZE_UNIT
7645 and friends retain their "sizetype-ness". */
7646 if (TREE_TYPE (expr
) != type
7647 && TREE_CODE (type
) == INTEGER_TYPE
7648 && TYPE_IS_SIZETYPE (type
))
7653 *expr_p
= create_tmp_var (type
, NULL
);
7654 tmp
= build1 (NOP_EXPR
, type
, expr
);
7655 stmt
= gimplify_assign (*expr_p
, tmp
, stmt_p
);
7656 gimple_set_location (stmt
, EXPR_LOC_OR_HERE (expr
));
7661 /* Gimplify the body of statements pointed to by BODY_P and return a
7662 GIMPLE_BIND containing the sequence of GIMPLE statements
7663 corresponding to BODY_P. FNDECL is the function decl containing
7667 gimplify_body (tree
*body_p
, tree fndecl
, bool do_parms
)
7669 location_t saved_location
= input_location
;
7670 gimple_seq parm_stmts
, seq
;
7672 struct gimplify_ctx gctx
;
7674 timevar_push (TV_TREE_GIMPLIFY
);
7676 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
7678 default_rtl_profile ();
7680 gcc_assert (gimplify_ctxp
== NULL
);
7681 push_gimplify_context (&gctx
);
7683 /* Unshare most shared trees in the body and in that of any nested functions.
7684 It would seem we don't have to do this for nested functions because
7685 they are supposed to be output and then the outer function gimplified
7686 first, but the g++ front end doesn't always do it that way. */
7687 unshare_body (body_p
, fndecl
);
7688 unvisit_body (body_p
, fndecl
);
7690 if (cgraph_node (fndecl
)->origin
)
7691 nonlocal_vlas
= pointer_set_create ();
7693 /* Make sure input_location isn't set to something weird. */
7694 input_location
= DECL_SOURCE_LOCATION (fndecl
);
7696 /* Resolve callee-copies. This has to be done before processing
7697 the body so that DECL_VALUE_EXPR gets processed correctly. */
7698 parm_stmts
= (do_parms
) ? gimplify_parameters () : NULL
;
7700 /* Gimplify the function's body. */
7702 gimplify_stmt (body_p
, &seq
);
7703 outer_bind
= gimple_seq_first_stmt (seq
);
7706 outer_bind
= gimple_build_nop ();
7707 gimplify_seq_add_stmt (&seq
, outer_bind
);
7710 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
7711 not the case, wrap everything in a GIMPLE_BIND to make it so. */
7712 if (gimple_code (outer_bind
) == GIMPLE_BIND
7713 && gimple_seq_first (seq
) == gimple_seq_last (seq
))
7716 outer_bind
= gimple_build_bind (NULL_TREE
, seq
, NULL
);
7718 *body_p
= NULL_TREE
;
7720 /* If we had callee-copies statements, insert them at the beginning
7721 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
7722 if (!gimple_seq_empty_p (parm_stmts
))
7726 gimplify_seq_add_seq (&parm_stmts
, gimple_bind_body (outer_bind
));
7727 gimple_bind_set_body (outer_bind
, parm_stmts
);
7729 for (parm
= DECL_ARGUMENTS (current_function_decl
);
7730 parm
; parm
= DECL_CHAIN (parm
))
7731 if (DECL_HAS_VALUE_EXPR_P (parm
))
7733 DECL_HAS_VALUE_EXPR_P (parm
) = 0;
7734 DECL_IGNORED_P (parm
) = 0;
7740 pointer_set_destroy (nonlocal_vlas
);
7741 nonlocal_vlas
= NULL
;
7744 pop_gimplify_context (outer_bind
);
7745 gcc_assert (gimplify_ctxp
== NULL
);
7747 #ifdef ENABLE_TYPES_CHECKING
7749 verify_types_in_gimple_seq (gimple_bind_body (outer_bind
));
7752 timevar_pop (TV_TREE_GIMPLIFY
);
7753 input_location
= saved_location
;
7758 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
7759 node for the function we want to gimplify.
7761 Returns the sequence of GIMPLE statements corresponding to the body
7765 gimplify_function_tree (tree fndecl
)
7767 tree oldfn
, parm
, ret
;
7771 gcc_assert (!gimple_body (fndecl
));
7773 oldfn
= current_function_decl
;
7774 current_function_decl
= fndecl
;
7775 if (DECL_STRUCT_FUNCTION (fndecl
))
7776 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
7778 push_struct_function (fndecl
);
7780 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
7782 /* Preliminarily mark non-addressed complex variables as eligible
7783 for promotion to gimple registers. We'll transform their uses
7785 if ((TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
7786 || TREE_CODE (TREE_TYPE (parm
)) == VECTOR_TYPE
)
7787 && !TREE_THIS_VOLATILE (parm
)
7788 && !needs_to_live_in_memory (parm
))
7789 DECL_GIMPLE_REG_P (parm
) = 1;
7792 ret
= DECL_RESULT (fndecl
);
7793 if ((TREE_CODE (TREE_TYPE (ret
)) == COMPLEX_TYPE
7794 || TREE_CODE (TREE_TYPE (ret
)) == VECTOR_TYPE
)
7795 && !needs_to_live_in_memory (ret
))
7796 DECL_GIMPLE_REG_P (ret
) = 1;
7798 bind
= gimplify_body (&DECL_SAVED_TREE (fndecl
), fndecl
, true);
7800 /* The tree body of the function is no longer needed, replace it
7801 with the new GIMPLE body. */
7802 seq
= gimple_seq_alloc ();
7803 gimple_seq_add_stmt (&seq
, bind
);
7804 gimple_set_body (fndecl
, seq
);
7806 /* If we're instrumenting function entry/exit, then prepend the call to
7807 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
7808 catch the exit hook. */
7809 /* ??? Add some way to ignore exceptions for this TFE. */
7810 if (flag_instrument_function_entry_exit
7811 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
)
7812 && !flag_instrument_functions_exclude_p (fndecl
))
7817 gimple_seq cleanup
= NULL
, body
= NULL
;
7819 x
= implicit_built_in_decls
[BUILT_IN_PROFILE_FUNC_EXIT
];
7820 gimplify_seq_add_stmt (&cleanup
, gimple_build_call (x
, 0));
7821 tf
= gimple_build_try (seq
, cleanup
, GIMPLE_TRY_FINALLY
);
7823 x
= implicit_built_in_decls
[BUILT_IN_PROFILE_FUNC_ENTER
];
7824 gimplify_seq_add_stmt (&body
, gimple_build_call (x
, 0));
7825 gimplify_seq_add_stmt (&body
, tf
);
7826 new_bind
= gimple_build_bind (NULL
, body
, gimple_bind_block (bind
));
7827 /* Clear the block for BIND, since it is no longer directly inside
7828 the function, but within a try block. */
7829 gimple_bind_set_block (bind
, NULL
);
7831 /* Replace the current function body with the body
7832 wrapped in the try/finally TF. */
7833 seq
= gimple_seq_alloc ();
7834 gimple_seq_add_stmt (&seq
, new_bind
);
7835 gimple_set_body (fndecl
, seq
);
7838 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
7839 cfun
->curr_properties
= PROP_gimple_any
;
7841 current_function_decl
= oldfn
;
7846 /* Some transformations like inlining may invalidate the GIMPLE form
7847 for operands. This function traverses all the operands in STMT and
7848 gimplifies anything that is not a valid gimple operand. Any new
7849 GIMPLE statements are inserted before *GSI_P. */
7852 gimple_regimplify_operands (gimple stmt
, gimple_stmt_iterator
*gsi_p
)
7855 tree orig_lhs
= NULL_TREE
, lhs
, t
;
7856 gimple_seq pre
= NULL
;
7857 gimple post_stmt
= NULL
;
7858 struct gimplify_ctx gctx
;
7860 push_gimplify_context (&gctx
);
7861 gimplify_ctxp
->into_ssa
= gimple_in_ssa_p (cfun
);
7863 switch (gimple_code (stmt
))
7866 gimplify_expr (gimple_cond_lhs_ptr (stmt
), &pre
, NULL
,
7867 is_gimple_val
, fb_rvalue
);
7868 gimplify_expr (gimple_cond_rhs_ptr (stmt
), &pre
, NULL
,
7869 is_gimple_val
, fb_rvalue
);
7872 gimplify_expr (gimple_switch_index_ptr (stmt
), &pre
, NULL
,
7873 is_gimple_val
, fb_rvalue
);
7875 case GIMPLE_OMP_ATOMIC_LOAD
:
7876 gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt
), &pre
, NULL
,
7877 is_gimple_val
, fb_rvalue
);
7881 size_t i
, noutputs
= gimple_asm_noutputs (stmt
);
7882 const char *constraint
, **oconstraints
;
7883 bool allows_mem
, allows_reg
, is_inout
;
7886 = (const char **) alloca ((noutputs
) * sizeof (const char *));
7887 for (i
= 0; i
< noutputs
; i
++)
7889 tree op
= gimple_asm_output_op (stmt
, i
);
7890 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op
)));
7891 oconstraints
[i
] = constraint
;
7892 parse_output_constraint (&constraint
, i
, 0, 0, &allows_mem
,
7893 &allows_reg
, &is_inout
);
7894 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
7895 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
7896 fb_lvalue
| fb_mayfail
);
7898 for (i
= 0; i
< gimple_asm_ninputs (stmt
); i
++)
7900 tree op
= gimple_asm_input_op (stmt
, i
);
7901 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op
)));
7902 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
7903 oconstraints
, &allows_mem
, &allows_reg
);
7904 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op
))) && allows_mem
)
7906 if (!allows_reg
&& allows_mem
)
7907 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
7908 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
7910 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
7911 is_gimple_asm_val
, fb_rvalue
);
7916 /* NOTE: We start gimplifying operands from last to first to
7917 make sure that side-effects on the RHS of calls, assignments
7918 and ASMs are executed before the LHS. The ordering is not
7919 important for other statements. */
7920 num_ops
= gimple_num_ops (stmt
);
7921 orig_lhs
= gimple_get_lhs (stmt
);
7922 for (i
= num_ops
; i
> 0; i
--)
7924 tree op
= gimple_op (stmt
, i
- 1);
7925 if (op
== NULL_TREE
)
7927 if (i
== 1 && (is_gimple_call (stmt
) || is_gimple_assign (stmt
)))
7928 gimplify_expr (&op
, &pre
, NULL
, is_gimple_lvalue
, fb_lvalue
);
7930 && is_gimple_assign (stmt
)
7932 && get_gimple_rhs_class (gimple_expr_code (stmt
))
7933 == GIMPLE_SINGLE_RHS
)
7934 gimplify_expr (&op
, &pre
, NULL
,
7935 rhs_predicate_for (gimple_assign_lhs (stmt
)),
7937 else if (i
== 2 && is_gimple_call (stmt
))
7939 if (TREE_CODE (op
) == FUNCTION_DECL
)
7941 gimplify_expr (&op
, &pre
, NULL
, is_gimple_call_addr
, fb_rvalue
);
7944 gimplify_expr (&op
, &pre
, NULL
, is_gimple_val
, fb_rvalue
);
7945 gimple_set_op (stmt
, i
- 1, op
);
7948 lhs
= gimple_get_lhs (stmt
);
7949 /* If the LHS changed it in a way that requires a simple RHS,
7950 create temporary. */
7951 if (lhs
&& !is_gimple_reg (lhs
))
7953 bool need_temp
= false;
7955 if (is_gimple_assign (stmt
)
7957 && get_gimple_rhs_class (gimple_expr_code (stmt
))
7958 == GIMPLE_SINGLE_RHS
)
7959 gimplify_expr (gimple_assign_rhs1_ptr (stmt
), &pre
, NULL
,
7960 rhs_predicate_for (gimple_assign_lhs (stmt
)),
7962 else if (is_gimple_reg (lhs
))
7964 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
7966 if (is_gimple_call (stmt
))
7968 i
= gimple_call_flags (stmt
);
7969 if ((i
& ECF_LOOPING_CONST_OR_PURE
)
7970 || !(i
& (ECF_CONST
| ECF_PURE
)))
7973 if (stmt_can_throw_internal (stmt
))
7979 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
7981 else if (TYPE_MODE (TREE_TYPE (lhs
)) != BLKmode
)
7983 if (is_gimple_call (stmt
))
7985 tree fndecl
= gimple_call_fndecl (stmt
);
7987 if (!aggregate_value_p (TREE_TYPE (lhs
), fndecl
)
7988 && !(fndecl
&& DECL_RESULT (fndecl
)
7989 && DECL_BY_REFERENCE (DECL_RESULT (fndecl
))))
7998 tree temp
= create_tmp_reg (TREE_TYPE (lhs
), NULL
);
8000 if (TREE_CODE (orig_lhs
) == SSA_NAME
)
8001 orig_lhs
= SSA_NAME_VAR (orig_lhs
);
8003 if (gimple_in_ssa_p (cfun
))
8004 temp
= make_ssa_name (temp
, NULL
);
8005 gimple_set_lhs (stmt
, temp
);
8006 post_stmt
= gimple_build_assign (lhs
, temp
);
8007 if (TREE_CODE (lhs
) == SSA_NAME
)
8008 SSA_NAME_DEF_STMT (lhs
) = post_stmt
;
8014 if (gimple_referenced_vars (cfun
))
8015 for (t
= gimplify_ctxp
->temps
; t
; t
= TREE_CHAIN (t
))
8016 add_referenced_var (t
);
8018 if (!gimple_seq_empty_p (pre
))
8020 if (gimple_in_ssa_p (cfun
))
8022 gimple_stmt_iterator i
;
8024 for (i
= gsi_start (pre
); !gsi_end_p (i
); gsi_next (&i
))
8025 mark_symbols_for_renaming (gsi_stmt (i
));
8027 gsi_insert_seq_before (gsi_p
, pre
, GSI_SAME_STMT
);
8030 gsi_insert_after (gsi_p
, post_stmt
, GSI_NEW_STMT
);
8032 pop_gimplify_context (NULL
);
8036 /* Expands EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
8037 the predicate that will hold for the result. If VAR is not NULL, make the
8038 base variable of the final destination be VAR if suitable. */
8041 force_gimple_operand_1 (tree expr
, gimple_seq
*stmts
,
8042 gimple_predicate gimple_test_f
, tree var
)
8045 enum gimplify_status ret
;
8046 struct gimplify_ctx gctx
;
8050 if (is_gimple_val (expr
))
8053 push_gimplify_context (&gctx
);
8054 gimplify_ctxp
->into_ssa
= gimple_in_ssa_p (cfun
);
8055 gimplify_ctxp
->allow_rhs_cond_expr
= true;
8058 expr
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, expr
);
8060 if (TREE_CODE (expr
) != MODIFY_EXPR
8061 && TREE_TYPE (expr
) == void_type_node
)
8063 gimplify_and_add (expr
, stmts
);
8068 ret
= gimplify_expr (&expr
, stmts
, NULL
, gimple_test_f
, fb_rvalue
);
8069 gcc_assert (ret
!= GS_ERROR
);
8072 if (gimple_referenced_vars (cfun
))
8073 for (t
= gimplify_ctxp
->temps
; t
; t
= DECL_CHAIN (t
))
8074 add_referenced_var (t
);
8076 pop_gimplify_context (NULL
);
8081 /* Expands EXPR to list of gimple statements STMTS. If SIMPLE is true,
8082 force the result to be either ssa_name or an invariant, otherwise
8083 just force it to be a rhs expression. If VAR is not NULL, make the
8084 base variable of the final destination be VAR if suitable. */
8087 force_gimple_operand (tree expr
, gimple_seq
*stmts
, bool simple
, tree var
)
8089 return force_gimple_operand_1 (expr
, stmts
,
8090 simple
? is_gimple_val
: is_gimple_reg_rhs
,
8094 /* Invokes force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
8095 and VAR. If some statements are produced, emits them at GSI.
8096 If BEFORE is true. the statements are appended before GSI, otherwise
8097 they are appended after it. M specifies the way GSI moves after
8098 insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values). */
8101 force_gimple_operand_gsi_1 (gimple_stmt_iterator
*gsi
, tree expr
,
8102 gimple_predicate gimple_test_f
,
8103 tree var
, bool before
,
8104 enum gsi_iterator_update m
)
8108 expr
= force_gimple_operand_1 (expr
, &stmts
, gimple_test_f
, var
);
8110 if (!gimple_seq_empty_p (stmts
))
8112 if (gimple_in_ssa_p (cfun
))
8114 gimple_stmt_iterator i
;
8116 for (i
= gsi_start (stmts
); !gsi_end_p (i
); gsi_next (&i
))
8117 mark_symbols_for_renaming (gsi_stmt (i
));
8121 gsi_insert_seq_before (gsi
, stmts
, m
);
8123 gsi_insert_seq_after (gsi
, stmts
, m
);
8129 /* Invokes force_gimple_operand_1 for EXPR with parameter VAR.
8130 If SIMPLE is true, force the result to be either ssa_name or an invariant,
8131 otherwise just force it to be a rhs expression. If some statements are
8132 produced, emits them at GSI. If BEFORE is true, the statements are
8133 appended before GSI, otherwise they are appended after it. M specifies
8134 the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
8135 are the usual values). */
8138 force_gimple_operand_gsi (gimple_stmt_iterator
*gsi
, tree expr
,
8139 bool simple_p
, tree var
, bool before
,
8140 enum gsi_iterator_update m
)
8142 return force_gimple_operand_gsi_1 (gsi
, expr
,
8144 ? is_gimple_val
: is_gimple_reg_rhs
,
8149 #include "gt-gimplify.h"