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, 2011,
4 2012 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"
44 #include "pointer-set.h"
45 #include "splay-tree.h"
48 #include "tree-pass.h"
50 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name. */
51 #include "expr.h" /* FIXME: for can_move_by_pieces
52 and STACK_CHECK_MAX_VAR_SIZE. */
54 enum gimplify_omp_var_data
60 GOVD_FIRSTPRIVATE
= 16,
61 GOVD_LASTPRIVATE
= 32,
64 GOVD_DEBUG_PRIVATE
= 256,
65 GOVD_PRIVATE_OUTER_REF
= 512,
66 GOVD_DATA_SHARE_CLASS
= (GOVD_SHARED
| GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
67 | GOVD_LASTPRIVATE
| GOVD_REDUCTION
| GOVD_LOCAL
)
75 ORT_COMBINED_PARALLEL
= 3,
80 struct gimplify_omp_ctx
82 struct gimplify_omp_ctx
*outer_context
;
84 struct pointer_set_t
*privatized_types
;
86 enum omp_clause_default_kind default_kind
;
87 enum omp_region_type region_type
;
90 static struct gimplify_ctx
*gimplify_ctxp
;
91 static struct gimplify_omp_ctx
*gimplify_omp_ctxp
;
94 /* Formal (expression) temporary table handling: multiple occurrences of
95 the same scalar expression are evaluated into the same temporary. */
97 typedef struct gimple_temp_hash_elt
100 tree temp
; /* Value */
103 /* Forward declaration. */
104 static enum gimplify_status
gimplify_compound_expr (tree
*, gimple_seq
*, bool);
106 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
107 form and we don't do any syntax checking. */
110 mark_addressable (tree x
)
112 while (handled_component_p (x
))
113 x
= TREE_OPERAND (x
, 0);
114 if (TREE_CODE (x
) == MEM_REF
115 && TREE_CODE (TREE_OPERAND (x
, 0)) == ADDR_EXPR
)
116 x
= TREE_OPERAND (TREE_OPERAND (x
, 0), 0);
117 if (TREE_CODE (x
) != VAR_DECL
118 && TREE_CODE (x
) != PARM_DECL
119 && TREE_CODE (x
) != RESULT_DECL
)
121 TREE_ADDRESSABLE (x
) = 1;
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 #ifdef ENABLE_CHECKING
150 /* Only allow them to compare equal if they also hash equal; otherwise
151 results are nondeterminate, and we fail bootstrap comparison. */
152 gcc_assert (gimple_tree_hash (p1
) == gimple_tree_hash (p2
));
158 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
159 *SEQ_P is NULL, a new sequence is allocated. This function is
160 similar to gimple_seq_add_stmt, but does not scan the operands.
161 During gimplification, we need to manipulate statement sequences
162 before the def/use vectors have been constructed. */
165 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
167 gimple_stmt_iterator si
;
173 *seq_p
= gimple_seq_alloc ();
175 si
= gsi_last (*seq_p
);
177 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
180 /* Shorter alias name for the above function for use in gimplify.c
184 gimplify_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
186 gimple_seq_add_stmt_without_update (seq_p
, gs
);
189 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
190 NULL, a new sequence is allocated. This function is
191 similar to gimple_seq_add_seq, but does not scan the operands.
192 During gimplification, we need to manipulate statement sequences
193 before the def/use vectors have been constructed. */
196 gimplify_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
198 gimple_stmt_iterator si
;
204 *dst_p
= gimple_seq_alloc ();
206 si
= gsi_last (*dst_p
);
207 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
210 /* Set up a context for the gimplifier. */
213 push_gimplify_context (struct gimplify_ctx
*c
)
215 memset (c
, '\0', sizeof (*c
));
216 c
->prev_context
= gimplify_ctxp
;
220 /* Tear down a context for the gimplifier. If BODY is non-null, then
221 put the temporaries into the outer BIND_EXPR. Otherwise, put them
224 BODY is not a sequence, but the first tuple in a sequence. */
227 pop_gimplify_context (gimple body
)
229 struct gimplify_ctx
*c
= gimplify_ctxp
;
231 gcc_assert (c
&& (c
->bind_expr_stack
== NULL
232 || VEC_empty (gimple
, c
->bind_expr_stack
)));
233 VEC_free (gimple
, heap
, c
->bind_expr_stack
);
234 gimplify_ctxp
= c
->prev_context
;
237 declare_vars (c
->temps
, body
, false);
239 record_vars (c
->temps
);
242 htab_delete (c
->temp_htab
);
245 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
248 gimple_push_bind_expr (gimple gimple_bind
)
250 if (gimplify_ctxp
->bind_expr_stack
== NULL
)
251 gimplify_ctxp
->bind_expr_stack
= VEC_alloc (gimple
, heap
, 8);
252 VEC_safe_push (gimple
, heap
, gimplify_ctxp
->bind_expr_stack
, gimple_bind
);
255 /* Pop the first element off the stack of bindings. */
258 gimple_pop_bind_expr (void)
260 VEC_pop (gimple
, gimplify_ctxp
->bind_expr_stack
);
263 /* Return the first element of the stack of bindings. */
266 gimple_current_bind_expr (void)
268 return VEC_last (gimple
, gimplify_ctxp
->bind_expr_stack
);
271 /* Return the stack of bindings created during gimplification. */
274 gimple_bind_expr_stack (void)
276 return gimplify_ctxp
->bind_expr_stack
;
279 /* Return true iff there is a COND_EXPR between us and the innermost
280 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
283 gimple_conditional_context (void)
285 return gimplify_ctxp
->conditions
> 0;
288 /* Note that we've entered a COND_EXPR. */
291 gimple_push_condition (void)
293 #ifdef ENABLE_GIMPLE_CHECKING
294 if (gimplify_ctxp
->conditions
== 0)
295 gcc_assert (gimple_seq_empty_p (gimplify_ctxp
->conditional_cleanups
));
297 ++(gimplify_ctxp
->conditions
);
300 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
301 now, add any conditional cleanups we've seen to the prequeue. */
304 gimple_pop_condition (gimple_seq
*pre_p
)
306 int conds
= --(gimplify_ctxp
->conditions
);
308 gcc_assert (conds
>= 0);
311 gimplify_seq_add_seq (pre_p
, gimplify_ctxp
->conditional_cleanups
);
312 gimplify_ctxp
->conditional_cleanups
= NULL
;
316 /* A stable comparison routine for use with splay trees and DECLs. */
319 splay_tree_compare_decl_uid (splay_tree_key xa
, splay_tree_key xb
)
324 return DECL_UID (a
) - DECL_UID (b
);
327 /* Create a new omp construct that deals with variable remapping. */
329 static struct gimplify_omp_ctx
*
330 new_omp_context (enum omp_region_type region_type
)
332 struct gimplify_omp_ctx
*c
;
334 c
= XCNEW (struct gimplify_omp_ctx
);
335 c
->outer_context
= gimplify_omp_ctxp
;
336 c
->variables
= splay_tree_new (splay_tree_compare_decl_uid
, 0, 0);
337 c
->privatized_types
= pointer_set_create ();
338 c
->location
= input_location
;
339 c
->region_type
= region_type
;
340 if ((region_type
& ORT_TASK
) == 0)
341 c
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
343 c
->default_kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
348 /* Destroy an omp construct that deals with variable remapping. */
351 delete_omp_context (struct gimplify_omp_ctx
*c
)
353 splay_tree_delete (c
->variables
);
354 pointer_set_destroy (c
->privatized_types
);
358 static void omp_add_variable (struct gimplify_omp_ctx
*, tree
, unsigned int);
359 static bool omp_notice_variable (struct gimplify_omp_ctx
*, tree
, bool);
361 /* Both gimplify the statement T and append it to *SEQ_P. This function
362 behaves exactly as gimplify_stmt, but you don't have to pass T as a
366 gimplify_and_add (tree t
, gimple_seq
*seq_p
)
368 gimplify_stmt (&t
, seq_p
);
371 /* Gimplify statement T into sequence *SEQ_P, and return the first
372 tuple in the sequence of generated tuples for this statement.
373 Return NULL if gimplifying T produced no tuples. */
376 gimplify_and_return_first (tree t
, gimple_seq
*seq_p
)
378 gimple_stmt_iterator last
= gsi_last (*seq_p
);
380 gimplify_and_add (t
, seq_p
);
382 if (!gsi_end_p (last
))
385 return gsi_stmt (last
);
388 return gimple_seq_first_stmt (*seq_p
);
391 /* Strip off a legitimate source ending from the input string NAME of
392 length LEN. Rather than having to know the names used by all of
393 our front ends, we strip off an ending of a period followed by
394 up to five characters. (Java uses ".class".) */
397 remove_suffix (char *name
, int len
)
401 for (i
= 2; i
< 8 && len
> i
; i
++)
403 if (name
[len
- i
] == '.')
405 name
[len
- i
] = '\0';
411 /* Create a new temporary name with PREFIX. Return an identifier. */
413 static GTY(()) unsigned int tmp_var_id_num
;
416 create_tmp_var_name (const char *prefix
)
422 char *preftmp
= ASTRDUP (prefix
);
424 remove_suffix (preftmp
, strlen (preftmp
));
425 clean_symbol_name (preftmp
);
430 ASM_FORMAT_PRIVATE_NAME (tmp_name
, prefix
? prefix
: "T", tmp_var_id_num
++);
431 return get_identifier (tmp_name
);
434 /* Create a new temporary variable declaration of type TYPE.
435 Do NOT push it into the current binding. */
438 create_tmp_var_raw (tree type
, const char *prefix
)
442 tmp_var
= build_decl (input_location
,
443 VAR_DECL
, prefix
? create_tmp_var_name (prefix
) : NULL
,
446 /* The variable was declared by the compiler. */
447 DECL_ARTIFICIAL (tmp_var
) = 1;
448 /* And we don't want debug info for it. */
449 DECL_IGNORED_P (tmp_var
) = 1;
451 /* Make the variable writable. */
452 TREE_READONLY (tmp_var
) = 0;
454 DECL_EXTERNAL (tmp_var
) = 0;
455 TREE_STATIC (tmp_var
) = 0;
456 TREE_USED (tmp_var
) = 1;
461 /* Create a new temporary variable declaration of type TYPE. DO push the
462 variable into the current binding. Further, assume that this is called
463 only from gimplification or optimization, at which point the creation of
464 certain types are bugs. */
467 create_tmp_var (tree type
, const char *prefix
)
471 /* We don't allow types that are addressable (meaning we can't make copies),
472 or incomplete. We also used to reject every variable size objects here,
473 but now support those for which a constant upper bound can be obtained.
474 The processing for variable sizes is performed in gimple_add_tmp_var,
475 point at which it really matters and possibly reached via paths not going
476 through this function, e.g. after direct calls to create_tmp_var_raw. */
477 gcc_assert (!TREE_ADDRESSABLE (type
) && COMPLETE_TYPE_P (type
));
479 tmp_var
= create_tmp_var_raw (type
, prefix
);
480 gimple_add_tmp_var (tmp_var
);
484 /* Create a new temporary variable declaration of type TYPE by calling
485 create_tmp_var and if TYPE is a vector or a complex number, mark the new
486 temporary as gimple register. */
489 create_tmp_reg (tree type
, const char *prefix
)
493 tmp
= create_tmp_var (type
, prefix
);
494 if (TREE_CODE (type
) == COMPLEX_TYPE
495 || TREE_CODE (type
) == VECTOR_TYPE
)
496 DECL_GIMPLE_REG_P (tmp
) = 1;
501 /* Create a temporary with a name derived from VAL. Subroutine of
502 lookup_tmp_var; nobody else should call this function. */
505 create_tmp_from_val (tree val
)
507 /* Drop all qualifiers and address-space information from the value type. */
508 return create_tmp_var (TYPE_MAIN_VARIANT (TREE_TYPE (val
)), get_name (val
));
511 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
512 an existing expression temporary. */
515 lookup_tmp_var (tree val
, bool is_formal
)
519 /* If not optimizing, never really reuse a temporary. local-alloc
520 won't allocate any variable that is used in more than one basic
521 block, which means it will go into memory, causing much extra
522 work in reload and final and poorer code generation, outweighing
523 the extra memory allocation here. */
524 if (!optimize
|| !is_formal
|| TREE_SIDE_EFFECTS (val
))
525 ret
= create_tmp_from_val (val
);
532 if (gimplify_ctxp
->temp_htab
== NULL
)
533 gimplify_ctxp
->temp_htab
534 = htab_create (1000, gimple_tree_hash
, gimple_tree_eq
, free
);
535 slot
= htab_find_slot (gimplify_ctxp
->temp_htab
, (void *)&elt
, INSERT
);
538 elt_p
= XNEW (elt_t
);
540 elt_p
->temp
= ret
= create_tmp_from_val (val
);
541 *slot
= (void *) elt_p
;
545 elt_p
= (elt_t
*) *slot
;
553 /* Returns true iff T is a valid RHS for an assignment to a renamed
554 user -- or front-end generated artificial -- variable. */
557 is_gimple_reg_rhs (tree t
)
559 return get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
;
562 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
563 LHS, or for a call argument. */
566 is_gimple_mem_rhs (tree t
)
568 /* If we're dealing with a renamable type, either source or dest must be
569 a renamed variable. */
570 if (is_gimple_reg_type (TREE_TYPE (t
)))
571 return is_gimple_val (t
);
573 return is_gimple_val (t
) || is_gimple_lvalue (t
);
576 /* Return true if T is a CALL_EXPR or an expression that can be
577 assigned to a temporary. Note that this predicate should only be
578 used during gimplification. See the rationale for this in
579 gimplify_modify_expr. */
582 is_gimple_reg_rhs_or_call (tree t
)
584 return (get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
585 || TREE_CODE (t
) == CALL_EXPR
);
588 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
589 this predicate should only be used during gimplification. See the
590 rationale for this in gimplify_modify_expr. */
593 is_gimple_mem_rhs_or_call (tree t
)
595 /* If we're dealing with a renamable type, either source or dest must be
596 a renamed variable. */
597 if (is_gimple_reg_type (TREE_TYPE (t
)))
598 return is_gimple_val (t
);
600 return (is_gimple_val (t
) || is_gimple_lvalue (t
)
601 || TREE_CODE (t
) == CALL_EXPR
);
604 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
607 internal_get_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
612 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
613 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
614 gimplify_expr (&val
, pre_p
, post_p
, is_gimple_reg_rhs_or_call
,
617 t
= lookup_tmp_var (val
, is_formal
);
620 && (TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
621 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
))
622 DECL_GIMPLE_REG_P (t
) = 1;
624 mod
= build2 (INIT_EXPR
, TREE_TYPE (t
), t
, unshare_expr (val
));
626 SET_EXPR_LOCATION (mod
, EXPR_LOC_OR_HERE (val
));
628 /* gimplify_modify_expr might want to reduce this further. */
629 gimplify_and_add (mod
, pre_p
);
632 /* If we're gimplifying into ssa, gimplify_modify_expr will have
633 given our temporary an SSA name. Find and return it. */
634 if (gimplify_ctxp
->into_ssa
)
636 gimple last
= gimple_seq_last_stmt (*pre_p
);
637 t
= gimple_get_lhs (last
);
643 /* Return a formal temporary variable initialized with VAL. PRE_P is as
644 in gimplify_expr. Only use this function if:
646 1) The value of the unfactored expression represented by VAL will not
647 change between the initialization and use of the temporary, and
648 2) The temporary will not be otherwise modified.
650 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
651 and #2 means it is inappropriate for && temps.
653 For other cases, use get_initialized_tmp_var instead. */
656 get_formal_tmp_var (tree val
, gimple_seq
*pre_p
)
658 return internal_get_tmp_var (val
, pre_p
, NULL
, true);
661 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
662 are as in gimplify_expr. */
665 get_initialized_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
667 return internal_get_tmp_var (val
, pre_p
, post_p
, false);
670 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
671 generate debug info for them; otherwise don't. */
674 declare_vars (tree vars
, gimple scope
, bool debug_info
)
681 gcc_assert (gimple_code (scope
) == GIMPLE_BIND
);
683 temps
= nreverse (last
);
685 block
= gimple_bind_block (scope
);
686 gcc_assert (!block
|| TREE_CODE (block
) == BLOCK
);
687 if (!block
|| !debug_info
)
689 DECL_CHAIN (last
) = gimple_bind_vars (scope
);
690 gimple_bind_set_vars (scope
, temps
);
694 /* We need to attach the nodes both to the BIND_EXPR and to its
695 associated BLOCK for debugging purposes. The key point here
696 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
697 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
698 if (BLOCK_VARS (block
))
699 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), temps
);
702 gimple_bind_set_vars (scope
,
703 chainon (gimple_bind_vars (scope
), temps
));
704 BLOCK_VARS (block
) = temps
;
710 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
711 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
712 no such upper bound can be obtained. */
715 force_constant_size (tree var
)
717 /* The only attempt we make is by querying the maximum size of objects
718 of the variable's type. */
720 HOST_WIDE_INT max_size
;
722 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
724 max_size
= max_int_size_in_bytes (TREE_TYPE (var
));
726 gcc_assert (max_size
>= 0);
729 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var
)), max_size
);
731 = build_int_cst (TREE_TYPE (DECL_SIZE (var
)), max_size
* BITS_PER_UNIT
);
734 /* Push the temporary variable TMP into the current binding. */
737 gimple_add_tmp_var (tree tmp
)
739 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
741 /* Later processing assumes that the object size is constant, which might
742 not be true at this point. Force the use of a constant upper bound in
744 if (!host_integerp (DECL_SIZE_UNIT (tmp
), 1))
745 force_constant_size (tmp
);
747 DECL_CONTEXT (tmp
) = current_function_decl
;
748 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
752 DECL_CHAIN (tmp
) = gimplify_ctxp
->temps
;
753 gimplify_ctxp
->temps
= tmp
;
755 /* Mark temporaries local within the nearest enclosing parallel. */
756 if (gimplify_omp_ctxp
)
758 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
759 while (ctx
&& ctx
->region_type
== ORT_WORKSHARE
)
760 ctx
= ctx
->outer_context
;
762 omp_add_variable (ctx
, tmp
, GOVD_LOCAL
| GOVD_SEEN
);
771 /* This case is for nested functions. We need to expose the locals
773 body_seq
= gimple_body (current_function_decl
);
774 declare_vars (tmp
, gimple_seq_first_stmt (body_seq
), false);
778 /* Determine whether to assign a location to the statement GS. */
781 should_carry_location_p (gimple gs
)
783 /* Don't emit a line note for a label. We particularly don't want to
784 emit one for the break label, since it doesn't actually correspond
785 to the beginning of the loop/switch. */
786 if (gimple_code (gs
) == GIMPLE_LABEL
)
792 /* Return true if a location should not be emitted for this statement
793 by annotate_one_with_location. */
796 gimple_do_not_emit_location_p (gimple g
)
798 return gimple_plf (g
, GF_PLF_1
);
801 /* Mark statement G so a location will not be emitted by
802 annotate_one_with_location. */
805 gimple_set_do_not_emit_location (gimple g
)
807 /* The PLF flags are initialized to 0 when a new tuple is created,
808 so no need to initialize it anywhere. */
809 gimple_set_plf (g
, GF_PLF_1
, true);
812 /* Set the location for gimple statement GS to LOCATION. */
815 annotate_one_with_location (gimple gs
, location_t location
)
817 if (!gimple_has_location (gs
)
818 && !gimple_do_not_emit_location_p (gs
)
819 && should_carry_location_p (gs
))
820 gimple_set_location (gs
, location
);
823 /* Set LOCATION for all the statements after iterator GSI in sequence
824 SEQ. If GSI is pointing to the end of the sequence, start with the
825 first statement in SEQ. */
828 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
832 gsi
= gsi_start (seq
);
836 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
837 annotate_one_with_location (gsi_stmt (gsi
), location
);
840 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
843 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
845 gimple_stmt_iterator i
;
847 if (gimple_seq_empty_p (stmt_p
))
850 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
852 gimple gs
= gsi_stmt (i
);
853 annotate_one_with_location (gs
, location
);
857 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
858 nodes that are referenced more than once in GENERIC functions. This is
859 necessary because gimplification (translation into GIMPLE) is performed
860 by modifying tree nodes in-place, so gimplication of a shared node in a
861 first context could generate an invalid GIMPLE form in a second context.
863 This is achieved with a simple mark/copy/unmark algorithm that walks the
864 GENERIC representation top-down, marks nodes with TREE_VISITED the first
865 time it encounters them, duplicates them if they already have TREE_VISITED
866 set, and finally removes the TREE_VISITED marks it has set.
868 The algorithm works only at the function level, i.e. it generates a GENERIC
869 representation of a function with no nodes shared within the function when
870 passed a GENERIC function (except for nodes that are allowed to be shared).
872 At the global level, it is also necessary to unshare tree nodes that are
873 referenced in more than one function, for the same aforementioned reason.
874 This requires some cooperation from the front-end. There are 2 strategies:
876 1. Manual unsharing. The front-end needs to call unshare_expr on every
877 expression that might end up being shared across functions.
879 2. Deep unsharing. This is an extension of regular unsharing. Instead
880 of calling unshare_expr on expressions that might be shared across
881 functions, the front-end pre-marks them with TREE_VISITED. This will
882 ensure that they are unshared on the first reference within functions
883 when the regular unsharing algorithm runs. The counterpart is that
884 this algorithm must look deeper than for manual unsharing, which is
885 specified by LANG_HOOKS_DEEP_UNSHARING.
887 If there are only few specific cases of node sharing across functions, it is
888 probably easier for a front-end to unshare the expressions manually. On the
889 contrary, if the expressions generated at the global level are as widespread
890 as expressions generated within functions, deep unsharing is very likely the
893 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
894 These nodes model computations that must be done once. If we were to
895 unshare something like SAVE_EXPR(i++), the gimplification process would
896 create wrong code. However, if DATA is non-null, it must hold a pointer
897 set that is used to unshare the subtrees of these nodes. */
900 mostly_copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
903 enum tree_code code
= TREE_CODE (t
);
905 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
906 copy their subtrees if we can make sure to do it only once. */
907 if (code
== SAVE_EXPR
|| code
== TARGET_EXPR
|| code
== BIND_EXPR
)
909 if (data
&& !pointer_set_insert ((struct pointer_set_t
*)data
, t
))
915 /* Stop at types, decls, constants like copy_tree_r. */
916 else if (TREE_CODE_CLASS (code
) == tcc_type
917 || TREE_CODE_CLASS (code
) == tcc_declaration
918 || TREE_CODE_CLASS (code
) == tcc_constant
919 /* We can't do anything sensible with a BLOCK used as an
920 expression, but we also can't just die when we see it
921 because of non-expression uses. So we avert our eyes
922 and cross our fingers. Silly Java. */
926 /* Cope with the statement expression extension. */
927 else if (code
== STATEMENT_LIST
)
930 /* Leave the bulk of the work to copy_tree_r itself. */
932 copy_tree_r (tp
, walk_subtrees
, NULL
);
937 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
938 If *TP has been visited already, then *TP is deeply copied by calling
939 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
942 copy_if_shared_r (tree
*tp
, int *walk_subtrees
, void *data
)
945 enum tree_code code
= TREE_CODE (t
);
947 /* Skip types, decls, and constants. But we do want to look at their
948 types and the bounds of types. Mark them as visited so we properly
949 unmark their subtrees on the unmark pass. If we've already seen them,
950 don't look down further. */
951 if (TREE_CODE_CLASS (code
) == tcc_type
952 || TREE_CODE_CLASS (code
) == tcc_declaration
953 || TREE_CODE_CLASS (code
) == tcc_constant
)
955 if (TREE_VISITED (t
))
958 TREE_VISITED (t
) = 1;
961 /* If this node has been visited already, unshare it and don't look
963 else if (TREE_VISITED (t
))
965 walk_tree (tp
, mostly_copy_tree_r
, data
, NULL
);
969 /* Otherwise, mark the node as visited and keep looking. */
971 TREE_VISITED (t
) = 1;
976 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
977 copy_if_shared_r callback unmodified. */
980 copy_if_shared (tree
*tp
, void *data
)
982 walk_tree (tp
, copy_if_shared_r
, data
, NULL
);
985 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
986 any nested functions. */
989 unshare_body (tree fndecl
)
991 struct cgraph_node
*cgn
= cgraph_get_node (fndecl
);
992 /* If the language requires deep unsharing, we need a pointer set to make
993 sure we don't repeatedly unshare subtrees of unshareable nodes. */
994 struct pointer_set_t
*visited
995 = lang_hooks
.deep_unsharing
? pointer_set_create () : NULL
;
997 copy_if_shared (&DECL_SAVED_TREE (fndecl
), visited
);
998 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl
)), visited
);
999 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)), visited
);
1002 pointer_set_destroy (visited
);
1005 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
1006 unshare_body (cgn
->symbol
.decl
);
1009 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
1010 Subtrees are walked until the first unvisited node is encountered. */
1013 unmark_visited_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1017 /* If this node has been visited, unmark it and keep looking. */
1018 if (TREE_VISITED (t
))
1019 TREE_VISITED (t
) = 0;
1021 /* Otherwise, don't look any deeper. */
1028 /* Unmark the visited trees rooted at *TP. */
1031 unmark_visited (tree
*tp
)
1033 walk_tree (tp
, unmark_visited_r
, NULL
, NULL
);
1036 /* Likewise, but mark all trees as not visited. */
1039 unvisit_body (tree fndecl
)
1041 struct cgraph_node
*cgn
= cgraph_get_node (fndecl
);
1043 unmark_visited (&DECL_SAVED_TREE (fndecl
));
1044 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl
)));
1045 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)));
1048 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
1049 unvisit_body (cgn
->symbol
.decl
);
1052 /* Unconditionally make an unshared copy of EXPR. This is used when using
1053 stored expressions which span multiple functions, such as BINFO_VTABLE,
1054 as the normal unsharing process can't tell that they're shared. */
1057 unshare_expr (tree expr
)
1059 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
1063 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1064 contain statements and have a value. Assign its value to a temporary
1065 and give it void_type_node. Return the temporary, or NULL_TREE if
1066 WRAPPER was already void. */
1069 voidify_wrapper_expr (tree wrapper
, tree temp
)
1071 tree type
= TREE_TYPE (wrapper
);
1072 if (type
&& !VOID_TYPE_P (type
))
1076 /* Set p to point to the body of the wrapper. Loop until we find
1077 something that isn't a wrapper. */
1078 for (p
= &wrapper
; p
&& *p
; )
1080 switch (TREE_CODE (*p
))
1083 TREE_SIDE_EFFECTS (*p
) = 1;
1084 TREE_TYPE (*p
) = void_type_node
;
1085 /* For a BIND_EXPR, the body is operand 1. */
1086 p
= &BIND_EXPR_BODY (*p
);
1089 case CLEANUP_POINT_EXPR
:
1090 case TRY_FINALLY_EXPR
:
1091 case TRY_CATCH_EXPR
:
1092 TREE_SIDE_EFFECTS (*p
) = 1;
1093 TREE_TYPE (*p
) = void_type_node
;
1094 p
= &TREE_OPERAND (*p
, 0);
1097 case STATEMENT_LIST
:
1099 tree_stmt_iterator i
= tsi_last (*p
);
1100 TREE_SIDE_EFFECTS (*p
) = 1;
1101 TREE_TYPE (*p
) = void_type_node
;
1102 p
= tsi_end_p (i
) ? NULL
: tsi_stmt_ptr (i
);
1107 /* Advance to the last statement. Set all container types to
1109 for (; TREE_CODE (*p
) == COMPOUND_EXPR
; p
= &TREE_OPERAND (*p
, 1))
1111 TREE_SIDE_EFFECTS (*p
) = 1;
1112 TREE_TYPE (*p
) = void_type_node
;
1116 case TRANSACTION_EXPR
:
1117 TREE_SIDE_EFFECTS (*p
) = 1;
1118 TREE_TYPE (*p
) = void_type_node
;
1119 p
= &TRANSACTION_EXPR_BODY (*p
);
1123 /* Assume that any tree upon which voidify_wrapper_expr is
1124 directly called is a wrapper, and that its body is op0. */
1127 TREE_SIDE_EFFECTS (*p
) = 1;
1128 TREE_TYPE (*p
) = void_type_node
;
1129 p
= &TREE_OPERAND (*p
, 0);
1137 if (p
== NULL
|| IS_EMPTY_STMT (*p
))
1141 /* The wrapper is on the RHS of an assignment that we're pushing
1143 gcc_assert (TREE_CODE (temp
) == INIT_EXPR
1144 || TREE_CODE (temp
) == MODIFY_EXPR
);
1145 TREE_OPERAND (temp
, 1) = *p
;
1150 temp
= create_tmp_var (type
, "retval");
1151 *p
= build2 (INIT_EXPR
, type
, temp
, *p
);
1160 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1161 a temporary through which they communicate. */
1164 build_stack_save_restore (gimple
*save
, gimple
*restore
)
1168 *save
= gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE
), 0);
1169 tmp_var
= create_tmp_var (ptr_type_node
, "saved_stack");
1170 gimple_call_set_lhs (*save
, tmp_var
);
1173 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE
),
1177 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1179 static enum gimplify_status
1180 gimplify_bind_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1182 tree bind_expr
= *expr_p
;
1183 bool old_save_stack
= gimplify_ctxp
->save_stack
;
1186 gimple_seq body
, cleanup
;
1189 tree temp
= voidify_wrapper_expr (bind_expr
, NULL
);
1191 /* Mark variables seen in this bind expr. */
1192 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1194 if (TREE_CODE (t
) == VAR_DECL
)
1196 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1198 /* Mark variable as local. */
1199 if (ctx
&& !DECL_EXTERNAL (t
)
1200 && (! DECL_SEEN_IN_BIND_EXPR_P (t
)
1201 || splay_tree_lookup (ctx
->variables
,
1202 (splay_tree_key
) t
) == NULL
))
1203 omp_add_variable (gimplify_omp_ctxp
, t
, GOVD_LOCAL
| GOVD_SEEN
);
1205 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
1207 if (DECL_HARD_REGISTER (t
) && !is_global_var (t
) && cfun
)
1208 cfun
->has_local_explicit_reg_vars
= true;
1211 /* Preliminarily mark non-addressed complex variables as eligible
1212 for promotion to gimple registers. We'll transform their uses
1214 if ((TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
1215 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1216 && !TREE_THIS_VOLATILE (t
)
1217 && (TREE_CODE (t
) == VAR_DECL
&& !DECL_HARD_REGISTER (t
))
1218 && !needs_to_live_in_memory (t
))
1219 DECL_GIMPLE_REG_P (t
) = 1;
1222 gimple_bind
= gimple_build_bind (BIND_EXPR_VARS (bind_expr
), NULL
,
1223 BIND_EXPR_BLOCK (bind_expr
));
1224 gimple_push_bind_expr (gimple_bind
);
1226 gimplify_ctxp
->save_stack
= false;
1228 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1230 gimplify_stmt (&BIND_EXPR_BODY (bind_expr
), &body
);
1231 gimple_bind_set_body (gimple_bind
, body
);
1235 if (gimplify_ctxp
->save_stack
)
1237 gimple stack_restore
;
1239 /* Save stack on entry and restore it on exit. Add a try_finally
1240 block to achieve this. Note that mudflap depends on the
1241 format of the emitted code: see mx_register_decls(). */
1242 build_stack_save_restore (&stack_save
, &stack_restore
);
1244 gimplify_seq_add_stmt (&cleanup
, stack_restore
);
1247 /* Add clobbers for all variables that go out of scope. */
1248 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1250 if (TREE_CODE (t
) == VAR_DECL
1251 && !is_global_var (t
)
1252 && DECL_CONTEXT (t
) == current_function_decl
1253 && !DECL_HARD_REGISTER (t
)
1254 && !TREE_THIS_VOLATILE (t
)
1255 && !DECL_HAS_VALUE_EXPR_P (t
)
1256 /* Only care for variables that have to be in memory. Others
1257 will be rewritten into SSA names, hence moved to the top-level. */
1258 && !is_gimple_reg (t
))
1260 tree clobber
= build_constructor (TREE_TYPE (t
), NULL
);
1261 TREE_THIS_VOLATILE (clobber
) = 1;
1262 gimplify_seq_add_stmt (&cleanup
, gimple_build_assign (t
, clobber
));
1269 gimple_seq new_body
;
1272 gs
= gimple_build_try (gimple_bind_body (gimple_bind
), cleanup
,
1273 GIMPLE_TRY_FINALLY
);
1276 gimplify_seq_add_stmt (&new_body
, stack_save
);
1277 gimplify_seq_add_stmt (&new_body
, gs
);
1278 gimple_bind_set_body (gimple_bind
, new_body
);
1281 gimplify_ctxp
->save_stack
= old_save_stack
;
1282 gimple_pop_bind_expr ();
1284 gimplify_seq_add_stmt (pre_p
, gimple_bind
);
1292 *expr_p
= NULL_TREE
;
1296 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1297 GIMPLE value, it is assigned to a new temporary and the statement is
1298 re-written to return the temporary.
1300 PRE_P points to the sequence where side effects that must happen before
1301 STMT should be stored. */
1303 static enum gimplify_status
1304 gimplify_return_expr (tree stmt
, gimple_seq
*pre_p
)
1307 tree ret_expr
= TREE_OPERAND (stmt
, 0);
1308 tree result_decl
, result
;
1310 if (ret_expr
== error_mark_node
)
1314 || TREE_CODE (ret_expr
) == RESULT_DECL
1315 || ret_expr
== error_mark_node
)
1317 gimple ret
= gimple_build_return (ret_expr
);
1318 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1319 gimplify_seq_add_stmt (pre_p
, ret
);
1323 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1324 result_decl
= NULL_TREE
;
1327 result_decl
= TREE_OPERAND (ret_expr
, 0);
1329 /* See through a return by reference. */
1330 if (TREE_CODE (result_decl
) == INDIRECT_REF
)
1331 result_decl
= TREE_OPERAND (result_decl
, 0);
1333 gcc_assert ((TREE_CODE (ret_expr
) == MODIFY_EXPR
1334 || TREE_CODE (ret_expr
) == INIT_EXPR
)
1335 && TREE_CODE (result_decl
) == RESULT_DECL
);
1338 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1339 Recall that aggregate_value_p is FALSE for any aggregate type that is
1340 returned in registers. If we're returning values in registers, then
1341 we don't want to extend the lifetime of the RESULT_DECL, particularly
1342 across another call. In addition, for those aggregates for which
1343 hard_function_value generates a PARALLEL, we'll die during normal
1344 expansion of structure assignments; there's special code in expand_return
1345 to handle this case that does not exist in expand_expr. */
1348 else if (aggregate_value_p (result_decl
, TREE_TYPE (current_function_decl
)))
1350 if (TREE_CODE (DECL_SIZE (result_decl
)) != INTEGER_CST
)
1352 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl
)))
1353 gimplify_type_sizes (TREE_TYPE (result_decl
), pre_p
);
1354 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1355 should be effectively allocated by the caller, i.e. all calls to
1356 this function must be subject to the Return Slot Optimization. */
1357 gimplify_one_sizepos (&DECL_SIZE (result_decl
), pre_p
);
1358 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl
), pre_p
);
1360 result
= result_decl
;
1362 else if (gimplify_ctxp
->return_temp
)
1363 result
= gimplify_ctxp
->return_temp
;
1366 result
= create_tmp_reg (TREE_TYPE (result_decl
), NULL
);
1368 /* ??? With complex control flow (usually involving abnormal edges),
1369 we can wind up warning about an uninitialized value for this. Due
1370 to how this variable is constructed and initialized, this is never
1371 true. Give up and never warn. */
1372 TREE_NO_WARNING (result
) = 1;
1374 gimplify_ctxp
->return_temp
= result
;
1377 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1378 Then gimplify the whole thing. */
1379 if (result
!= result_decl
)
1380 TREE_OPERAND (ret_expr
, 0) = result
;
1382 gimplify_and_add (TREE_OPERAND (stmt
, 0), pre_p
);
1384 ret
= gimple_build_return (result
);
1385 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1386 gimplify_seq_add_stmt (pre_p
, ret
);
1391 /* Gimplify a variable-length array DECL. */
1394 gimplify_vla_decl (tree decl
, gimple_seq
*seq_p
)
1396 /* This is a variable-sized decl. Simplify its size and mark it
1397 for deferred expansion. Note that mudflap depends on the format
1398 of the emitted code: see mx_register_decls(). */
1399 tree t
, addr
, ptr_type
;
1401 gimplify_one_sizepos (&DECL_SIZE (decl
), seq_p
);
1402 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl
), seq_p
);
1404 /* All occurrences of this decl in final gimplified code will be
1405 replaced by indirection. Setting DECL_VALUE_EXPR does two
1406 things: First, it lets the rest of the gimplifier know what
1407 replacement to use. Second, it lets the debug info know
1408 where to find the value. */
1409 ptr_type
= build_pointer_type (TREE_TYPE (decl
));
1410 addr
= create_tmp_var (ptr_type
, get_name (decl
));
1411 DECL_IGNORED_P (addr
) = 0;
1412 t
= build_fold_indirect_ref (addr
);
1413 TREE_THIS_NOTRAP (t
) = 1;
1414 SET_DECL_VALUE_EXPR (decl
, t
);
1415 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1417 t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
1418 t
= build_call_expr (t
, 2, DECL_SIZE_UNIT (decl
),
1419 size_int (DECL_ALIGN (decl
)));
1420 /* The call has been built for a variable-sized object. */
1421 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
1422 t
= fold_convert (ptr_type
, t
);
1423 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
1425 gimplify_and_add (t
, seq_p
);
1427 /* Indicate that we need to restore the stack level when the
1428 enclosing BIND_EXPR is exited. */
1429 gimplify_ctxp
->save_stack
= true;
1432 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1433 and initialization explicit. */
1435 static enum gimplify_status
1436 gimplify_decl_expr (tree
*stmt_p
, gimple_seq
*seq_p
)
1438 tree stmt
= *stmt_p
;
1439 tree decl
= DECL_EXPR_DECL (stmt
);
1441 *stmt_p
= NULL_TREE
;
1443 if (TREE_TYPE (decl
) == error_mark_node
)
1446 if ((TREE_CODE (decl
) == TYPE_DECL
1447 || TREE_CODE (decl
) == VAR_DECL
)
1448 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl
)))
1449 gimplify_type_sizes (TREE_TYPE (decl
), seq_p
);
1451 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1453 tree init
= DECL_INITIAL (decl
);
1455 if (TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1456 || (!TREE_STATIC (decl
)
1457 && flag_stack_check
== GENERIC_STACK_CHECK
1458 && compare_tree_int (DECL_SIZE_UNIT (decl
),
1459 STACK_CHECK_MAX_VAR_SIZE
) > 0))
1460 gimplify_vla_decl (decl
, seq_p
);
1462 /* Some front ends do not explicitly declare all anonymous
1463 artificial variables. We compensate here by declaring the
1464 variables, though it would be better if the front ends would
1465 explicitly declare them. */
1466 if (!DECL_SEEN_IN_BIND_EXPR_P (decl
)
1467 && DECL_ARTIFICIAL (decl
) && DECL_NAME (decl
) == NULL_TREE
)
1468 gimple_add_tmp_var (decl
);
1470 if (init
&& init
!= error_mark_node
)
1472 if (!TREE_STATIC (decl
))
1474 DECL_INITIAL (decl
) = NULL_TREE
;
1475 init
= build2 (INIT_EXPR
, void_type_node
, decl
, init
);
1476 gimplify_and_add (init
, seq_p
);
1480 /* We must still examine initializers for static variables
1481 as they may contain a label address. */
1482 walk_tree (&init
, force_labels_r
, NULL
, NULL
);
1489 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1490 and replacing the LOOP_EXPR with goto, but if the loop contains an
1491 EXIT_EXPR, we need to append a label for it to jump to. */
1493 static enum gimplify_status
1494 gimplify_loop_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1496 tree saved_label
= gimplify_ctxp
->exit_label
;
1497 tree start_label
= create_artificial_label (UNKNOWN_LOCATION
);
1499 gimplify_seq_add_stmt (pre_p
, gimple_build_label (start_label
));
1501 gimplify_ctxp
->exit_label
= NULL_TREE
;
1503 gimplify_and_add (LOOP_EXPR_BODY (*expr_p
), pre_p
);
1505 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (start_label
));
1507 if (gimplify_ctxp
->exit_label
)
1508 gimplify_seq_add_stmt (pre_p
,
1509 gimple_build_label (gimplify_ctxp
->exit_label
));
1511 gimplify_ctxp
->exit_label
= saved_label
;
1517 /* Gimplify a statement list onto a sequence. These may be created either
1518 by an enlightened front-end, or by shortcut_cond_expr. */
1520 static enum gimplify_status
1521 gimplify_statement_list (tree
*expr_p
, gimple_seq
*pre_p
)
1523 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
1525 tree_stmt_iterator i
= tsi_start (*expr_p
);
1527 while (!tsi_end_p (i
))
1529 gimplify_stmt (tsi_stmt_ptr (i
), pre_p
);
1542 /* Compare two case labels. Because the front end should already have
1543 made sure that case ranges do not overlap, it is enough to only compare
1544 the CASE_LOW values of each case label. */
1547 compare_case_labels (const void *p1
, const void *p2
)
1549 const_tree
const case1
= *(const_tree
const*)p1
;
1550 const_tree
const case2
= *(const_tree
const*)p2
;
1552 /* The 'default' case label always goes first. */
1553 if (!CASE_LOW (case1
))
1555 else if (!CASE_LOW (case2
))
1558 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
1561 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1564 sort_case_labels (VEC(tree
,heap
)* label_vec
)
1566 VEC_qsort (tree
, label_vec
, compare_case_labels
);
1569 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1572 static enum gimplify_status
1573 gimplify_switch_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1575 tree switch_expr
= *expr_p
;
1576 gimple_seq switch_body_seq
= NULL
;
1577 enum gimplify_status ret
;
1578 tree index_type
= TREE_TYPE (switch_expr
);
1579 if (index_type
== NULL_TREE
)
1580 index_type
= TREE_TYPE (SWITCH_COND (switch_expr
));
1582 ret
= gimplify_expr (&SWITCH_COND (switch_expr
), pre_p
, NULL
, is_gimple_val
,
1584 if (ret
== GS_ERROR
|| ret
== GS_UNHANDLED
)
1587 if (SWITCH_BODY (switch_expr
))
1589 VEC (tree
,heap
) *labels
;
1590 VEC (tree
,heap
) *saved_labels
;
1591 tree min_value
, max_value
;
1592 tree default_case
= NULL_TREE
;
1594 gimple gimple_switch
;
1596 /* If someone can be bothered to fill in the labels, they can
1597 be bothered to null out the body too. */
1598 gcc_assert (!SWITCH_LABELS (switch_expr
));
1600 /* Save old labels, get new ones from body, then restore the old
1601 labels. Save all the things from the switch body to append after. */
1602 saved_labels
= gimplify_ctxp
->case_labels
;
1603 gimplify_ctxp
->case_labels
= VEC_alloc (tree
, heap
, 8);
1605 gimplify_stmt (&SWITCH_BODY (switch_expr
), &switch_body_seq
);
1606 labels
= gimplify_ctxp
->case_labels
;
1607 gimplify_ctxp
->case_labels
= saved_labels
;
1610 min_value
= TYPE_MIN_VALUE (index_type
);
1611 max_value
= TYPE_MAX_VALUE (index_type
);
1612 while (i
< VEC_length (tree
, labels
))
1614 tree elt
= VEC_index (tree
, labels
, i
);
1615 tree low
= CASE_LOW (elt
);
1616 tree high
= CASE_HIGH (elt
);
1617 bool remove_element
= FALSE
;
1622 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
1623 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
1625 /* This is a non-default case label, i.e. it has a value.
1627 See if the case label is reachable within the range of
1628 the index type. Remove out-of-range case values. Turn
1629 case ranges into a canonical form (high > low strictly)
1630 and convert the case label values to the index type.
1632 NB: The type of gimple_switch_index() may be the promoted
1633 type, but the case labels retain the original type. */
1637 /* This is a case range. Discard empty ranges.
1638 If the bounds or the range are equal, turn this
1639 into a simple (one-value) case. */
1640 int cmp
= tree_int_cst_compare (high
, low
);
1642 remove_element
= TRUE
;
1649 /* If the simple case value is unreachable, ignore it. */
1650 if ((TREE_CODE (min_value
) == INTEGER_CST
1651 && tree_int_cst_compare (low
, min_value
) < 0)
1652 || (TREE_CODE (max_value
) == INTEGER_CST
1653 && tree_int_cst_compare (low
, max_value
) > 0))
1654 remove_element
= TRUE
;
1656 low
= fold_convert (index_type
, low
);
1660 /* If the entire case range is unreachable, ignore it. */
1661 if ((TREE_CODE (min_value
) == INTEGER_CST
1662 && tree_int_cst_compare (high
, min_value
) < 0)
1663 || (TREE_CODE (max_value
) == INTEGER_CST
1664 && tree_int_cst_compare (low
, max_value
) > 0))
1665 remove_element
= TRUE
;
1668 /* If the lower bound is less than the index type's
1669 minimum value, truncate the range bounds. */
1670 if (TREE_CODE (min_value
) == INTEGER_CST
1671 && tree_int_cst_compare (low
, min_value
) < 0)
1673 low
= fold_convert (index_type
, low
);
1675 /* If the upper bound is greater than the index type's
1676 maximum value, truncate the range bounds. */
1677 if (TREE_CODE (max_value
) == INTEGER_CST
1678 && tree_int_cst_compare (high
, max_value
) > 0)
1680 high
= fold_convert (index_type
, high
);
1684 CASE_LOW (elt
) = low
;
1685 CASE_HIGH (elt
) = high
;
1689 /* The default case must be the last label in the list. */
1690 gcc_assert (!default_case
);
1692 remove_element
= TRUE
;
1696 VEC_ordered_remove (tree
, labels
, i
);
1702 if (!VEC_empty (tree
, labels
))
1703 sort_case_labels (labels
);
1707 /* If the switch has no default label, add one, so that we jump
1708 around the switch body. If the labels already cover the whole
1709 range of the switch index_type, add the default label pointing
1710 to one of the existing labels. */
1712 && TYPE_MIN_VALUE (index_type
)
1713 && TYPE_MAX_VALUE (index_type
)
1714 && tree_int_cst_equal (CASE_LOW (VEC_index (tree
, labels
, 0)),
1715 TYPE_MIN_VALUE (index_type
)))
1717 tree low
, high
= CASE_HIGH (VEC_index (tree
, labels
, len
- 1));
1719 high
= CASE_LOW (VEC_index (tree
, labels
, len
- 1));
1720 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
1722 for (i
= 1; i
< len
; i
++)
1724 high
= CASE_LOW (VEC_index (tree
, labels
, i
));
1725 low
= CASE_HIGH (VEC_index (tree
, labels
, i
- 1));
1727 low
= CASE_LOW (VEC_index (tree
, labels
, i
- 1));
1728 if ((TREE_INT_CST_LOW (low
) + 1
1729 != TREE_INT_CST_LOW (high
))
1730 || (TREE_INT_CST_HIGH (low
)
1731 + (TREE_INT_CST_LOW (high
) == 0)
1732 != TREE_INT_CST_HIGH (high
)))
1737 tree label
= CASE_LABEL (VEC_index (tree
, labels
, 0));
1738 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
1749 = build_case_label (NULL_TREE
, NULL_TREE
,
1750 create_artificial_label (UNKNOWN_LOCATION
));
1751 new_default
= gimple_build_label (CASE_LABEL (default_case
));
1752 gimplify_seq_add_stmt (&switch_body_seq
, new_default
);
1756 gimple_switch
= gimple_build_switch_vec (SWITCH_COND (switch_expr
),
1757 default_case
, labels
);
1758 gimplify_seq_add_stmt (pre_p
, gimple_switch
);
1759 gimplify_seq_add_seq (pre_p
, switch_body_seq
);
1760 VEC_free(tree
, heap
, labels
);
1763 gcc_assert (SWITCH_LABELS (switch_expr
));
1768 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
1770 static enum gimplify_status
1771 gimplify_case_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1773 struct gimplify_ctx
*ctxp
;
1774 gimple gimple_label
;
1776 /* Invalid OpenMP programs can play Duff's Device type games with
1777 #pragma omp parallel. At least in the C front end, we don't
1778 detect such invalid branches until after gimplification. */
1779 for (ctxp
= gimplify_ctxp
; ; ctxp
= ctxp
->prev_context
)
1780 if (ctxp
->case_labels
)
1783 gimple_label
= gimple_build_label (CASE_LABEL (*expr_p
));
1784 VEC_safe_push (tree
, heap
, ctxp
->case_labels
, *expr_p
);
1785 gimplify_seq_add_stmt (pre_p
, gimple_label
);
1790 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1794 build_and_jump (tree
*label_p
)
1796 if (label_p
== NULL
)
1797 /* If there's nowhere to jump, just fall through. */
1800 if (*label_p
== NULL_TREE
)
1802 tree label
= create_artificial_label (UNKNOWN_LOCATION
);
1806 return build1 (GOTO_EXPR
, void_type_node
, *label_p
);
1809 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1810 This also involves building a label to jump to and communicating it to
1811 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1813 static enum gimplify_status
1814 gimplify_exit_expr (tree
*expr_p
)
1816 tree cond
= TREE_OPERAND (*expr_p
, 0);
1819 expr
= build_and_jump (&gimplify_ctxp
->exit_label
);
1820 expr
= build3 (COND_EXPR
, void_type_node
, cond
, expr
, NULL_TREE
);
1826 /* A helper function to be called via walk_tree. Mark all labels under *TP
1827 as being forced. To be called for DECL_INITIAL of static variables. */
1830 force_labels_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1834 if (TREE_CODE (*tp
) == LABEL_DECL
)
1835 FORCED_LABEL (*tp
) = 1;
1840 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1841 different from its canonical type, wrap the whole thing inside a
1842 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1845 The canonical type of a COMPONENT_REF is the type of the field being
1846 referenced--unless the field is a bit-field which can be read directly
1847 in a smaller mode, in which case the canonical type is the
1848 sign-appropriate type corresponding to that mode. */
1851 canonicalize_component_ref (tree
*expr_p
)
1853 tree expr
= *expr_p
;
1856 gcc_assert (TREE_CODE (expr
) == COMPONENT_REF
);
1858 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
1859 type
= TREE_TYPE (get_unwidened (expr
, NULL_TREE
));
1861 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
1863 /* One could argue that all the stuff below is not necessary for
1864 the non-bitfield case and declare it a FE error if type
1865 adjustment would be needed. */
1866 if (TREE_TYPE (expr
) != type
)
1868 #ifdef ENABLE_TYPES_CHECKING
1869 tree old_type
= TREE_TYPE (expr
);
1873 /* We need to preserve qualifiers and propagate them from
1875 type_quals
= TYPE_QUALS (type
)
1876 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1877 if (TYPE_QUALS (type
) != type_quals
)
1878 type
= build_qualified_type (TYPE_MAIN_VARIANT (type
), type_quals
);
1880 /* Set the type of the COMPONENT_REF to the underlying type. */
1881 TREE_TYPE (expr
) = type
;
1883 #ifdef ENABLE_TYPES_CHECKING
1884 /* It is now a FE error, if the conversion from the canonical
1885 type to the original expression type is not useless. */
1886 gcc_assert (useless_type_conversion_p (old_type
, type
));
1891 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1892 to foo, embed that change in the ADDR_EXPR by converting
1897 where L is the lower bound. For simplicity, only do this for constant
1899 The constraint is that the type of &array[L] is trivially convertible
1903 canonicalize_addr_expr (tree
*expr_p
)
1905 tree expr
= *expr_p
;
1906 tree addr_expr
= TREE_OPERAND (expr
, 0);
1907 tree datype
, ddatype
, pddatype
;
1909 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1910 if (!POINTER_TYPE_P (TREE_TYPE (expr
))
1911 || TREE_CODE (addr_expr
) != ADDR_EXPR
)
1914 /* The addr_expr type should be a pointer to an array. */
1915 datype
= TREE_TYPE (TREE_TYPE (addr_expr
));
1916 if (TREE_CODE (datype
) != ARRAY_TYPE
)
1919 /* The pointer to element type shall be trivially convertible to
1920 the expression pointer type. */
1921 ddatype
= TREE_TYPE (datype
);
1922 pddatype
= build_pointer_type (ddatype
);
1923 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)),
1927 /* The lower bound and element sizes must be constant. */
1928 if (!TYPE_SIZE_UNIT (ddatype
)
1929 || TREE_CODE (TYPE_SIZE_UNIT (ddatype
)) != INTEGER_CST
1930 || !TYPE_DOMAIN (datype
) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))
1931 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))) != INTEGER_CST
)
1934 /* All checks succeeded. Build a new node to merge the cast. */
1935 *expr_p
= build4 (ARRAY_REF
, ddatype
, TREE_OPERAND (addr_expr
, 0),
1936 TYPE_MIN_VALUE (TYPE_DOMAIN (datype
)),
1937 NULL_TREE
, NULL_TREE
);
1938 *expr_p
= build1 (ADDR_EXPR
, pddatype
, *expr_p
);
1940 /* We can have stripped a required restrict qualifier above. */
1941 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
1942 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
1945 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1946 underneath as appropriate. */
1948 static enum gimplify_status
1949 gimplify_conversion (tree
*expr_p
)
1951 location_t loc
= EXPR_LOCATION (*expr_p
);
1952 gcc_assert (CONVERT_EXPR_P (*expr_p
));
1954 /* Then strip away all but the outermost conversion. */
1955 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p
, 0));
1957 /* And remove the outermost conversion if it's useless. */
1958 if (tree_ssa_useless_type_conversion (*expr_p
))
1959 *expr_p
= TREE_OPERAND (*expr_p
, 0);
1961 /* If we still have a conversion at the toplevel,
1962 then canonicalize some constructs. */
1963 if (CONVERT_EXPR_P (*expr_p
))
1965 tree sub
= TREE_OPERAND (*expr_p
, 0);
1967 /* If a NOP conversion is changing the type of a COMPONENT_REF
1968 expression, then canonicalize its type now in order to expose more
1969 redundant conversions. */
1970 if (TREE_CODE (sub
) == COMPONENT_REF
)
1971 canonicalize_component_ref (&TREE_OPERAND (*expr_p
, 0));
1973 /* If a NOP conversion is changing a pointer to array of foo
1974 to a pointer to foo, embed that change in the ADDR_EXPR. */
1975 else if (TREE_CODE (sub
) == ADDR_EXPR
)
1976 canonicalize_addr_expr (expr_p
);
1979 /* If we have a conversion to a non-register type force the
1980 use of a VIEW_CONVERT_EXPR instead. */
1981 if (CONVERT_EXPR_P (*expr_p
) && !is_gimple_reg_type (TREE_TYPE (*expr_p
)))
1982 *expr_p
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (*expr_p
),
1983 TREE_OPERAND (*expr_p
, 0));
1988 /* Nonlocal VLAs seen in the current function. */
1989 static struct pointer_set_t
*nonlocal_vlas
;
1991 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
1992 DECL_VALUE_EXPR, and it's worth re-examining things. */
1994 static enum gimplify_status
1995 gimplify_var_or_parm_decl (tree
*expr_p
)
1997 tree decl
= *expr_p
;
1999 /* ??? If this is a local variable, and it has not been seen in any
2000 outer BIND_EXPR, then it's probably the result of a duplicate
2001 declaration, for which we've already issued an error. It would
2002 be really nice if the front end wouldn't leak these at all.
2003 Currently the only known culprit is C++ destructors, as seen
2004 in g++.old-deja/g++.jason/binding.C. */
2005 if (TREE_CODE (decl
) == VAR_DECL
2006 && !DECL_SEEN_IN_BIND_EXPR_P (decl
)
2007 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)
2008 && decl_function_context (decl
) == current_function_decl
)
2010 gcc_assert (seen_error ());
2014 /* When within an OpenMP context, notice uses of variables. */
2015 if (gimplify_omp_ctxp
&& omp_notice_variable (gimplify_omp_ctxp
, decl
, true))
2018 /* If the decl is an alias for another expression, substitute it now. */
2019 if (DECL_HAS_VALUE_EXPR_P (decl
))
2021 tree value_expr
= DECL_VALUE_EXPR (decl
);
2023 /* For referenced nonlocal VLAs add a decl for debugging purposes
2024 to the current function. */
2025 if (TREE_CODE (decl
) == VAR_DECL
2026 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
2027 && nonlocal_vlas
!= NULL
2028 && TREE_CODE (value_expr
) == INDIRECT_REF
2029 && TREE_CODE (TREE_OPERAND (value_expr
, 0)) == VAR_DECL
2030 && decl_function_context (decl
) != current_function_decl
)
2032 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
2033 while (ctx
&& ctx
->region_type
== ORT_WORKSHARE
)
2034 ctx
= ctx
->outer_context
;
2035 if (!ctx
&& !pointer_set_insert (nonlocal_vlas
, decl
))
2037 tree copy
= copy_node (decl
), block
;
2039 lang_hooks
.dup_lang_specific_decl (copy
);
2040 SET_DECL_RTL (copy
, 0);
2041 TREE_USED (copy
) = 1;
2042 block
= DECL_INITIAL (current_function_decl
);
2043 DECL_CHAIN (copy
) = BLOCK_VARS (block
);
2044 BLOCK_VARS (block
) = copy
;
2045 SET_DECL_VALUE_EXPR (copy
, unshare_expr (value_expr
));
2046 DECL_HAS_VALUE_EXPR_P (copy
) = 1;
2050 *expr_p
= unshare_expr (value_expr
);
2057 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
2061 : min_lval '[' val ']'
2063 | compound_lval '[' val ']'
2064 | compound_lval '.' ID
2066 This is not part of the original SIMPLE definition, which separates
2067 array and member references, but it seems reasonable to handle them
2068 together. Also, this way we don't run into problems with union
2069 aliasing; gcc requires that for accesses through a union to alias, the
2070 union reference must be explicit, which was not always the case when we
2071 were splitting up array and member refs.
2073 PRE_P points to the sequence where side effects that must happen before
2074 *EXPR_P should be stored.
2076 POST_P points to the sequence where side effects that must happen after
2077 *EXPR_P should be stored. */
2079 static enum gimplify_status
2080 gimplify_compound_lval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2081 fallback_t fallback
)
2084 VEC(tree
,heap
) *stack
;
2085 enum gimplify_status ret
= GS_ALL_DONE
, tret
;
2087 location_t loc
= EXPR_LOCATION (*expr_p
);
2088 tree expr
= *expr_p
;
2090 /* Create a stack of the subexpressions so later we can walk them in
2091 order from inner to outer. */
2092 stack
= VEC_alloc (tree
, heap
, 10);
2094 /* We can handle anything that get_inner_reference can deal with. */
2095 for (p
= expr_p
; ; p
= &TREE_OPERAND (*p
, 0))
2098 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2099 if (TREE_CODE (*p
) == INDIRECT_REF
)
2100 *p
= fold_indirect_ref_loc (loc
, *p
);
2102 if (handled_component_p (*p
))
2104 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2105 additional COMPONENT_REFs. */
2106 else if ((TREE_CODE (*p
) == VAR_DECL
|| TREE_CODE (*p
) == PARM_DECL
)
2107 && gimplify_var_or_parm_decl (p
) == GS_OK
)
2112 VEC_safe_push (tree
, heap
, stack
, *p
);
2115 gcc_assert (VEC_length (tree
, stack
));
2117 /* Now STACK is a stack of pointers to all the refs we've walked through
2118 and P points to the innermost expression.
2120 Java requires that we elaborated nodes in source order. That
2121 means we must gimplify the inner expression followed by each of
2122 the indices, in order. But we can't gimplify the inner
2123 expression until we deal with any variable bounds, sizes, or
2124 positions in order to deal with PLACEHOLDER_EXPRs.
2126 So we do this in three steps. First we deal with the annotations
2127 for any variables in the components, then we gimplify the base,
2128 then we gimplify any indices, from left to right. */
2129 for (i
= VEC_length (tree
, stack
) - 1; i
>= 0; i
--)
2131 tree t
= VEC_index (tree
, stack
, i
);
2133 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2135 /* Gimplify the low bound and element type size and put them into
2136 the ARRAY_REF. If these values are set, they have already been
2138 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2140 tree low
= unshare_expr (array_ref_low_bound (t
));
2141 if (!is_gimple_min_invariant (low
))
2143 TREE_OPERAND (t
, 2) = low
;
2144 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2145 post_p
, is_gimple_reg
,
2147 ret
= MIN (ret
, tret
);
2152 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2153 is_gimple_reg
, fb_rvalue
);
2154 ret
= MIN (ret
, tret
);
2157 if (TREE_OPERAND (t
, 3) == NULL_TREE
)
2159 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0)));
2160 tree elmt_size
= unshare_expr (array_ref_element_size (t
));
2161 tree factor
= size_int (TYPE_ALIGN_UNIT (elmt_type
));
2163 /* Divide the element size by the alignment of the element
2166 = size_binop_loc (loc
, EXACT_DIV_EXPR
, elmt_size
, factor
);
2168 if (!is_gimple_min_invariant (elmt_size
))
2170 TREE_OPERAND (t
, 3) = elmt_size
;
2171 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
,
2172 post_p
, is_gimple_reg
,
2174 ret
= MIN (ret
, tret
);
2179 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
, post_p
,
2180 is_gimple_reg
, fb_rvalue
);
2181 ret
= MIN (ret
, tret
);
2184 else if (TREE_CODE (t
) == COMPONENT_REF
)
2186 /* Set the field offset into T and gimplify it. */
2187 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2189 tree offset
= unshare_expr (component_ref_field_offset (t
));
2190 tree field
= TREE_OPERAND (t
, 1);
2192 = size_int (DECL_OFFSET_ALIGN (field
) / BITS_PER_UNIT
);
2194 /* Divide the offset by its alignment. */
2195 offset
= size_binop_loc (loc
, EXACT_DIV_EXPR
, offset
, factor
);
2197 if (!is_gimple_min_invariant (offset
))
2199 TREE_OPERAND (t
, 2) = offset
;
2200 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2201 post_p
, is_gimple_reg
,
2203 ret
= MIN (ret
, tret
);
2208 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2209 is_gimple_reg
, fb_rvalue
);
2210 ret
= MIN (ret
, tret
);
2215 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2216 so as to match the min_lval predicate. Failure to do so may result
2217 in the creation of large aggregate temporaries. */
2218 tret
= gimplify_expr (p
, pre_p
, post_p
, is_gimple_min_lval
,
2219 fallback
| fb_lvalue
);
2220 ret
= MIN (ret
, tret
);
2222 /* And finally, the indices and operands to BIT_FIELD_REF. During this
2223 loop we also remove any useless conversions. */
2224 for (; VEC_length (tree
, stack
) > 0; )
2226 tree t
= VEC_pop (tree
, stack
);
2228 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2230 /* Gimplify the dimension. */
2231 if (!is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
2233 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2234 is_gimple_val
, fb_rvalue
);
2235 ret
= MIN (ret
, tret
);
2238 else if (TREE_CODE (t
) == BIT_FIELD_REF
)
2240 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2241 is_gimple_val
, fb_rvalue
);
2242 ret
= MIN (ret
, tret
);
2243 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2244 is_gimple_val
, fb_rvalue
);
2245 ret
= MIN (ret
, tret
);
2248 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t
, 0));
2250 /* The innermost expression P may have originally had
2251 TREE_SIDE_EFFECTS set which would have caused all the outer
2252 expressions in *EXPR_P leading to P to also have had
2253 TREE_SIDE_EFFECTS set. */
2254 recalculate_side_effects (t
);
2257 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2258 if ((fallback
& fb_rvalue
) && TREE_CODE (*expr_p
) == COMPONENT_REF
)
2260 canonicalize_component_ref (expr_p
);
2263 VEC_free (tree
, heap
, stack
);
2265 gcc_assert (*expr_p
== expr
|| ret
!= GS_ALL_DONE
);
2270 /* Gimplify the self modifying expression pointed to by EXPR_P
2273 PRE_P points to the list where side effects that must happen before
2274 *EXPR_P should be stored.
2276 POST_P points to the list where side effects that must happen after
2277 *EXPR_P should be stored.
2279 WANT_VALUE is nonzero iff we want to use the value of this expression
2280 in another expression. */
2282 static enum gimplify_status
2283 gimplify_self_mod_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2286 enum tree_code code
;
2287 tree lhs
, lvalue
, rhs
, t1
;
2288 gimple_seq post
= NULL
, *orig_post_p
= post_p
;
2290 enum tree_code arith_code
;
2291 enum gimplify_status ret
;
2292 location_t loc
= EXPR_LOCATION (*expr_p
);
2294 code
= TREE_CODE (*expr_p
);
2296 gcc_assert (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
2297 || code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
);
2299 /* Prefix or postfix? */
2300 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
2301 /* Faster to treat as prefix if result is not used. */
2302 postfix
= want_value
;
2306 /* For postfix, make sure the inner expression's post side effects
2307 are executed after side effects from this expression. */
2311 /* Add or subtract? */
2312 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2313 arith_code
= PLUS_EXPR
;
2315 arith_code
= MINUS_EXPR
;
2317 /* Gimplify the LHS into a GIMPLE lvalue. */
2318 lvalue
= TREE_OPERAND (*expr_p
, 0);
2319 ret
= gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
2320 if (ret
== GS_ERROR
)
2323 /* Extract the operands to the arithmetic operation. */
2325 rhs
= TREE_OPERAND (*expr_p
, 1);
2327 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2328 that as the result value and in the postqueue operation. We also
2329 make sure to make lvalue a minimal lval, see
2330 gcc.c-torture/execute/20040313-1.c for an example where this matters. */
2333 if (!is_gimple_min_lval (lvalue
))
2335 mark_addressable (lvalue
);
2336 lvalue
= build_fold_addr_expr_loc (input_location
, lvalue
);
2337 gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
2338 lvalue
= build_fold_indirect_ref_loc (input_location
, lvalue
);
2340 ret
= gimplify_expr (&lhs
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
2341 if (ret
== GS_ERROR
)
2345 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2346 if (POINTER_TYPE_P (TREE_TYPE (lhs
)))
2348 rhs
= convert_to_ptrofftype_loc (loc
, rhs
);
2349 if (arith_code
== MINUS_EXPR
)
2350 rhs
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
2351 arith_code
= POINTER_PLUS_EXPR
;
2356 tree t2
= get_initialized_tmp_var (lhs
, pre_p
, NULL
);
2357 t1
= build2 (arith_code
, TREE_TYPE (*expr_p
), t2
, rhs
);
2358 gimplify_assign (lvalue
, t1
, pre_p
);
2359 gimplify_seq_add_seq (orig_post_p
, post
);
2365 t1
= build2 (arith_code
, TREE_TYPE (*expr_p
), lhs
, rhs
);
2366 *expr_p
= build2 (MODIFY_EXPR
, TREE_TYPE (lvalue
), lvalue
, t1
);
2371 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2374 maybe_with_size_expr (tree
*expr_p
)
2376 tree expr
= *expr_p
;
2377 tree type
= TREE_TYPE (expr
);
2380 /* If we've already wrapped this or the type is error_mark_node, we can't do
2382 if (TREE_CODE (expr
) == WITH_SIZE_EXPR
2383 || type
== error_mark_node
)
2386 /* If the size isn't known or is a constant, we have nothing to do. */
2387 size
= TYPE_SIZE_UNIT (type
);
2388 if (!size
|| TREE_CODE (size
) == INTEGER_CST
)
2391 /* Otherwise, make a WITH_SIZE_EXPR. */
2392 size
= unshare_expr (size
);
2393 size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (size
, expr
);
2394 *expr_p
= build2 (WITH_SIZE_EXPR
, type
, expr
, size
);
2397 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2398 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2401 static enum gimplify_status
2402 gimplify_arg (tree
*arg_p
, gimple_seq
*pre_p
, location_t call_location
)
2404 bool (*test
) (tree
);
2407 /* In general, we allow lvalues for function arguments to avoid
2408 extra overhead of copying large aggregates out of even larger
2409 aggregates into temporaries only to copy the temporaries to
2410 the argument list. Make optimizers happy by pulling out to
2411 temporaries those types that fit in registers. */
2412 if (is_gimple_reg_type (TREE_TYPE (*arg_p
)))
2413 test
= is_gimple_val
, fb
= fb_rvalue
;
2416 test
= is_gimple_lvalue
, fb
= fb_either
;
2417 /* Also strip a TARGET_EXPR that would force an extra copy. */
2418 if (TREE_CODE (*arg_p
) == TARGET_EXPR
)
2420 tree init
= TARGET_EXPR_INITIAL (*arg_p
);
2422 && !VOID_TYPE_P (TREE_TYPE (init
)))
2427 /* If this is a variable sized type, we must remember the size. */
2428 maybe_with_size_expr (arg_p
);
2430 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2431 /* Make sure arguments have the same location as the function call
2433 protected_set_expr_location (*arg_p
, call_location
);
2435 /* There is a sequence point before a function call. Side effects in
2436 the argument list must occur before the actual call. So, when
2437 gimplifying arguments, force gimplify_expr to use an internal
2438 post queue which is then appended to the end of PRE_P. */
2439 return gimplify_expr (arg_p
, pre_p
, NULL
, test
, fb
);
2442 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2443 WANT_VALUE is true if the result of the call is desired. */
2445 static enum gimplify_status
2446 gimplify_call_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
2448 tree fndecl
, parms
, p
, fnptrtype
;
2449 enum gimplify_status ret
;
2452 bool builtin_va_start_p
= FALSE
;
2453 location_t loc
= EXPR_LOCATION (*expr_p
);
2455 gcc_assert (TREE_CODE (*expr_p
) == CALL_EXPR
);
2457 /* For reliable diagnostics during inlining, it is necessary that
2458 every call_expr be annotated with file and line. */
2459 if (! EXPR_HAS_LOCATION (*expr_p
))
2460 SET_EXPR_LOCATION (*expr_p
, input_location
);
2462 /* This may be a call to a builtin function.
2464 Builtin function calls may be transformed into different
2465 (and more efficient) builtin function calls under certain
2466 circumstances. Unfortunately, gimplification can muck things
2467 up enough that the builtin expanders are not aware that certain
2468 transformations are still valid.
2470 So we attempt transformation/gimplification of the call before
2471 we gimplify the CALL_EXPR. At this time we do not manage to
2472 transform all calls in the same manner as the expanders do, but
2473 we do transform most of them. */
2474 fndecl
= get_callee_fndecl (*expr_p
);
2475 if (fndecl
&& DECL_BUILT_IN (fndecl
))
2477 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2479 if (new_tree
&& new_tree
!= *expr_p
)
2481 /* There was a transformation of this call which computes the
2482 same value, but in a more efficient way. Return and try
2488 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
2489 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_VA_START
)
2491 builtin_va_start_p
= TRUE
;
2492 if (call_expr_nargs (*expr_p
) < 2)
2494 error ("too few arguments to function %<va_start%>");
2495 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2499 if (fold_builtin_next_arg (*expr_p
, true))
2501 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2507 /* Remember the original function pointer type. */
2508 fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*expr_p
));
2510 /* There is a sequence point before the call, so any side effects in
2511 the calling expression must occur before the actual call. Force
2512 gimplify_expr to use an internal post queue. */
2513 ret
= gimplify_expr (&CALL_EXPR_FN (*expr_p
), pre_p
, NULL
,
2514 is_gimple_call_addr
, fb_rvalue
);
2516 nargs
= call_expr_nargs (*expr_p
);
2518 /* Get argument types for verification. */
2519 fndecl
= get_callee_fndecl (*expr_p
);
2522 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2523 else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p
))))
2524 parms
= TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p
))));
2526 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
2527 p
= DECL_ARGUMENTS (fndecl
);
2532 for (i
= 0; i
< nargs
&& p
; i
++, p
= TREE_CHAIN (p
))
2535 /* If the last argument is __builtin_va_arg_pack () and it is not
2536 passed as a named argument, decrease the number of CALL_EXPR
2537 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2540 && TREE_CODE (CALL_EXPR_ARG (*expr_p
, nargs
- 1)) == CALL_EXPR
)
2542 tree last_arg
= CALL_EXPR_ARG (*expr_p
, nargs
- 1);
2543 tree last_arg_fndecl
= get_callee_fndecl (last_arg
);
2546 && TREE_CODE (last_arg_fndecl
) == FUNCTION_DECL
2547 && DECL_BUILT_IN_CLASS (last_arg_fndecl
) == BUILT_IN_NORMAL
2548 && DECL_FUNCTION_CODE (last_arg_fndecl
) == BUILT_IN_VA_ARG_PACK
)
2550 tree call
= *expr_p
;
2553 *expr_p
= build_call_array_loc (loc
, TREE_TYPE (call
),
2554 CALL_EXPR_FN (call
),
2555 nargs
, CALL_EXPR_ARGP (call
));
2557 /* Copy all CALL_EXPR flags, location and block, except
2558 CALL_EXPR_VA_ARG_PACK flag. */
2559 CALL_EXPR_STATIC_CHAIN (*expr_p
) = CALL_EXPR_STATIC_CHAIN (call
);
2560 CALL_EXPR_TAILCALL (*expr_p
) = CALL_EXPR_TAILCALL (call
);
2561 CALL_EXPR_RETURN_SLOT_OPT (*expr_p
)
2562 = CALL_EXPR_RETURN_SLOT_OPT (call
);
2563 CALL_FROM_THUNK_P (*expr_p
) = CALL_FROM_THUNK_P (call
);
2564 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (call
));
2565 TREE_BLOCK (*expr_p
) = TREE_BLOCK (call
);
2567 /* Set CALL_EXPR_VA_ARG_PACK. */
2568 CALL_EXPR_VA_ARG_PACK (*expr_p
) = 1;
2572 /* Finally, gimplify the function arguments. */
2575 for (i
= (PUSH_ARGS_REVERSED
? nargs
- 1 : 0);
2576 PUSH_ARGS_REVERSED
? i
>= 0 : i
< nargs
;
2577 PUSH_ARGS_REVERSED
? i
-- : i
++)
2579 enum gimplify_status t
;
2581 /* Avoid gimplifying the second argument to va_start, which needs to
2582 be the plain PARM_DECL. */
2583 if ((i
!= 1) || !builtin_va_start_p
)
2585 t
= gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
2586 EXPR_LOCATION (*expr_p
));
2594 /* Verify the function result. */
2595 if (want_value
&& fndecl
2596 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype
))))
2598 error_at (loc
, "using result of function returning %<void%>");
2602 /* Try this again in case gimplification exposed something. */
2603 if (ret
!= GS_ERROR
)
2605 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2607 if (new_tree
&& new_tree
!= *expr_p
)
2609 /* There was a transformation of this call which computes the
2610 same value, but in a more efficient way. Return and try
2618 *expr_p
= error_mark_node
;
2622 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2623 decl. This allows us to eliminate redundant or useless
2624 calls to "const" functions. */
2625 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
2627 int flags
= call_expr_flags (*expr_p
);
2628 if (flags
& (ECF_CONST
| ECF_PURE
)
2629 /* An infinite loop is considered a side effect. */
2630 && !(flags
& (ECF_LOOPING_CONST_OR_PURE
)))
2631 TREE_SIDE_EFFECTS (*expr_p
) = 0;
2634 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2635 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2636 form and delegate the creation of a GIMPLE_CALL to
2637 gimplify_modify_expr. This is always possible because when
2638 WANT_VALUE is true, the caller wants the result of this call into
2639 a temporary, which means that we will emit an INIT_EXPR in
2640 internal_get_tmp_var which will then be handled by
2641 gimplify_modify_expr. */
2644 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2645 have to do is replicate it as a GIMPLE_CALL tuple. */
2646 gimple_stmt_iterator gsi
;
2647 call
= gimple_build_call_from_tree (*expr_p
);
2648 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
2649 gimplify_seq_add_stmt (pre_p
, call
);
2650 gsi
= gsi_last (*pre_p
);
2652 *expr_p
= NULL_TREE
;
2655 /* Remember the original function type. */
2656 CALL_EXPR_FN (*expr_p
) = build1 (NOP_EXPR
, fnptrtype
,
2657 CALL_EXPR_FN (*expr_p
));
2662 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2663 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2665 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2666 condition is true or false, respectively. If null, we should generate
2667 our own to skip over the evaluation of this specific expression.
2669 LOCUS is the source location of the COND_EXPR.
2671 This function is the tree equivalent of do_jump.
2673 shortcut_cond_r should only be called by shortcut_cond_expr. */
2676 shortcut_cond_r (tree pred
, tree
*true_label_p
, tree
*false_label_p
,
2679 tree local_label
= NULL_TREE
;
2680 tree t
, expr
= NULL
;
2682 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2683 retain the shortcut semantics. Just insert the gotos here;
2684 shortcut_cond_expr will append the real blocks later. */
2685 if (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2687 location_t new_locus
;
2689 /* Turn if (a && b) into
2691 if (a); else goto no;
2692 if (b) goto yes; else goto no;
2695 if (false_label_p
== NULL
)
2696 false_label_p
= &local_label
;
2698 /* Keep the original source location on the first 'if'. */
2699 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), NULL
, false_label_p
, locus
);
2700 append_to_statement_list (t
, &expr
);
2702 /* Set the source location of the && on the second 'if'. */
2703 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2704 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2706 append_to_statement_list (t
, &expr
);
2708 else if (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2710 location_t new_locus
;
2712 /* Turn if (a || b) into
2715 if (b) goto yes; else goto no;
2718 if (true_label_p
== NULL
)
2719 true_label_p
= &local_label
;
2721 /* Keep the original source location on the first 'if'. */
2722 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), true_label_p
, NULL
, locus
);
2723 append_to_statement_list (t
, &expr
);
2725 /* Set the source location of the || on the second 'if'. */
2726 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2727 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2729 append_to_statement_list (t
, &expr
);
2731 else if (TREE_CODE (pred
) == COND_EXPR
2732 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 1)))
2733 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 2))))
2735 location_t new_locus
;
2737 /* As long as we're messing with gotos, turn if (a ? b : c) into
2739 if (b) goto yes; else goto no;
2741 if (c) goto yes; else goto no;
2743 Don't do this if one of the arms has void type, which can happen
2744 in C++ when the arm is throw. */
2746 /* Keep the original source location on the first 'if'. Set the source
2747 location of the ? on the second 'if'. */
2748 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2749 expr
= build3 (COND_EXPR
, void_type_node
, TREE_OPERAND (pred
, 0),
2750 shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
,
2751 false_label_p
, locus
),
2752 shortcut_cond_r (TREE_OPERAND (pred
, 2), true_label_p
,
2753 false_label_p
, new_locus
));
2757 expr
= build3 (COND_EXPR
, void_type_node
, pred
,
2758 build_and_jump (true_label_p
),
2759 build_and_jump (false_label_p
));
2760 SET_EXPR_LOCATION (expr
, locus
);
2765 t
= build1 (LABEL_EXPR
, void_type_node
, local_label
);
2766 append_to_statement_list (t
, &expr
);
2772 /* Given a conditional expression EXPR with short-circuit boolean
2773 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2774 predicate appart into the equivalent sequence of conditionals. */
2777 shortcut_cond_expr (tree expr
)
2779 tree pred
= TREE_OPERAND (expr
, 0);
2780 tree then_
= TREE_OPERAND (expr
, 1);
2781 tree else_
= TREE_OPERAND (expr
, 2);
2782 tree true_label
, false_label
, end_label
, t
;
2784 tree
*false_label_p
;
2785 bool emit_end
, emit_false
, jump_over_else
;
2786 bool then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2787 bool else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2789 /* First do simple transformations. */
2792 /* If there is no 'else', turn
2795 if (a) if (b) then c. */
2796 while (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2798 /* Keep the original source location on the first 'if'. */
2799 location_t locus
= EXPR_LOC_OR_HERE (expr
);
2800 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2801 /* Set the source location of the && on the second 'if'. */
2802 if (EXPR_HAS_LOCATION (pred
))
2803 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2804 then_
= shortcut_cond_expr (expr
);
2805 then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2806 pred
= TREE_OPERAND (pred
, 0);
2807 expr
= build3 (COND_EXPR
, void_type_node
, pred
, then_
, NULL_TREE
);
2808 SET_EXPR_LOCATION (expr
, locus
);
2814 /* If there is no 'then', turn
2817 if (a); else if (b); else d. */
2818 while (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2820 /* Keep the original source location on the first 'if'. */
2821 location_t locus
= EXPR_LOC_OR_HERE (expr
);
2822 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2823 /* Set the source location of the || on the second 'if'. */
2824 if (EXPR_HAS_LOCATION (pred
))
2825 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2826 else_
= shortcut_cond_expr (expr
);
2827 else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2828 pred
= TREE_OPERAND (pred
, 0);
2829 expr
= build3 (COND_EXPR
, void_type_node
, pred
, NULL_TREE
, else_
);
2830 SET_EXPR_LOCATION (expr
, locus
);
2834 /* If we're done, great. */
2835 if (TREE_CODE (pred
) != TRUTH_ANDIF_EXPR
2836 && TREE_CODE (pred
) != TRUTH_ORIF_EXPR
)
2839 /* Otherwise we need to mess with gotos. Change
2842 if (a); else goto no;
2845 and recursively gimplify the condition. */
2847 true_label
= false_label
= end_label
= NULL_TREE
;
2849 /* If our arms just jump somewhere, hijack those labels so we don't
2850 generate jumps to jumps. */
2853 && TREE_CODE (then_
) == GOTO_EXPR
2854 && TREE_CODE (GOTO_DESTINATION (then_
)) == LABEL_DECL
)
2856 true_label
= GOTO_DESTINATION (then_
);
2862 && TREE_CODE (else_
) == GOTO_EXPR
2863 && TREE_CODE (GOTO_DESTINATION (else_
)) == LABEL_DECL
)
2865 false_label
= GOTO_DESTINATION (else_
);
2870 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2872 true_label_p
= &true_label
;
2874 true_label_p
= NULL
;
2876 /* The 'else' branch also needs a label if it contains interesting code. */
2877 if (false_label
|| else_se
)
2878 false_label_p
= &false_label
;
2880 false_label_p
= NULL
;
2882 /* If there was nothing else in our arms, just forward the label(s). */
2883 if (!then_se
&& !else_se
)
2884 return shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2885 EXPR_LOC_OR_HERE (expr
));
2887 /* If our last subexpression already has a terminal label, reuse it. */
2889 t
= expr_last (else_
);
2891 t
= expr_last (then_
);
2894 if (t
&& TREE_CODE (t
) == LABEL_EXPR
)
2895 end_label
= LABEL_EXPR_LABEL (t
);
2897 /* If we don't care about jumping to the 'else' branch, jump to the end
2898 if the condition is false. */
2900 false_label_p
= &end_label
;
2902 /* We only want to emit these labels if we aren't hijacking them. */
2903 emit_end
= (end_label
== NULL_TREE
);
2904 emit_false
= (false_label
== NULL_TREE
);
2906 /* We only emit the jump over the else clause if we have to--if the
2907 then clause may fall through. Otherwise we can wind up with a
2908 useless jump and a useless label at the end of gimplified code,
2909 which will cause us to think that this conditional as a whole
2910 falls through even if it doesn't. If we then inline a function
2911 which ends with such a condition, that can cause us to issue an
2912 inappropriate warning about control reaching the end of a
2913 non-void function. */
2914 jump_over_else
= block_may_fallthru (then_
);
2916 pred
= shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2917 EXPR_LOC_OR_HERE (expr
));
2920 append_to_statement_list (pred
, &expr
);
2922 append_to_statement_list (then_
, &expr
);
2927 tree last
= expr_last (expr
);
2928 t
= build_and_jump (&end_label
);
2929 if (EXPR_HAS_LOCATION (last
))
2930 SET_EXPR_LOCATION (t
, EXPR_LOCATION (last
));
2931 append_to_statement_list (t
, &expr
);
2935 t
= build1 (LABEL_EXPR
, void_type_node
, false_label
);
2936 append_to_statement_list (t
, &expr
);
2938 append_to_statement_list (else_
, &expr
);
2940 if (emit_end
&& end_label
)
2942 t
= build1 (LABEL_EXPR
, void_type_node
, end_label
);
2943 append_to_statement_list (t
, &expr
);
2949 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2952 gimple_boolify (tree expr
)
2954 tree type
= TREE_TYPE (expr
);
2955 location_t loc
= EXPR_LOCATION (expr
);
2957 if (TREE_CODE (expr
) == NE_EXPR
2958 && TREE_CODE (TREE_OPERAND (expr
, 0)) == CALL_EXPR
2959 && integer_zerop (TREE_OPERAND (expr
, 1)))
2961 tree call
= TREE_OPERAND (expr
, 0);
2962 tree fn
= get_callee_fndecl (call
);
2964 /* For __builtin_expect ((long) (x), y) recurse into x as well
2965 if x is truth_value_p. */
2967 && DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
2968 && DECL_FUNCTION_CODE (fn
) == BUILT_IN_EXPECT
2969 && call_expr_nargs (call
) == 2)
2971 tree arg
= CALL_EXPR_ARG (call
, 0);
2974 if (TREE_CODE (arg
) == NOP_EXPR
2975 && TREE_TYPE (arg
) == TREE_TYPE (call
))
2976 arg
= TREE_OPERAND (arg
, 0);
2977 if (truth_value_p (TREE_CODE (arg
)))
2979 arg
= gimple_boolify (arg
);
2980 CALL_EXPR_ARG (call
, 0)
2981 = fold_convert_loc (loc
, TREE_TYPE (call
), arg
);
2987 switch (TREE_CODE (expr
))
2989 case TRUTH_AND_EXPR
:
2991 case TRUTH_XOR_EXPR
:
2992 case TRUTH_ANDIF_EXPR
:
2993 case TRUTH_ORIF_EXPR
:
2994 /* Also boolify the arguments of truth exprs. */
2995 TREE_OPERAND (expr
, 1) = gimple_boolify (TREE_OPERAND (expr
, 1));
2998 case TRUTH_NOT_EXPR
:
2999 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3001 /* These expressions always produce boolean results. */
3002 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3003 TREE_TYPE (expr
) = boolean_type_node
;
3007 if (COMPARISON_CLASS_P (expr
))
3009 /* There expressions always prduce boolean results. */
3010 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3011 TREE_TYPE (expr
) = boolean_type_node
;
3014 /* Other expressions that get here must have boolean values, but
3015 might need to be converted to the appropriate mode. */
3016 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
3018 return fold_convert_loc (loc
, boolean_type_node
, expr
);
3022 /* Given a conditional expression *EXPR_P without side effects, gimplify
3023 its operands. New statements are inserted to PRE_P. */
3025 static enum gimplify_status
3026 gimplify_pure_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
)
3028 tree expr
= *expr_p
, cond
;
3029 enum gimplify_status ret
, tret
;
3030 enum tree_code code
;
3032 cond
= gimple_boolify (COND_EXPR_COND (expr
));
3034 /* We need to handle && and || specially, as their gimplification
3035 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
3036 code
= TREE_CODE (cond
);
3037 if (code
== TRUTH_ANDIF_EXPR
)
3038 TREE_SET_CODE (cond
, TRUTH_AND_EXPR
);
3039 else if (code
== TRUTH_ORIF_EXPR
)
3040 TREE_SET_CODE (cond
, TRUTH_OR_EXPR
);
3041 ret
= gimplify_expr (&cond
, pre_p
, NULL
, is_gimple_condexpr
, fb_rvalue
);
3042 COND_EXPR_COND (*expr_p
) = cond
;
3044 tret
= gimplify_expr (&COND_EXPR_THEN (expr
), pre_p
, NULL
,
3045 is_gimple_val
, fb_rvalue
);
3046 ret
= MIN (ret
, tret
);
3047 tret
= gimplify_expr (&COND_EXPR_ELSE (expr
), pre_p
, NULL
,
3048 is_gimple_val
, fb_rvalue
);
3050 return MIN (ret
, tret
);
3053 /* Return true if evaluating EXPR could trap.
3054 EXPR is GENERIC, while tree_could_trap_p can be called
3058 generic_expr_could_trap_p (tree expr
)
3062 if (!expr
|| is_gimple_val (expr
))
3065 if (!EXPR_P (expr
) || tree_could_trap_p (expr
))
3068 n
= TREE_OPERAND_LENGTH (expr
);
3069 for (i
= 0; i
< n
; i
++)
3070 if (generic_expr_could_trap_p (TREE_OPERAND (expr
, i
)))
3076 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3085 The second form is used when *EXPR_P is of type void.
3087 PRE_P points to the list where side effects that must happen before
3088 *EXPR_P should be stored. */
3090 static enum gimplify_status
3091 gimplify_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
, fallback_t fallback
)
3093 tree expr
= *expr_p
;
3094 tree type
= TREE_TYPE (expr
);
3095 location_t loc
= EXPR_LOCATION (expr
);
3096 tree tmp
, arm1
, arm2
;
3097 enum gimplify_status ret
;
3098 tree label_true
, label_false
, label_cont
;
3099 bool have_then_clause_p
, have_else_clause_p
;
3101 enum tree_code pred_code
;
3102 gimple_seq seq
= NULL
;
3104 /* If this COND_EXPR has a value, copy the values into a temporary within
3106 if (!VOID_TYPE_P (type
))
3108 tree then_
= TREE_OPERAND (expr
, 1), else_
= TREE_OPERAND (expr
, 2);
3111 /* If either an rvalue is ok or we do not require an lvalue, create the
3112 temporary. But we cannot do that if the type is addressable. */
3113 if (((fallback
& fb_rvalue
) || !(fallback
& fb_lvalue
))
3114 && !TREE_ADDRESSABLE (type
))
3116 if (gimplify_ctxp
->allow_rhs_cond_expr
3117 /* If either branch has side effects or could trap, it can't be
3118 evaluated unconditionally. */
3119 && !TREE_SIDE_EFFECTS (then_
)
3120 && !generic_expr_could_trap_p (then_
)
3121 && !TREE_SIDE_EFFECTS (else_
)
3122 && !generic_expr_could_trap_p (else_
))
3123 return gimplify_pure_cond_expr (expr_p
, pre_p
);
3125 tmp
= create_tmp_var (type
, "iftmp");
3129 /* Otherwise, only create and copy references to the values. */
3132 type
= build_pointer_type (type
);
3134 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3135 then_
= build_fold_addr_expr_loc (loc
, then_
);
3137 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3138 else_
= build_fold_addr_expr_loc (loc
, else_
);
3141 = build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0), then_
, else_
);
3143 tmp
= create_tmp_var (type
, "iftmp");
3144 result
= build_simple_mem_ref_loc (loc
, tmp
);
3147 /* Build the new then clause, `tmp = then_;'. But don't build the
3148 assignment if the value is void; in C++ it can be if it's a throw. */
3149 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3150 TREE_OPERAND (expr
, 1) = build2 (MODIFY_EXPR
, type
, tmp
, then_
);
3152 /* Similarly, build the new else clause, `tmp = else_;'. */
3153 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3154 TREE_OPERAND (expr
, 2) = build2 (MODIFY_EXPR
, type
, tmp
, else_
);
3156 TREE_TYPE (expr
) = void_type_node
;
3157 recalculate_side_effects (expr
);
3159 /* Move the COND_EXPR to the prequeue. */
3160 gimplify_stmt (&expr
, pre_p
);
3166 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
3167 STRIP_TYPE_NOPS (TREE_OPERAND (expr
, 0));
3168 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == COMPOUND_EXPR
)
3169 gimplify_compound_expr (&TREE_OPERAND (expr
, 0), pre_p
, true);
3171 /* Make sure the condition has BOOLEAN_TYPE. */
3172 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3174 /* Break apart && and || conditions. */
3175 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ANDIF_EXPR
3176 || TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ORIF_EXPR
)
3178 expr
= shortcut_cond_expr (expr
);
3180 if (expr
!= *expr_p
)
3184 /* We can't rely on gimplify_expr to re-gimplify the expanded
3185 form properly, as cleanups might cause the target labels to be
3186 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3187 set up a conditional context. */
3188 gimple_push_condition ();
3189 gimplify_stmt (expr_p
, &seq
);
3190 gimple_pop_condition (pre_p
);
3191 gimple_seq_add_seq (pre_p
, seq
);
3197 /* Now do the normal gimplification. */
3199 /* Gimplify condition. */
3200 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, NULL
, is_gimple_condexpr
,
3202 if (ret
== GS_ERROR
)
3204 gcc_assert (TREE_OPERAND (expr
, 0) != NULL_TREE
);
3206 gimple_push_condition ();
3208 have_then_clause_p
= have_else_clause_p
= false;
3209 if (TREE_OPERAND (expr
, 1) != NULL
3210 && TREE_CODE (TREE_OPERAND (expr
, 1)) == GOTO_EXPR
3211 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 1))) == LABEL_DECL
3212 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 1)))
3213 == current_function_decl
)
3214 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3215 have different locations, otherwise we end up with incorrect
3216 location information on the branches. */
3218 || !EXPR_HAS_LOCATION (expr
)
3219 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 1))
3220 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 1))))
3222 label_true
= GOTO_DESTINATION (TREE_OPERAND (expr
, 1));
3223 have_then_clause_p
= true;
3226 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
3227 if (TREE_OPERAND (expr
, 2) != NULL
3228 && TREE_CODE (TREE_OPERAND (expr
, 2)) == GOTO_EXPR
3229 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 2))) == LABEL_DECL
3230 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 2)))
3231 == current_function_decl
)
3232 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3233 have different locations, otherwise we end up with incorrect
3234 location information on the branches. */
3236 || !EXPR_HAS_LOCATION (expr
)
3237 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 2))
3238 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 2))))
3240 label_false
= GOTO_DESTINATION (TREE_OPERAND (expr
, 2));
3241 have_else_clause_p
= true;
3244 label_false
= create_artificial_label (UNKNOWN_LOCATION
);
3246 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr
), &pred_code
, &arm1
,
3249 gimple_cond
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
,
3252 gimplify_seq_add_stmt (&seq
, gimple_cond
);
3253 label_cont
= NULL_TREE
;
3254 if (!have_then_clause_p
)
3256 /* For if (...) {} else { code; } put label_true after
3258 if (TREE_OPERAND (expr
, 1) == NULL_TREE
3259 && !have_else_clause_p
3260 && TREE_OPERAND (expr
, 2) != NULL_TREE
)
3261 label_cont
= label_true
;
3264 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_true
));
3265 have_then_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 1), &seq
);
3266 /* For if (...) { code; } else {} or
3267 if (...) { code; } else goto label; or
3268 if (...) { code; return; } else { ... }
3269 label_cont isn't needed. */
3270 if (!have_else_clause_p
3271 && TREE_OPERAND (expr
, 2) != NULL_TREE
3272 && gimple_seq_may_fallthru (seq
))
3275 label_cont
= create_artificial_label (UNKNOWN_LOCATION
);
3277 g
= gimple_build_goto (label_cont
);
3279 /* GIMPLE_COND's are very low level; they have embedded
3280 gotos. This particular embedded goto should not be marked
3281 with the location of the original COND_EXPR, as it would
3282 correspond to the COND_EXPR's condition, not the ELSE or the
3283 THEN arms. To avoid marking it with the wrong location, flag
3284 it as "no location". */
3285 gimple_set_do_not_emit_location (g
);
3287 gimplify_seq_add_stmt (&seq
, g
);
3291 if (!have_else_clause_p
)
3293 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_false
));
3294 have_else_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 2), &seq
);
3297 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_cont
));
3299 gimple_pop_condition (pre_p
);
3300 gimple_seq_add_seq (pre_p
, seq
);
3302 if (ret
== GS_ERROR
)
3304 else if (have_then_clause_p
|| have_else_clause_p
)
3308 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3309 expr
= TREE_OPERAND (expr
, 0);
3310 gimplify_stmt (&expr
, pre_p
);
3317 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3318 to be marked addressable.
3320 We cannot rely on such an expression being directly markable if a temporary
3321 has been created by the gimplification. In this case, we create another
3322 temporary and initialize it with a copy, which will become a store after we
3323 mark it addressable. This can happen if the front-end passed us something
3324 that it could not mark addressable yet, like a Fortran pass-by-reference
3325 parameter (int) floatvar. */
3328 prepare_gimple_addressable (tree
*expr_p
, gimple_seq
*seq_p
)
3330 while (handled_component_p (*expr_p
))
3331 expr_p
= &TREE_OPERAND (*expr_p
, 0);
3332 if (is_gimple_reg (*expr_p
))
3333 *expr_p
= get_initialized_tmp_var (*expr_p
, seq_p
, NULL
);
3336 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3337 a call to __builtin_memcpy. */
3339 static enum gimplify_status
3340 gimplify_modify_expr_to_memcpy (tree
*expr_p
, tree size
, bool want_value
,
3343 tree t
, to
, to_ptr
, from
, from_ptr
;
3345 location_t loc
= EXPR_LOCATION (*expr_p
);
3347 to
= TREE_OPERAND (*expr_p
, 0);
3348 from
= TREE_OPERAND (*expr_p
, 1);
3350 /* Mark the RHS addressable. Beware that it may not be possible to do so
3351 directly if a temporary has been created by the gimplification. */
3352 prepare_gimple_addressable (&from
, seq_p
);
3354 mark_addressable (from
);
3355 from_ptr
= build_fold_addr_expr_loc (loc
, from
);
3356 gimplify_arg (&from_ptr
, seq_p
, loc
);
3358 mark_addressable (to
);
3359 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3360 gimplify_arg (&to_ptr
, seq_p
, loc
);
3362 t
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3364 gs
= gimple_build_call (t
, 3, to_ptr
, from_ptr
, size
);
3368 /* tmp = memcpy() */
3369 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3370 gimple_call_set_lhs (gs
, t
);
3371 gimplify_seq_add_stmt (seq_p
, gs
);
3373 *expr_p
= build_simple_mem_ref (t
);
3377 gimplify_seq_add_stmt (seq_p
, gs
);
3382 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3383 a call to __builtin_memset. In this case we know that the RHS is
3384 a CONSTRUCTOR with an empty element list. */
3386 static enum gimplify_status
3387 gimplify_modify_expr_to_memset (tree
*expr_p
, tree size
, bool want_value
,
3390 tree t
, from
, to
, to_ptr
;
3392 location_t loc
= EXPR_LOCATION (*expr_p
);
3394 /* Assert our assumptions, to abort instead of producing wrong code
3395 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3396 not be immediately exposed. */
3397 from
= TREE_OPERAND (*expr_p
, 1);
3398 if (TREE_CODE (from
) == WITH_SIZE_EXPR
)
3399 from
= TREE_OPERAND (from
, 0);
3401 gcc_assert (TREE_CODE (from
) == CONSTRUCTOR
3402 && VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (from
)));
3405 to
= TREE_OPERAND (*expr_p
, 0);
3407 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3408 gimplify_arg (&to_ptr
, seq_p
, loc
);
3409 t
= builtin_decl_implicit (BUILT_IN_MEMSET
);
3411 gs
= gimple_build_call (t
, 3, to_ptr
, integer_zero_node
, size
);
3415 /* tmp = memset() */
3416 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3417 gimple_call_set_lhs (gs
, t
);
3418 gimplify_seq_add_stmt (seq_p
, gs
);
3420 *expr_p
= build1 (INDIRECT_REF
, TREE_TYPE (to
), t
);
3424 gimplify_seq_add_stmt (seq_p
, gs
);
3429 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3430 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3431 assignment. Return non-null if we detect a potential overlap. */
3433 struct gimplify_init_ctor_preeval_data
3435 /* The base decl of the lhs object. May be NULL, in which case we
3436 have to assume the lhs is indirect. */
3439 /* The alias set of the lhs object. */
3440 alias_set_type lhs_alias_set
;
3444 gimplify_init_ctor_preeval_1 (tree
*tp
, int *walk_subtrees
, void *xdata
)
3446 struct gimplify_init_ctor_preeval_data
*data
3447 = (struct gimplify_init_ctor_preeval_data
*) xdata
;
3450 /* If we find the base object, obviously we have overlap. */
3451 if (data
->lhs_base_decl
== t
)
3454 /* If the constructor component is indirect, determine if we have a
3455 potential overlap with the lhs. The only bits of information we
3456 have to go on at this point are addressability and alias sets. */
3457 if ((INDIRECT_REF_P (t
)
3458 || TREE_CODE (t
) == MEM_REF
)
3459 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3460 && alias_sets_conflict_p (data
->lhs_alias_set
, get_alias_set (t
)))
3463 /* If the constructor component is a call, determine if it can hide a
3464 potential overlap with the lhs through an INDIRECT_REF like above.
3465 ??? Ugh - this is completely broken. In fact this whole analysis
3466 doesn't look conservative. */
3467 if (TREE_CODE (t
) == CALL_EXPR
)
3469 tree type
, fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t
)));
3471 for (type
= TYPE_ARG_TYPES (fntype
); type
; type
= TREE_CHAIN (type
))
3472 if (POINTER_TYPE_P (TREE_VALUE (type
))
3473 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3474 && alias_sets_conflict_p (data
->lhs_alias_set
,
3476 (TREE_TYPE (TREE_VALUE (type
)))))
3480 if (IS_TYPE_OR_DECL_P (t
))
3485 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3486 force values that overlap with the lhs (as described by *DATA)
3487 into temporaries. */
3490 gimplify_init_ctor_preeval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3491 struct gimplify_init_ctor_preeval_data
*data
)
3493 enum gimplify_status one
;
3495 /* If the value is constant, then there's nothing to pre-evaluate. */
3496 if (TREE_CONSTANT (*expr_p
))
3498 /* Ensure it does not have side effects, it might contain a reference to
3499 the object we're initializing. */
3500 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p
));
3504 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3505 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p
)))
3508 /* Recurse for nested constructors. */
3509 if (TREE_CODE (*expr_p
) == CONSTRUCTOR
)
3511 unsigned HOST_WIDE_INT ix
;
3512 constructor_elt
*ce
;
3513 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (*expr_p
);
3515 FOR_EACH_VEC_ELT (constructor_elt
, v
, ix
, ce
)
3516 gimplify_init_ctor_preeval (&ce
->value
, pre_p
, post_p
, data
);
3521 /* If this is a variable sized type, we must remember the size. */
3522 maybe_with_size_expr (expr_p
);
3524 /* Gimplify the constructor element to something appropriate for the rhs
3525 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3526 the gimplifier will consider this a store to memory. Doing this
3527 gimplification now means that we won't have to deal with complicated
3528 language-specific trees, nor trees like SAVE_EXPR that can induce
3529 exponential search behavior. */
3530 one
= gimplify_expr (expr_p
, pre_p
, post_p
, is_gimple_mem_rhs
, fb_rvalue
);
3531 if (one
== GS_ERROR
)
3537 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3538 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3539 always be true for all scalars, since is_gimple_mem_rhs insists on a
3540 temporary variable for them. */
3541 if (DECL_P (*expr_p
))
3544 /* If this is of variable size, we have no choice but to assume it doesn't
3545 overlap since we can't make a temporary for it. */
3546 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p
))) != INTEGER_CST
)
3549 /* Otherwise, we must search for overlap ... */
3550 if (!walk_tree (expr_p
, gimplify_init_ctor_preeval_1
, data
, NULL
))
3553 /* ... and if found, force the value into a temporary. */
3554 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
3557 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3558 a RANGE_EXPR in a CONSTRUCTOR for an array.
3562 object[var] = value;
3569 We increment var _after_ the loop exit check because we might otherwise
3570 fail if upper == TYPE_MAX_VALUE (type for upper).
3572 Note that we never have to deal with SAVE_EXPRs here, because this has
3573 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3575 static void gimplify_init_ctor_eval (tree
, VEC(constructor_elt
,gc
) *,
3576 gimple_seq
*, bool);
3579 gimplify_init_ctor_eval_range (tree object
, tree lower
, tree upper
,
3580 tree value
, tree array_elt_type
,
3581 gimple_seq
*pre_p
, bool cleared
)
3583 tree loop_entry_label
, loop_exit_label
, fall_thru_label
;
3584 tree var
, var_type
, cref
, tmp
;
3586 loop_entry_label
= create_artificial_label (UNKNOWN_LOCATION
);
3587 loop_exit_label
= create_artificial_label (UNKNOWN_LOCATION
);
3588 fall_thru_label
= create_artificial_label (UNKNOWN_LOCATION
);
3590 /* Create and initialize the index variable. */
3591 var_type
= TREE_TYPE (upper
);
3592 var
= create_tmp_var (var_type
, NULL
);
3593 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, lower
));
3595 /* Add the loop entry label. */
3596 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_entry_label
));
3598 /* Build the reference. */
3599 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3600 var
, NULL_TREE
, NULL_TREE
);
3602 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3603 the store. Otherwise just assign value to the reference. */
3605 if (TREE_CODE (value
) == CONSTRUCTOR
)
3606 /* NB we might have to call ourself recursively through
3607 gimplify_init_ctor_eval if the value is a constructor. */
3608 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3611 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (cref
, value
));
3613 /* We exit the loop when the index var is equal to the upper bound. */
3614 gimplify_seq_add_stmt (pre_p
,
3615 gimple_build_cond (EQ_EXPR
, var
, upper
,
3616 loop_exit_label
, fall_thru_label
));
3618 gimplify_seq_add_stmt (pre_p
, gimple_build_label (fall_thru_label
));
3620 /* Otherwise, increment the index var... */
3621 tmp
= build2 (PLUS_EXPR
, var_type
, var
,
3622 fold_convert (var_type
, integer_one_node
));
3623 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, tmp
));
3625 /* ...and jump back to the loop entry. */
3626 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (loop_entry_label
));
3628 /* Add the loop exit label. */
3629 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_exit_label
));
3632 /* Return true if FDECL is accessing a field that is zero sized. */
3635 zero_sized_field_decl (const_tree fdecl
)
3637 if (TREE_CODE (fdecl
) == FIELD_DECL
&& DECL_SIZE (fdecl
)
3638 && integer_zerop (DECL_SIZE (fdecl
)))
3643 /* Return true if TYPE is zero sized. */
3646 zero_sized_type (const_tree type
)
3648 if (AGGREGATE_TYPE_P (type
) && TYPE_SIZE (type
)
3649 && integer_zerop (TYPE_SIZE (type
)))
3654 /* A subroutine of gimplify_init_constructor. Generate individual
3655 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3656 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3657 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3661 gimplify_init_ctor_eval (tree object
, VEC(constructor_elt
,gc
) *elts
,
3662 gimple_seq
*pre_p
, bool cleared
)
3664 tree array_elt_type
= NULL
;
3665 unsigned HOST_WIDE_INT ix
;
3666 tree purpose
, value
;
3668 if (TREE_CODE (TREE_TYPE (object
)) == ARRAY_TYPE
)
3669 array_elt_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object
)));
3671 FOR_EACH_CONSTRUCTOR_ELT (elts
, ix
, purpose
, value
)
3675 /* NULL values are created above for gimplification errors. */
3679 if (cleared
&& initializer_zerop (value
))
3682 /* ??? Here's to hoping the front end fills in all of the indices,
3683 so we don't have to figure out what's missing ourselves. */
3684 gcc_assert (purpose
);
3686 /* Skip zero-sized fields, unless value has side-effects. This can
3687 happen with calls to functions returning a zero-sized type, which
3688 we shouldn't discard. As a number of downstream passes don't
3689 expect sets of zero-sized fields, we rely on the gimplification of
3690 the MODIFY_EXPR we make below to drop the assignment statement. */
3691 if (! TREE_SIDE_EFFECTS (value
) && zero_sized_field_decl (purpose
))
3694 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3696 if (TREE_CODE (purpose
) == RANGE_EXPR
)
3698 tree lower
= TREE_OPERAND (purpose
, 0);
3699 tree upper
= TREE_OPERAND (purpose
, 1);
3701 /* If the lower bound is equal to upper, just treat it as if
3702 upper was the index. */
3703 if (simple_cst_equal (lower
, upper
))
3707 gimplify_init_ctor_eval_range (object
, lower
, upper
, value
,
3708 array_elt_type
, pre_p
, cleared
);
3715 /* Do not use bitsizetype for ARRAY_REF indices. */
3716 if (TYPE_DOMAIN (TREE_TYPE (object
)))
3718 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object
))),
3720 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3721 purpose
, NULL_TREE
, NULL_TREE
);
3725 gcc_assert (TREE_CODE (purpose
) == FIELD_DECL
);
3726 cref
= build3 (COMPONENT_REF
, TREE_TYPE (purpose
),
3727 unshare_expr (object
), purpose
, NULL_TREE
);
3730 if (TREE_CODE (value
) == CONSTRUCTOR
3731 && TREE_CODE (TREE_TYPE (value
)) != VECTOR_TYPE
)
3732 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3736 tree init
= build2 (INIT_EXPR
, TREE_TYPE (cref
), cref
, value
);
3737 gimplify_and_add (init
, pre_p
);
3743 /* Return the appropriate RHS predicate for this LHS. */
3746 rhs_predicate_for (tree lhs
)
3748 if (is_gimple_reg (lhs
))
3749 return is_gimple_reg_rhs_or_call
;
3751 return is_gimple_mem_rhs_or_call
;
3754 /* Gimplify a C99 compound literal expression. This just means adding
3755 the DECL_EXPR before the current statement and using its anonymous
3758 static enum gimplify_status
3759 gimplify_compound_literal_expr (tree
*expr_p
, gimple_seq
*pre_p
)
3761 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p
);
3762 tree decl
= DECL_EXPR_DECL (decl_s
);
3763 /* Mark the decl as addressable if the compound literal
3764 expression is addressable now, otherwise it is marked too late
3765 after we gimplify the initialization expression. */
3766 if (TREE_ADDRESSABLE (*expr_p
))
3767 TREE_ADDRESSABLE (decl
) = 1;
3769 /* Preliminarily mark non-addressed complex variables as eligible
3770 for promotion to gimple registers. We'll transform their uses
3772 if ((TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
3773 || TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
)
3774 && !TREE_THIS_VOLATILE (decl
)
3775 && !needs_to_live_in_memory (decl
))
3776 DECL_GIMPLE_REG_P (decl
) = 1;
3778 /* This decl isn't mentioned in the enclosing block, so add it to the
3779 list of temps. FIXME it seems a bit of a kludge to say that
3780 anonymous artificial vars aren't pushed, but everything else is. */
3781 if (DECL_NAME (decl
) == NULL_TREE
&& !DECL_SEEN_IN_BIND_EXPR_P (decl
))
3782 gimple_add_tmp_var (decl
);
3784 gimplify_and_add (decl_s
, pre_p
);
3789 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3790 return a new CONSTRUCTOR if something changed. */
3793 optimize_compound_literals_in_ctor (tree orig_ctor
)
3795 tree ctor
= orig_ctor
;
3796 VEC(constructor_elt
,gc
) *elts
= CONSTRUCTOR_ELTS (ctor
);
3797 unsigned int idx
, num
= VEC_length (constructor_elt
, elts
);
3799 for (idx
= 0; idx
< num
; idx
++)
3801 tree value
= VEC_index (constructor_elt
, elts
, idx
)->value
;
3802 tree newval
= value
;
3803 if (TREE_CODE (value
) == CONSTRUCTOR
)
3804 newval
= optimize_compound_literals_in_ctor (value
);
3805 else if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
3807 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (value
);
3808 tree decl
= DECL_EXPR_DECL (decl_s
);
3809 tree init
= DECL_INITIAL (decl
);
3811 if (!TREE_ADDRESSABLE (value
)
3812 && !TREE_ADDRESSABLE (decl
)
3814 newval
= optimize_compound_literals_in_ctor (init
);
3816 if (newval
== value
)
3819 if (ctor
== orig_ctor
)
3821 ctor
= copy_node (orig_ctor
);
3822 CONSTRUCTOR_ELTS (ctor
) = VEC_copy (constructor_elt
, gc
, elts
);
3823 elts
= CONSTRUCTOR_ELTS (ctor
);
3825 VEC_index (constructor_elt
, elts
, idx
)->value
= newval
;
3830 /* A subroutine of gimplify_modify_expr. Break out elements of a
3831 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3833 Note that we still need to clear any elements that don't have explicit
3834 initializers, so if not all elements are initialized we keep the
3835 original MODIFY_EXPR, we just remove all of the constructor elements.
3837 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3838 GS_ERROR if we would have to create a temporary when gimplifying
3839 this constructor. Otherwise, return GS_OK.
3841 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3843 static enum gimplify_status
3844 gimplify_init_constructor (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3845 bool want_value
, bool notify_temp_creation
)
3847 tree object
, ctor
, type
;
3848 enum gimplify_status ret
;
3849 VEC(constructor_elt
,gc
) *elts
;
3851 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == CONSTRUCTOR
);
3853 if (!notify_temp_creation
)
3855 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
3856 is_gimple_lvalue
, fb_lvalue
);
3857 if (ret
== GS_ERROR
)
3861 object
= TREE_OPERAND (*expr_p
, 0);
3862 ctor
= TREE_OPERAND (*expr_p
, 1) =
3863 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p
, 1));
3864 type
= TREE_TYPE (ctor
);
3865 elts
= CONSTRUCTOR_ELTS (ctor
);
3868 switch (TREE_CODE (type
))
3872 case QUAL_UNION_TYPE
:
3875 struct gimplify_init_ctor_preeval_data preeval_data
;
3876 HOST_WIDE_INT num_ctor_elements
, num_nonzero_elements
;
3877 bool cleared
, complete_p
, valid_const_initializer
;
3879 /* Aggregate types must lower constructors to initialization of
3880 individual elements. The exception is that a CONSTRUCTOR node
3881 with no elements indicates zero-initialization of the whole. */
3882 if (VEC_empty (constructor_elt
, elts
))
3884 if (notify_temp_creation
)
3889 /* Fetch information about the constructor to direct later processing.
3890 We might want to make static versions of it in various cases, and
3891 can only do so if it known to be a valid constant initializer. */
3892 valid_const_initializer
3893 = categorize_ctor_elements (ctor
, &num_nonzero_elements
,
3894 &num_ctor_elements
, &complete_p
);
3896 /* If a const aggregate variable is being initialized, then it
3897 should never be a lose to promote the variable to be static. */
3898 if (valid_const_initializer
3899 && num_nonzero_elements
> 1
3900 && TREE_READONLY (object
)
3901 && TREE_CODE (object
) == VAR_DECL
3902 && (flag_merge_constants
>= 2 || !TREE_ADDRESSABLE (object
)))
3904 if (notify_temp_creation
)
3906 DECL_INITIAL (object
) = ctor
;
3907 TREE_STATIC (object
) = 1;
3908 if (!DECL_NAME (object
))
3909 DECL_NAME (object
) = create_tmp_var_name ("C");
3910 walk_tree (&DECL_INITIAL (object
), force_labels_r
, NULL
, NULL
);
3912 /* ??? C++ doesn't automatically append a .<number> to the
3913 assembler name, and even when it does, it looks a FE private
3914 data structures to figure out what that number should be,
3915 which are not set for this variable. I suppose this is
3916 important for local statics for inline functions, which aren't
3917 "local" in the object file sense. So in order to get a unique
3918 TU-local symbol, we must invoke the lhd version now. */
3919 lhd_set_decl_assembler_name (object
);
3921 *expr_p
= NULL_TREE
;
3925 /* If there are "lots" of initialized elements, even discounting
3926 those that are not address constants (and thus *must* be
3927 computed at runtime), then partition the constructor into
3928 constant and non-constant parts. Block copy the constant
3929 parts in, then generate code for the non-constant parts. */
3930 /* TODO. There's code in cp/typeck.c to do this. */
3932 if (int_size_in_bytes (TREE_TYPE (ctor
)) < 0)
3933 /* store_constructor will ignore the clearing of variable-sized
3934 objects. Initializers for such objects must explicitly set
3935 every field that needs to be set. */
3937 else if (!complete_p
)
3938 /* If the constructor isn't complete, clear the whole object
3941 ??? This ought not to be needed. For any element not present
3942 in the initializer, we should simply set them to zero. Except
3943 we'd need to *find* the elements that are not present, and that
3944 requires trickery to avoid quadratic compile-time behavior in
3945 large cases or excessive memory use in small cases. */
3947 else if (num_ctor_elements
- num_nonzero_elements
3948 > CLEAR_RATIO (optimize_function_for_speed_p (cfun
))
3949 && num_nonzero_elements
< num_ctor_elements
/ 4)
3950 /* If there are "lots" of zeros, it's more efficient to clear
3951 the memory and then set the nonzero elements. */
3956 /* If there are "lots" of initialized elements, and all of them
3957 are valid address constants, then the entire initializer can
3958 be dropped to memory, and then memcpy'd out. Don't do this
3959 for sparse arrays, though, as it's more efficient to follow
3960 the standard CONSTRUCTOR behavior of memset followed by
3961 individual element initialization. Also don't do this for small
3962 all-zero initializers (which aren't big enough to merit
3963 clearing), and don't try to make bitwise copies of
3964 TREE_ADDRESSABLE types. */
3965 if (valid_const_initializer
3966 && !(cleared
|| num_nonzero_elements
== 0)
3967 && !TREE_ADDRESSABLE (type
))
3969 HOST_WIDE_INT size
= int_size_in_bytes (type
);
3972 /* ??? We can still get unbounded array types, at least
3973 from the C++ front end. This seems wrong, but attempt
3974 to work around it for now. */
3977 size
= int_size_in_bytes (TREE_TYPE (object
));
3979 TREE_TYPE (ctor
) = type
= TREE_TYPE (object
);
3982 /* Find the maximum alignment we can assume for the object. */
3983 /* ??? Make use of DECL_OFFSET_ALIGN. */
3984 if (DECL_P (object
))
3985 align
= DECL_ALIGN (object
);
3987 align
= TYPE_ALIGN (type
);
3990 && num_nonzero_elements
> 1
3991 && !can_move_by_pieces (size
, align
))
3993 if (notify_temp_creation
)
3996 walk_tree (&ctor
, force_labels_r
, NULL
, NULL
);
3997 ctor
= tree_output_constant_def (ctor
);
3998 if (!useless_type_conversion_p (type
, TREE_TYPE (ctor
)))
3999 ctor
= build1 (VIEW_CONVERT_EXPR
, type
, ctor
);
4000 TREE_OPERAND (*expr_p
, 1) = ctor
;
4002 /* This is no longer an assignment of a CONSTRUCTOR, but
4003 we still may have processing to do on the LHS. So
4004 pretend we didn't do anything here to let that happen. */
4005 return GS_UNHANDLED
;
4009 /* If the target is volatile, we have non-zero elements and more than
4010 one field to assign, initialize the target from a temporary. */
4011 if (TREE_THIS_VOLATILE (object
)
4012 && !TREE_ADDRESSABLE (type
)
4013 && num_nonzero_elements
> 0
4014 && VEC_length (constructor_elt
, elts
) > 1)
4016 tree temp
= create_tmp_var (TYPE_MAIN_VARIANT (type
), NULL
);
4017 TREE_OPERAND (*expr_p
, 0) = temp
;
4018 *expr_p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*expr_p
),
4020 build2 (MODIFY_EXPR
, void_type_node
,
4025 if (notify_temp_creation
)
4028 /* If there are nonzero elements and if needed, pre-evaluate to capture
4029 elements overlapping with the lhs into temporaries. We must do this
4030 before clearing to fetch the values before they are zeroed-out. */
4031 if (num_nonzero_elements
> 0 && TREE_CODE (*expr_p
) != INIT_EXPR
)
4033 preeval_data
.lhs_base_decl
= get_base_address (object
);
4034 if (!DECL_P (preeval_data
.lhs_base_decl
))
4035 preeval_data
.lhs_base_decl
= NULL
;
4036 preeval_data
.lhs_alias_set
= get_alias_set (object
);
4038 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p
, 1),
4039 pre_p
, post_p
, &preeval_data
);
4044 /* Zap the CONSTRUCTOR element list, which simplifies this case.
4045 Note that we still have to gimplify, in order to handle the
4046 case of variable sized types. Avoid shared tree structures. */
4047 CONSTRUCTOR_ELTS (ctor
) = NULL
;
4048 TREE_SIDE_EFFECTS (ctor
) = 0;
4049 object
= unshare_expr (object
);
4050 gimplify_stmt (expr_p
, pre_p
);
4053 /* If we have not block cleared the object, or if there are nonzero
4054 elements in the constructor, add assignments to the individual
4055 scalar fields of the object. */
4056 if (!cleared
|| num_nonzero_elements
> 0)
4057 gimplify_init_ctor_eval (object
, elts
, pre_p
, cleared
);
4059 *expr_p
= NULL_TREE
;
4067 if (notify_temp_creation
)
4070 /* Extract the real and imaginary parts out of the ctor. */
4071 gcc_assert (VEC_length (constructor_elt
, elts
) == 2);
4072 r
= VEC_index (constructor_elt
, elts
, 0)->value
;
4073 i
= VEC_index (constructor_elt
, elts
, 1)->value
;
4074 if (r
== NULL
|| i
== NULL
)
4076 tree zero
= build_zero_cst (TREE_TYPE (type
));
4083 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
4084 represent creation of a complex value. */
4085 if (TREE_CONSTANT (r
) && TREE_CONSTANT (i
))
4087 ctor
= build_complex (type
, r
, i
);
4088 TREE_OPERAND (*expr_p
, 1) = ctor
;
4092 ctor
= build2 (COMPLEX_EXPR
, type
, r
, i
);
4093 TREE_OPERAND (*expr_p
, 1) = ctor
;
4094 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1),
4097 rhs_predicate_for (TREE_OPERAND (*expr_p
, 0)),
4105 unsigned HOST_WIDE_INT ix
;
4106 constructor_elt
*ce
;
4108 if (notify_temp_creation
)
4111 /* Go ahead and simplify constant constructors to VECTOR_CST. */
4112 if (TREE_CONSTANT (ctor
))
4114 bool constant_p
= true;
4117 /* Even when ctor is constant, it might contain non-*_CST
4118 elements, such as addresses or trapping values like
4119 1.0/0.0 - 1.0/0.0. Such expressions don't belong
4120 in VECTOR_CST nodes. */
4121 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
4122 if (!CONSTANT_CLASS_P (value
))
4130 TREE_OPERAND (*expr_p
, 1) = build_vector_from_ctor (type
, elts
);
4134 /* Don't reduce an initializer constant even if we can't
4135 make a VECTOR_CST. It won't do anything for us, and it'll
4136 prevent us from representing it as a single constant. */
4137 if (initializer_constant_valid_p (ctor
, type
))
4140 TREE_CONSTANT (ctor
) = 0;
4143 /* Vector types use CONSTRUCTOR all the way through gimple
4144 compilation as a general initializer. */
4145 FOR_EACH_VEC_ELT (constructor_elt
, elts
, ix
, ce
)
4147 enum gimplify_status tret
;
4148 tret
= gimplify_expr (&ce
->value
, pre_p
, post_p
, is_gimple_val
,
4150 if (tret
== GS_ERROR
)
4153 if (!is_gimple_reg (TREE_OPERAND (*expr_p
, 0)))
4154 TREE_OPERAND (*expr_p
, 1) = get_formal_tmp_var (ctor
, pre_p
);
4159 /* So how did we get a CONSTRUCTOR for a scalar type? */
4163 if (ret
== GS_ERROR
)
4165 else if (want_value
)
4172 /* If we have gimplified both sides of the initializer but have
4173 not emitted an assignment, do so now. */
4176 tree lhs
= TREE_OPERAND (*expr_p
, 0);
4177 tree rhs
= TREE_OPERAND (*expr_p
, 1);
4178 gimple init
= gimple_build_assign (lhs
, rhs
);
4179 gimplify_seq_add_stmt (pre_p
, init
);
4187 /* Given a pointer value OP0, return a simplified version of an
4188 indirection through OP0, or NULL_TREE if no simplification is
4189 possible. Note that the resulting type may be different from
4190 the type pointed to in the sense that it is still compatible
4191 from the langhooks point of view. */
4194 gimple_fold_indirect_ref (tree t
)
4196 tree ptype
= TREE_TYPE (t
), type
= TREE_TYPE (ptype
);
4201 subtype
= TREE_TYPE (sub
);
4202 if (!POINTER_TYPE_P (subtype
))
4205 if (TREE_CODE (sub
) == ADDR_EXPR
)
4207 tree op
= TREE_OPERAND (sub
, 0);
4208 tree optype
= TREE_TYPE (op
);
4210 if (useless_type_conversion_p (type
, optype
))
4213 /* *(foo *)&fooarray => fooarray[0] */
4214 if (TREE_CODE (optype
) == ARRAY_TYPE
4215 && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype
))) == INTEGER_CST
4216 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4218 tree type_domain
= TYPE_DOMAIN (optype
);
4219 tree min_val
= size_zero_node
;
4220 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
4221 min_val
= TYPE_MIN_VALUE (type_domain
);
4222 if (TREE_CODE (min_val
) == INTEGER_CST
)
4223 return build4 (ARRAY_REF
, type
, op
, min_val
, NULL_TREE
, NULL_TREE
);
4225 /* *(foo *)&complexfoo => __real__ complexfoo */
4226 else if (TREE_CODE (optype
) == COMPLEX_TYPE
4227 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4228 return fold_build1 (REALPART_EXPR
, type
, op
);
4229 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
4230 else if (TREE_CODE (optype
) == VECTOR_TYPE
4231 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4233 tree part_width
= TYPE_SIZE (type
);
4234 tree index
= bitsize_int (0);
4235 return fold_build3 (BIT_FIELD_REF
, type
, op
, part_width
, index
);
4239 /* *(p + CST) -> ... */
4240 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
4241 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
4243 tree addr
= TREE_OPERAND (sub
, 0);
4244 tree off
= TREE_OPERAND (sub
, 1);
4248 addrtype
= TREE_TYPE (addr
);
4250 /* ((foo*)&vectorfoo)[1] -> BIT_FIELD_REF<vectorfoo,...> */
4251 if (TREE_CODE (addr
) == ADDR_EXPR
4252 && TREE_CODE (TREE_TYPE (addrtype
)) == VECTOR_TYPE
4253 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
)))
4254 && host_integerp (off
, 1))
4256 unsigned HOST_WIDE_INT offset
= tree_low_cst (off
, 1);
4257 tree part_width
= TYPE_SIZE (type
);
4258 unsigned HOST_WIDE_INT part_widthi
4259 = tree_low_cst (part_width
, 0) / BITS_PER_UNIT
;
4260 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
4261 tree index
= bitsize_int (indexi
);
4262 if (offset
/ part_widthi
4263 <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype
)))
4264 return fold_build3 (BIT_FIELD_REF
, type
, TREE_OPERAND (addr
, 0),
4268 /* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
4269 if (TREE_CODE (addr
) == ADDR_EXPR
4270 && TREE_CODE (TREE_TYPE (addrtype
)) == COMPLEX_TYPE
4271 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
))))
4273 tree size
= TYPE_SIZE_UNIT (type
);
4274 if (tree_int_cst_equal (size
, off
))
4275 return fold_build1 (IMAGPART_EXPR
, type
, TREE_OPERAND (addr
, 0));
4278 /* *(p + CST) -> MEM_REF <p, CST>. */
4279 if (TREE_CODE (addr
) != ADDR_EXPR
4280 || DECL_P (TREE_OPERAND (addr
, 0)))
4281 return fold_build2 (MEM_REF
, type
,
4283 build_int_cst_wide (ptype
,
4284 TREE_INT_CST_LOW (off
),
4285 TREE_INT_CST_HIGH (off
)));
4288 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
4289 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
4290 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (subtype
)))) == INTEGER_CST
4291 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (subtype
))))
4294 tree min_val
= size_zero_node
;
4296 sub
= gimple_fold_indirect_ref (sub
);
4298 sub
= build1 (INDIRECT_REF
, TREE_TYPE (subtype
), osub
);
4299 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
4300 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
4301 min_val
= TYPE_MIN_VALUE (type_domain
);
4302 if (TREE_CODE (min_val
) == INTEGER_CST
)
4303 return build4 (ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
, NULL_TREE
);
4309 /* Given a pointer value OP0, return a simplified version of an
4310 indirection through OP0, or NULL_TREE if no simplification is
4311 possible. This may only be applied to a rhs of an expression.
4312 Note that the resulting type may be different from the type pointed
4313 to in the sense that it is still compatible from the langhooks
4317 gimple_fold_indirect_ref_rhs (tree t
)
4319 return gimple_fold_indirect_ref (t
);
4322 /* Subroutine of gimplify_modify_expr to do simplifications of
4323 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4324 something changes. */
4326 static enum gimplify_status
4327 gimplify_modify_expr_rhs (tree
*expr_p
, tree
*from_p
, tree
*to_p
,
4328 gimple_seq
*pre_p
, gimple_seq
*post_p
,
4331 enum gimplify_status ret
= GS_UNHANDLED
;
4337 switch (TREE_CODE (*from_p
))
4340 /* If we're assigning from a read-only variable initialized with
4341 a constructor, do the direct assignment from the constructor,
4342 but only if neither source nor target are volatile since this
4343 latter assignment might end up being done on a per-field basis. */
4344 if (DECL_INITIAL (*from_p
)
4345 && TREE_READONLY (*from_p
)
4346 && !TREE_THIS_VOLATILE (*from_p
)
4347 && !TREE_THIS_VOLATILE (*to_p
)
4348 && TREE_CODE (DECL_INITIAL (*from_p
)) == CONSTRUCTOR
)
4350 tree old_from
= *from_p
;
4351 enum gimplify_status subret
;
4353 /* Move the constructor into the RHS. */
4354 *from_p
= unshare_expr (DECL_INITIAL (*from_p
));
4356 /* Let's see if gimplify_init_constructor will need to put
4358 subret
= gimplify_init_constructor (expr_p
, NULL
, NULL
,
4360 if (subret
== GS_ERROR
)
4362 /* If so, revert the change. */
4374 /* If we have code like
4378 where the type of "x" is a (possibly cv-qualified variant
4379 of "A"), treat the entire expression as identical to "x".
4380 This kind of code arises in C++ when an object is bound
4381 to a const reference, and if "x" is a TARGET_EXPR we want
4382 to take advantage of the optimization below. */
4383 bool volatile_p
= TREE_THIS_VOLATILE (*from_p
);
4384 tree t
= gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p
, 0));
4387 if (TREE_THIS_VOLATILE (t
) != volatile_p
)
4389 if (TREE_CODE_CLASS (TREE_CODE (t
)) == tcc_declaration
)
4390 t
= build_simple_mem_ref_loc (EXPR_LOCATION (*from_p
),
4391 build_fold_addr_expr (t
));
4392 if (REFERENCE_CLASS_P (t
))
4393 TREE_THIS_VOLATILE (t
) = volatile_p
;
4404 /* If we are initializing something from a TARGET_EXPR, strip the
4405 TARGET_EXPR and initialize it directly, if possible. This can't
4406 be done if the initializer is void, since that implies that the
4407 temporary is set in some non-trivial way.
4409 ??? What about code that pulls out the temp and uses it
4410 elsewhere? I think that such code never uses the TARGET_EXPR as
4411 an initializer. If I'm wrong, we'll die because the temp won't
4412 have any RTL. In that case, I guess we'll need to replace
4413 references somehow. */
4414 tree init
= TARGET_EXPR_INITIAL (*from_p
);
4417 && !VOID_TYPE_P (TREE_TYPE (init
)))
4427 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4429 gimplify_compound_expr (from_p
, pre_p
, true);
4435 /* If we already made some changes, let the front end have a
4436 crack at this before we break it down. */
4437 if (ret
!= GS_UNHANDLED
)
4439 /* If we're initializing from a CONSTRUCTOR, break this into
4440 individual MODIFY_EXPRs. */
4441 return gimplify_init_constructor (expr_p
, pre_p
, post_p
, want_value
,
4445 /* If we're assigning to a non-register type, push the assignment
4446 down into the branches. This is mandatory for ADDRESSABLE types,
4447 since we cannot generate temporaries for such, but it saves a
4448 copy in other cases as well. */
4449 if (!is_gimple_reg_type (TREE_TYPE (*from_p
)))
4451 /* This code should mirror the code in gimplify_cond_expr. */
4452 enum tree_code code
= TREE_CODE (*expr_p
);
4453 tree cond
= *from_p
;
4454 tree result
= *to_p
;
4456 ret
= gimplify_expr (&result
, pre_p
, post_p
,
4457 is_gimple_lvalue
, fb_lvalue
);
4458 if (ret
!= GS_ERROR
)
4461 if (TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
)
4462 TREE_OPERAND (cond
, 1)
4463 = build2 (code
, void_type_node
, result
,
4464 TREE_OPERAND (cond
, 1));
4465 if (TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
4466 TREE_OPERAND (cond
, 2)
4467 = build2 (code
, void_type_node
, unshare_expr (result
),
4468 TREE_OPERAND (cond
, 2));
4470 TREE_TYPE (cond
) = void_type_node
;
4471 recalculate_side_effects (cond
);
4475 gimplify_and_add (cond
, pre_p
);
4476 *expr_p
= unshare_expr (result
);
4485 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4486 return slot so that we don't generate a temporary. */
4487 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p
)
4488 && aggregate_value_p (*from_p
, *from_p
))
4492 if (!(rhs_predicate_for (*to_p
))(*from_p
))
4493 /* If we need a temporary, *to_p isn't accurate. */
4495 /* It's OK to use the return slot directly unless it's an NRV. */
4496 else if (TREE_CODE (*to_p
) == RESULT_DECL
4497 && DECL_NAME (*to_p
) == NULL_TREE
4498 && needs_to_live_in_memory (*to_p
))
4500 else if (is_gimple_reg_type (TREE_TYPE (*to_p
))
4501 || (DECL_P (*to_p
) && DECL_REGISTER (*to_p
)))
4502 /* Don't force regs into memory. */
4504 else if (TREE_CODE (*expr_p
) == INIT_EXPR
)
4505 /* It's OK to use the target directly if it's being
4508 else if (variably_modified_type_p (TREE_TYPE (*to_p
), NULL_TREE
))
4509 /* Always use the target and thus RSO for variable-sized types.
4510 GIMPLE cannot deal with a variable-sized assignment
4511 embedded in a call statement. */
4513 else if (TREE_CODE (*to_p
) != SSA_NAME
4514 && (!is_gimple_variable (*to_p
)
4515 || needs_to_live_in_memory (*to_p
)))
4516 /* Don't use the original target if it's already addressable;
4517 if its address escapes, and the called function uses the
4518 NRV optimization, a conforming program could see *to_p
4519 change before the called function returns; see c++/19317.
4520 When optimizing, the return_slot pass marks more functions
4521 as safe after we have escape info. */
4528 CALL_EXPR_RETURN_SLOT_OPT (*from_p
) = 1;
4529 mark_addressable (*to_p
);
4534 case WITH_SIZE_EXPR
:
4535 /* Likewise for calls that return an aggregate of non-constant size,
4536 since we would not be able to generate a temporary at all. */
4537 if (TREE_CODE (TREE_OPERAND (*from_p
, 0)) == CALL_EXPR
)
4539 *from_p
= TREE_OPERAND (*from_p
, 0);
4540 /* We don't change ret in this case because the
4541 WITH_SIZE_EXPR might have been added in
4542 gimplify_modify_expr, so returning GS_OK would lead to an
4548 /* If we're initializing from a container, push the initialization
4550 case CLEANUP_POINT_EXPR
:
4552 case STATEMENT_LIST
:
4554 tree wrap
= *from_p
;
4557 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_min_lval
,
4559 if (ret
!= GS_ERROR
)
4562 t
= voidify_wrapper_expr (wrap
, *expr_p
);
4563 gcc_assert (t
== *expr_p
);
4567 gimplify_and_add (wrap
, pre_p
);
4568 *expr_p
= unshare_expr (*to_p
);
4575 case COMPOUND_LITERAL_EXPR
:
4577 tree complit
= TREE_OPERAND (*expr_p
, 1);
4578 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (complit
);
4579 tree decl
= DECL_EXPR_DECL (decl_s
);
4580 tree init
= DECL_INITIAL (decl
);
4582 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4583 into struct T x = { 0, 1, 2 } if the address of the
4584 compound literal has never been taken. */
4585 if (!TREE_ADDRESSABLE (complit
)
4586 && !TREE_ADDRESSABLE (decl
)
4589 *expr_p
= copy_node (*expr_p
);
4590 TREE_OPERAND (*expr_p
, 1) = init
;
4605 /* Return true if T looks like a valid GIMPLE statement. */
4608 is_gimple_stmt (tree t
)
4610 const enum tree_code code
= TREE_CODE (t
);
4615 /* The only valid NOP_EXPR is the empty statement. */
4616 return IS_EMPTY_STMT (t
);
4620 /* These are only valid if they're void. */
4621 return TREE_TYPE (t
) == NULL
|| VOID_TYPE_P (TREE_TYPE (t
));
4627 case CASE_LABEL_EXPR
:
4628 case TRY_CATCH_EXPR
:
4629 case TRY_FINALLY_EXPR
:
4630 case EH_FILTER_EXPR
:
4633 case STATEMENT_LIST
:
4643 /* These are always void. */
4649 /* These are valid regardless of their type. */
4658 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4659 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4660 DECL_GIMPLE_REG_P set.
4662 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4663 other, unmodified part of the complex object just before the total store.
4664 As a consequence, if the object is still uninitialized, an undefined value
4665 will be loaded into a register, which may result in a spurious exception
4666 if the register is floating-point and the value happens to be a signaling
4667 NaN for example. Then the fully-fledged complex operations lowering pass
4668 followed by a DCE pass are necessary in order to fix things up. */
4670 static enum gimplify_status
4671 gimplify_modify_expr_complex_part (tree
*expr_p
, gimple_seq
*pre_p
,
4674 enum tree_code code
, ocode
;
4675 tree lhs
, rhs
, new_rhs
, other
, realpart
, imagpart
;
4677 lhs
= TREE_OPERAND (*expr_p
, 0);
4678 rhs
= TREE_OPERAND (*expr_p
, 1);
4679 code
= TREE_CODE (lhs
);
4680 lhs
= TREE_OPERAND (lhs
, 0);
4682 ocode
= code
== REALPART_EXPR
? IMAGPART_EXPR
: REALPART_EXPR
;
4683 other
= build1 (ocode
, TREE_TYPE (rhs
), lhs
);
4684 TREE_NO_WARNING (other
) = 1;
4685 other
= get_formal_tmp_var (other
, pre_p
);
4687 realpart
= code
== REALPART_EXPR
? rhs
: other
;
4688 imagpart
= code
== REALPART_EXPR
? other
: rhs
;
4690 if (TREE_CONSTANT (realpart
) && TREE_CONSTANT (imagpart
))
4691 new_rhs
= build_complex (TREE_TYPE (lhs
), realpart
, imagpart
);
4693 new_rhs
= build2 (COMPLEX_EXPR
, TREE_TYPE (lhs
), realpart
, imagpart
);
4695 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (lhs
, new_rhs
));
4696 *expr_p
= (want_value
) ? rhs
: NULL_TREE
;
4701 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4707 PRE_P points to the list where side effects that must happen before
4708 *EXPR_P should be stored.
4710 POST_P points to the list where side effects that must happen after
4711 *EXPR_P should be stored.
4713 WANT_VALUE is nonzero iff we want to use the value of this expression
4714 in another expression. */
4716 static enum gimplify_status
4717 gimplify_modify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4720 tree
*from_p
= &TREE_OPERAND (*expr_p
, 1);
4721 tree
*to_p
= &TREE_OPERAND (*expr_p
, 0);
4722 enum gimplify_status ret
= GS_UNHANDLED
;
4724 location_t loc
= EXPR_LOCATION (*expr_p
);
4726 gcc_assert (TREE_CODE (*expr_p
) == MODIFY_EXPR
4727 || TREE_CODE (*expr_p
) == INIT_EXPR
);
4729 /* Trying to simplify a clobber using normal logic doesn't work,
4730 so handle it here. */
4731 if (TREE_CLOBBER_P (*from_p
))
4733 gcc_assert (!want_value
&& TREE_CODE (*to_p
) == VAR_DECL
);
4734 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (*to_p
, *from_p
));
4739 /* Insert pointer conversions required by the middle-end that are not
4740 required by the frontend. This fixes middle-end type checking for
4741 for example gcc.dg/redecl-6.c. */
4742 if (POINTER_TYPE_P (TREE_TYPE (*to_p
)))
4744 STRIP_USELESS_TYPE_CONVERSION (*from_p
);
4745 if (!useless_type_conversion_p (TREE_TYPE (*to_p
), TREE_TYPE (*from_p
)))
4746 *from_p
= fold_convert_loc (loc
, TREE_TYPE (*to_p
), *from_p
);
4749 /* See if any simplifications can be done based on what the RHS is. */
4750 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4752 if (ret
!= GS_UNHANDLED
)
4755 /* For zero sized types only gimplify the left hand side and right hand
4756 side as statements and throw away the assignment. Do this after
4757 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4759 if (zero_sized_type (TREE_TYPE (*from_p
)) && !want_value
)
4761 gimplify_stmt (from_p
, pre_p
);
4762 gimplify_stmt (to_p
, pre_p
);
4763 *expr_p
= NULL_TREE
;
4767 /* If the value being copied is of variable width, compute the length
4768 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4769 before gimplifying any of the operands so that we can resolve any
4770 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4771 the size of the expression to be copied, not of the destination, so
4772 that is what we must do here. */
4773 maybe_with_size_expr (from_p
);
4775 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4776 if (ret
== GS_ERROR
)
4779 /* As a special case, we have to temporarily allow for assignments
4780 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4781 a toplevel statement, when gimplifying the GENERIC expression
4782 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4783 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4785 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4786 prevent gimplify_expr from trying to create a new temporary for
4787 foo's LHS, we tell it that it should only gimplify until it
4788 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4789 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4790 and all we need to do here is set 'a' to be its LHS. */
4791 ret
= gimplify_expr (from_p
, pre_p
, post_p
, rhs_predicate_for (*to_p
),
4793 if (ret
== GS_ERROR
)
4796 /* Now see if the above changed *from_p to something we handle specially. */
4797 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4799 if (ret
!= GS_UNHANDLED
)
4802 /* If we've got a variable sized assignment between two lvalues (i.e. does
4803 not involve a call), then we can make things a bit more straightforward
4804 by converting the assignment to memcpy or memset. */
4805 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
4807 tree from
= TREE_OPERAND (*from_p
, 0);
4808 tree size
= TREE_OPERAND (*from_p
, 1);
4810 if (TREE_CODE (from
) == CONSTRUCTOR
)
4811 return gimplify_modify_expr_to_memset (expr_p
, size
, want_value
, pre_p
);
4813 if (is_gimple_addressable (from
))
4816 return gimplify_modify_expr_to_memcpy (expr_p
, size
, want_value
,
4821 /* Transform partial stores to non-addressable complex variables into
4822 total stores. This allows us to use real instead of virtual operands
4823 for these variables, which improves optimization. */
4824 if ((TREE_CODE (*to_p
) == REALPART_EXPR
4825 || TREE_CODE (*to_p
) == IMAGPART_EXPR
)
4826 && is_gimple_reg (TREE_OPERAND (*to_p
, 0)))
4827 return gimplify_modify_expr_complex_part (expr_p
, pre_p
, want_value
);
4829 /* Try to alleviate the effects of the gimplification creating artificial
4830 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
4831 if (!gimplify_ctxp
->into_ssa
4832 && TREE_CODE (*from_p
) == VAR_DECL
4833 && DECL_IGNORED_P (*from_p
)
4835 && !DECL_IGNORED_P (*to_p
))
4837 if (!DECL_NAME (*from_p
) && DECL_NAME (*to_p
))
4839 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p
)));
4840 DECL_DEBUG_EXPR_IS_FROM (*from_p
) = 1;
4841 SET_DECL_DEBUG_EXPR (*from_p
, *to_p
);
4844 if (want_value
&& TREE_THIS_VOLATILE (*to_p
))
4845 *from_p
= get_initialized_tmp_var (*from_p
, pre_p
, post_p
);
4847 if (TREE_CODE (*from_p
) == CALL_EXPR
)
4849 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4850 instead of a GIMPLE_ASSIGN. */
4851 tree fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*from_p
));
4852 CALL_EXPR_FN (*from_p
) = TREE_OPERAND (CALL_EXPR_FN (*from_p
), 0);
4853 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p
));
4854 assign
= gimple_build_call_from_tree (*from_p
);
4855 gimple_call_set_fntype (assign
, TREE_TYPE (fnptrtype
));
4856 if (!gimple_call_noreturn_p (assign
))
4857 gimple_call_set_lhs (assign
, *to_p
);
4861 assign
= gimple_build_assign (*to_p
, *from_p
);
4862 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
4865 gimplify_seq_add_stmt (pre_p
, assign
);
4867 if (gimplify_ctxp
->into_ssa
&& is_gimple_reg (*to_p
))
4869 /* If we've somehow already got an SSA_NAME on the LHS, then
4870 we've probably modified it twice. Not good. */
4871 gcc_assert (TREE_CODE (*to_p
) != SSA_NAME
);
4872 *to_p
= make_ssa_name (*to_p
, assign
);
4873 gimple_set_lhs (assign
, *to_p
);
4878 *expr_p
= TREE_THIS_VOLATILE (*to_p
) ? *from_p
: unshare_expr (*to_p
);
4887 /* Gimplify a comparison between two variable-sized objects. Do this
4888 with a call to BUILT_IN_MEMCMP. */
4890 static enum gimplify_status
4891 gimplify_variable_sized_compare (tree
*expr_p
)
4893 location_t loc
= EXPR_LOCATION (*expr_p
);
4894 tree op0
= TREE_OPERAND (*expr_p
, 0);
4895 tree op1
= TREE_OPERAND (*expr_p
, 1);
4896 tree t
, arg
, dest
, src
, expr
;
4898 arg
= TYPE_SIZE_UNIT (TREE_TYPE (op0
));
4899 arg
= unshare_expr (arg
);
4900 arg
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg
, op0
);
4901 src
= build_fold_addr_expr_loc (loc
, op1
);
4902 dest
= build_fold_addr_expr_loc (loc
, op0
);
4903 t
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
4904 t
= build_call_expr_loc (loc
, t
, 3, dest
, src
, arg
);
4907 = build2 (TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), t
, integer_zero_node
);
4908 SET_EXPR_LOCATION (expr
, loc
);
4914 /* Gimplify a comparison between two aggregate objects of integral scalar
4915 mode as a comparison between the bitwise equivalent scalar values. */
4917 static enum gimplify_status
4918 gimplify_scalar_mode_aggregate_compare (tree
*expr_p
)
4920 location_t loc
= EXPR_LOCATION (*expr_p
);
4921 tree op0
= TREE_OPERAND (*expr_p
, 0);
4922 tree op1
= TREE_OPERAND (*expr_p
, 1);
4924 tree type
= TREE_TYPE (op0
);
4925 tree scalar_type
= lang_hooks
.types
.type_for_mode (TYPE_MODE (type
), 1);
4927 op0
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op0
);
4928 op1
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op1
);
4931 = fold_build2_loc (loc
, TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), op0
, op1
);
4936 /* Gimplify an expression sequence. This function gimplifies each
4937 expression and rewrites the original expression with the last
4938 expression of the sequence in GIMPLE form.
4940 PRE_P points to the list where the side effects for all the
4941 expressions in the sequence will be emitted.
4943 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
4945 static enum gimplify_status
4946 gimplify_compound_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
4952 tree
*sub_p
= &TREE_OPERAND (t
, 0);
4954 if (TREE_CODE (*sub_p
) == COMPOUND_EXPR
)
4955 gimplify_compound_expr (sub_p
, pre_p
, false);
4957 gimplify_stmt (sub_p
, pre_p
);
4959 t
= TREE_OPERAND (t
, 1);
4961 while (TREE_CODE (t
) == COMPOUND_EXPR
);
4968 gimplify_stmt (expr_p
, pre_p
);
4973 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
4974 gimplify. After gimplification, EXPR_P will point to a new temporary
4975 that holds the original value of the SAVE_EXPR node.
4977 PRE_P points to the list where side effects that must happen before
4978 *EXPR_P should be stored. */
4980 static enum gimplify_status
4981 gimplify_save_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
4983 enum gimplify_status ret
= GS_ALL_DONE
;
4986 gcc_assert (TREE_CODE (*expr_p
) == SAVE_EXPR
);
4987 val
= TREE_OPERAND (*expr_p
, 0);
4989 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
4990 if (!SAVE_EXPR_RESOLVED_P (*expr_p
))
4992 /* The operand may be a void-valued expression such as SAVE_EXPRs
4993 generated by the Java frontend for class initialization. It is
4994 being executed only for its side-effects. */
4995 if (TREE_TYPE (val
) == void_type_node
)
4997 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
4998 is_gimple_stmt
, fb_none
);
5002 val
= get_initialized_tmp_var (val
, pre_p
, post_p
);
5004 TREE_OPERAND (*expr_p
, 0) = val
;
5005 SAVE_EXPR_RESOLVED_P (*expr_p
) = 1;
5013 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
5020 PRE_P points to the list where side effects that must happen before
5021 *EXPR_P should be stored.
5023 POST_P points to the list where side effects that must happen after
5024 *EXPR_P should be stored. */
5026 static enum gimplify_status
5027 gimplify_addr_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5029 tree expr
= *expr_p
;
5030 tree op0
= TREE_OPERAND (expr
, 0);
5031 enum gimplify_status ret
;
5032 location_t loc
= EXPR_LOCATION (*expr_p
);
5034 switch (TREE_CODE (op0
))
5038 /* Check if we are dealing with an expression of the form '&*ptr'.
5039 While the front end folds away '&*ptr' into 'ptr', these
5040 expressions may be generated internally by the compiler (e.g.,
5041 builtins like __builtin_va_end). */
5042 /* Caution: the silent array decomposition semantics we allow for
5043 ADDR_EXPR means we can't always discard the pair. */
5044 /* Gimplification of the ADDR_EXPR operand may drop
5045 cv-qualification conversions, so make sure we add them if
5048 tree op00
= TREE_OPERAND (op0
, 0);
5049 tree t_expr
= TREE_TYPE (expr
);
5050 tree t_op00
= TREE_TYPE (op00
);
5052 if (!useless_type_conversion_p (t_expr
, t_op00
))
5053 op00
= fold_convert_loc (loc
, TREE_TYPE (expr
), op00
);
5059 case VIEW_CONVERT_EXPR
:
5060 /* Take the address of our operand and then convert it to the type of
5063 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
5064 all clear. The impact of this transformation is even less clear. */
5066 /* If the operand is a useless conversion, look through it. Doing so
5067 guarantees that the ADDR_EXPR and its operand will remain of the
5069 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0
, 0)))
5070 op0
= TREE_OPERAND (op0
, 0);
5072 *expr_p
= fold_convert_loc (loc
, TREE_TYPE (expr
),
5073 build_fold_addr_expr_loc (loc
,
5074 TREE_OPERAND (op0
, 0)));
5079 /* We use fb_either here because the C frontend sometimes takes
5080 the address of a call that returns a struct; see
5081 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
5082 the implied temporary explicit. */
5084 /* Make the operand addressable. */
5085 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, post_p
,
5086 is_gimple_addressable
, fb_either
);
5087 if (ret
== GS_ERROR
)
5090 /* Then mark it. Beware that it may not be possible to do so directly
5091 if a temporary has been created by the gimplification. */
5092 prepare_gimple_addressable (&TREE_OPERAND (expr
, 0), pre_p
);
5094 op0
= TREE_OPERAND (expr
, 0);
5096 /* For various reasons, the gimplification of the expression
5097 may have made a new INDIRECT_REF. */
5098 if (TREE_CODE (op0
) == INDIRECT_REF
)
5099 goto do_indirect_ref
;
5101 mark_addressable (TREE_OPERAND (expr
, 0));
5103 /* The FEs may end up building ADDR_EXPRs early on a decl with
5104 an incomplete type. Re-build ADDR_EXPRs in canonical form
5106 if (!types_compatible_p (TREE_TYPE (op0
), TREE_TYPE (TREE_TYPE (expr
))))
5107 *expr_p
= build_fold_addr_expr (op0
);
5109 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
5110 recompute_tree_invariant_for_addr_expr (*expr_p
);
5112 /* If we re-built the ADDR_EXPR add a conversion to the original type
5114 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
5115 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
5123 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
5124 value; output operands should be a gimple lvalue. */
5126 static enum gimplify_status
5127 gimplify_asm_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5131 const char **oconstraints
;
5134 const char *constraint
;
5135 bool allows_mem
, allows_reg
, is_inout
;
5136 enum gimplify_status ret
, tret
;
5138 VEC(tree
, gc
) *inputs
;
5139 VEC(tree
, gc
) *outputs
;
5140 VEC(tree
, gc
) *clobbers
;
5141 VEC(tree
, gc
) *labels
;
5145 noutputs
= list_length (ASM_OUTPUTS (expr
));
5146 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
5148 inputs
= outputs
= clobbers
= labels
= NULL
;
5151 link_next
= NULL_TREE
;
5152 for (i
= 0, link
= ASM_OUTPUTS (expr
); link
; ++i
, link
= link_next
)
5155 size_t constraint_len
;
5157 link_next
= TREE_CHAIN (link
);
5161 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5162 constraint_len
= strlen (constraint
);
5163 if (constraint_len
== 0)
5166 ok
= parse_output_constraint (&constraint
, i
, 0, 0,
5167 &allows_mem
, &allows_reg
, &is_inout
);
5174 if (!allows_reg
&& allows_mem
)
5175 mark_addressable (TREE_VALUE (link
));
5177 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5178 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
5179 fb_lvalue
| fb_mayfail
);
5180 if (tret
== GS_ERROR
)
5182 error ("invalid lvalue in asm output %d", i
);
5186 VEC_safe_push (tree
, gc
, outputs
, link
);
5187 TREE_CHAIN (link
) = NULL_TREE
;
5191 /* An input/output operand. To give the optimizers more
5192 flexibility, split it into separate input and output
5197 /* Turn the in/out constraint into an output constraint. */
5198 char *p
= xstrdup (constraint
);
5200 TREE_VALUE (TREE_PURPOSE (link
)) = build_string (constraint_len
, p
);
5202 /* And add a matching input constraint. */
5205 sprintf (buf
, "%d", i
);
5207 /* If there are multiple alternatives in the constraint,
5208 handle each of them individually. Those that allow register
5209 will be replaced with operand number, the others will stay
5211 if (strchr (p
, ',') != NULL
)
5213 size_t len
= 0, buflen
= strlen (buf
);
5214 char *beg
, *end
, *str
, *dst
;
5218 end
= strchr (beg
, ',');
5220 end
= strchr (beg
, '\0');
5221 if ((size_t) (end
- beg
) < buflen
)
5224 len
+= end
- beg
+ 1;
5231 str
= (char *) alloca (len
);
5232 for (beg
= p
+ 1, dst
= str
;;)
5235 bool mem_p
, reg_p
, inout_p
;
5237 end
= strchr (beg
, ',');
5242 parse_output_constraint (&tem
, i
, 0, 0,
5243 &mem_p
, ®_p
, &inout_p
);
5248 memcpy (dst
, buf
, buflen
);
5257 memcpy (dst
, beg
, len
);
5266 input
= build_string (dst
- str
, str
);
5269 input
= build_string (strlen (buf
), buf
);
5272 input
= build_string (constraint_len
- 1, constraint
+ 1);
5276 input
= build_tree_list (build_tree_list (NULL_TREE
, input
),
5277 unshare_expr (TREE_VALUE (link
)));
5278 ASM_INPUTS (expr
) = chainon (ASM_INPUTS (expr
), input
);
5282 link_next
= NULL_TREE
;
5283 for (link
= ASM_INPUTS (expr
); link
; ++i
, link
= link_next
)
5285 link_next
= TREE_CHAIN (link
);
5286 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5287 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
5288 oconstraints
, &allows_mem
, &allows_reg
);
5290 /* If we can't make copies, we can only accept memory. */
5291 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link
))))
5297 error ("impossible constraint in %<asm%>");
5298 error ("non-memory input %d must stay in memory", i
);
5303 /* If the operand is a memory input, it should be an lvalue. */
5304 if (!allows_reg
&& allows_mem
)
5306 tree inputv
= TREE_VALUE (link
);
5307 STRIP_NOPS (inputv
);
5308 if (TREE_CODE (inputv
) == PREDECREMENT_EXPR
5309 || TREE_CODE (inputv
) == PREINCREMENT_EXPR
5310 || TREE_CODE (inputv
) == POSTDECREMENT_EXPR
5311 || TREE_CODE (inputv
) == POSTINCREMENT_EXPR
)
5312 TREE_VALUE (link
) = error_mark_node
;
5313 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5314 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
5315 mark_addressable (TREE_VALUE (link
));
5316 if (tret
== GS_ERROR
)
5318 if (EXPR_HAS_LOCATION (TREE_VALUE (link
)))
5319 input_location
= EXPR_LOCATION (TREE_VALUE (link
));
5320 error ("memory input %d is not directly addressable", i
);
5326 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5327 is_gimple_asm_val
, fb_rvalue
);
5328 if (tret
== GS_ERROR
)
5332 TREE_CHAIN (link
) = NULL_TREE
;
5333 VEC_safe_push (tree
, gc
, inputs
, link
);
5336 for (link
= ASM_CLOBBERS (expr
); link
; ++i
, link
= TREE_CHAIN (link
))
5337 VEC_safe_push (tree
, gc
, clobbers
, link
);
5339 for (link
= ASM_LABELS (expr
); link
; ++i
, link
= TREE_CHAIN (link
))
5340 VEC_safe_push (tree
, gc
, labels
, link
);
5342 /* Do not add ASMs with errors to the gimple IL stream. */
5343 if (ret
!= GS_ERROR
)
5345 stmt
= gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr
)),
5346 inputs
, outputs
, clobbers
, labels
);
5348 gimple_asm_set_volatile (stmt
, ASM_VOLATILE_P (expr
));
5349 gimple_asm_set_input (stmt
, ASM_INPUT_P (expr
));
5351 gimplify_seq_add_stmt (pre_p
, stmt
);
5357 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
5358 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
5359 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
5360 return to this function.
5362 FIXME should we complexify the prequeue handling instead? Or use flags
5363 for all the cleanups and let the optimizer tighten them up? The current
5364 code seems pretty fragile; it will break on a cleanup within any
5365 non-conditional nesting. But any such nesting would be broken, anyway;
5366 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
5367 and continues out of it. We can do that at the RTL level, though, so
5368 having an optimizer to tighten up try/finally regions would be a Good
5371 static enum gimplify_status
5372 gimplify_cleanup_point_expr (tree
*expr_p
, gimple_seq
*pre_p
)
5374 gimple_stmt_iterator iter
;
5375 gimple_seq body_sequence
= NULL
;
5377 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
5379 /* We only care about the number of conditions between the innermost
5380 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5381 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5382 int old_conds
= gimplify_ctxp
->conditions
;
5383 gimple_seq old_cleanups
= gimplify_ctxp
->conditional_cleanups
;
5384 bool old_in_cleanup_point_expr
= gimplify_ctxp
->in_cleanup_point_expr
;
5385 gimplify_ctxp
->conditions
= 0;
5386 gimplify_ctxp
->conditional_cleanups
= NULL
;
5387 gimplify_ctxp
->in_cleanup_point_expr
= true;
5389 gimplify_stmt (&TREE_OPERAND (*expr_p
, 0), &body_sequence
);
5391 gimplify_ctxp
->conditions
= old_conds
;
5392 gimplify_ctxp
->conditional_cleanups
= old_cleanups
;
5393 gimplify_ctxp
->in_cleanup_point_expr
= old_in_cleanup_point_expr
;
5395 for (iter
= gsi_start (body_sequence
); !gsi_end_p (iter
); )
5397 gimple wce
= gsi_stmt (iter
);
5399 if (gimple_code (wce
) == GIMPLE_WITH_CLEANUP_EXPR
)
5401 if (gsi_one_before_end_p (iter
))
5403 /* Note that gsi_insert_seq_before and gsi_remove do not
5404 scan operands, unlike some other sequence mutators. */
5405 if (!gimple_wce_cleanup_eh_only (wce
))
5406 gsi_insert_seq_before_without_update (&iter
,
5407 gimple_wce_cleanup (wce
),
5409 gsi_remove (&iter
, true);
5416 enum gimple_try_flags kind
;
5418 if (gimple_wce_cleanup_eh_only (wce
))
5419 kind
= GIMPLE_TRY_CATCH
;
5421 kind
= GIMPLE_TRY_FINALLY
;
5422 seq
= gsi_split_seq_after (iter
);
5424 gtry
= gimple_build_try (seq
, gimple_wce_cleanup (wce
), kind
);
5425 /* Do not use gsi_replace here, as it may scan operands.
5426 We want to do a simple structural modification only. */
5427 *gsi_stmt_ptr (&iter
) = gtry
;
5428 iter
= gsi_start (seq
);
5435 gimplify_seq_add_seq (pre_p
, body_sequence
);
5448 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5449 is the cleanup action required. EH_ONLY is true if the cleanup should
5450 only be executed if an exception is thrown, not on normal exit. */
5453 gimple_push_cleanup (tree var
, tree cleanup
, bool eh_only
, gimple_seq
*pre_p
)
5456 gimple_seq cleanup_stmts
= NULL
;
5458 /* Errors can result in improperly nested cleanups. Which results in
5459 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5463 if (gimple_conditional_context ())
5465 /* If we're in a conditional context, this is more complex. We only
5466 want to run the cleanup if we actually ran the initialization that
5467 necessitates it, but we want to run it after the end of the
5468 conditional context. So we wrap the try/finally around the
5469 condition and use a flag to determine whether or not to actually
5470 run the destructor. Thus
5474 becomes (approximately)
5478 if (test) { A::A(temp); flag = 1; val = f(temp); }
5481 if (flag) A::~A(temp);
5485 tree flag
= create_tmp_var (boolean_type_node
, "cleanup");
5486 gimple ffalse
= gimple_build_assign (flag
, boolean_false_node
);
5487 gimple ftrue
= gimple_build_assign (flag
, boolean_true_node
);
5489 cleanup
= build3 (COND_EXPR
, void_type_node
, flag
, cleanup
, NULL
);
5490 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5491 wce
= gimple_build_wce (cleanup_stmts
);
5493 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, ffalse
);
5494 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
5495 gimplify_seq_add_stmt (pre_p
, ftrue
);
5497 /* Because of this manipulation, and the EH edges that jump
5498 threading cannot redirect, the temporary (VAR) will appear
5499 to be used uninitialized. Don't warn. */
5500 TREE_NO_WARNING (var
) = 1;
5504 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5505 wce
= gimple_build_wce (cleanup_stmts
);
5506 gimple_wce_set_cleanup_eh_only (wce
, eh_only
);
5507 gimplify_seq_add_stmt (pre_p
, wce
);
5511 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5513 static enum gimplify_status
5514 gimplify_target_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5516 tree targ
= *expr_p
;
5517 tree temp
= TARGET_EXPR_SLOT (targ
);
5518 tree init
= TARGET_EXPR_INITIAL (targ
);
5519 enum gimplify_status ret
;
5523 tree cleanup
= NULL_TREE
;
5525 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5526 to the temps list. Handle also variable length TARGET_EXPRs. */
5527 if (TREE_CODE (DECL_SIZE (temp
)) != INTEGER_CST
)
5529 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp
)))
5530 gimplify_type_sizes (TREE_TYPE (temp
), pre_p
);
5531 gimplify_vla_decl (temp
, pre_p
);
5534 gimple_add_tmp_var (temp
);
5536 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5537 expression is supposed to initialize the slot. */
5538 if (VOID_TYPE_P (TREE_TYPE (init
)))
5539 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5542 tree init_expr
= build2 (INIT_EXPR
, void_type_node
, temp
, init
);
5544 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5546 ggc_free (init_expr
);
5548 if (ret
== GS_ERROR
)
5550 /* PR c++/28266 Make sure this is expanded only once. */
5551 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5555 gimplify_and_add (init
, pre_p
);
5557 /* If needed, push the cleanup for the temp. */
5558 if (TARGET_EXPR_CLEANUP (targ
))
5560 if (CLEANUP_EH_ONLY (targ
))
5561 gimple_push_cleanup (temp
, TARGET_EXPR_CLEANUP (targ
),
5562 CLEANUP_EH_ONLY (targ
), pre_p
);
5564 cleanup
= TARGET_EXPR_CLEANUP (targ
);
5567 /* Add a clobber for the temporary going out of scope, like
5568 gimplify_bind_expr. */
5569 if (gimplify_ctxp
->in_cleanup_point_expr
5570 && needs_to_live_in_memory (temp
))
5572 tree clobber
= build_constructor (TREE_TYPE (temp
), NULL
);
5573 TREE_THIS_VOLATILE (clobber
) = true;
5574 clobber
= build2 (MODIFY_EXPR
, TREE_TYPE (temp
), temp
, clobber
);
5576 cleanup
= build2 (COMPOUND_EXPR
, void_type_node
, cleanup
,
5583 gimple_push_cleanup (temp
, cleanup
, false, pre_p
);
5585 /* Only expand this once. */
5586 TREE_OPERAND (targ
, 3) = init
;
5587 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5590 /* We should have expanded this before. */
5591 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp
));
5597 /* Gimplification of expression trees. */
5599 /* Gimplify an expression which appears at statement context. The
5600 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5601 NULL, a new sequence is allocated.
5603 Return true if we actually added a statement to the queue. */
5606 gimplify_stmt (tree
*stmt_p
, gimple_seq
*seq_p
)
5608 gimple_seq_node last
;
5611 *seq_p
= gimple_seq_alloc ();
5613 last
= gimple_seq_last (*seq_p
);
5614 gimplify_expr (stmt_p
, seq_p
, NULL
, is_gimple_stmt
, fb_none
);
5615 return last
!= gimple_seq_last (*seq_p
);
5618 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5619 to CTX. If entries already exist, force them to be some flavor of private.
5620 If there is no enclosing parallel, do nothing. */
5623 omp_firstprivatize_variable (struct gimplify_omp_ctx
*ctx
, tree decl
)
5627 if (decl
== NULL
|| !DECL_P (decl
))
5632 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5635 if (n
->value
& GOVD_SHARED
)
5636 n
->value
= GOVD_FIRSTPRIVATE
| (n
->value
& GOVD_SEEN
);
5640 else if (ctx
->region_type
!= ORT_WORKSHARE
)
5641 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
5643 ctx
= ctx
->outer_context
;
5648 /* Similarly for each of the type sizes of TYPE. */
5651 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx
*ctx
, tree type
)
5653 if (type
== NULL
|| type
== error_mark_node
)
5655 type
= TYPE_MAIN_VARIANT (type
);
5657 if (pointer_set_insert (ctx
->privatized_types
, type
))
5660 switch (TREE_CODE (type
))
5666 case FIXED_POINT_TYPE
:
5667 omp_firstprivatize_variable (ctx
, TYPE_MIN_VALUE (type
));
5668 omp_firstprivatize_variable (ctx
, TYPE_MAX_VALUE (type
));
5672 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5673 omp_firstprivatize_type_sizes (ctx
, TYPE_DOMAIN (type
));
5678 case QUAL_UNION_TYPE
:
5681 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
5682 if (TREE_CODE (field
) == FIELD_DECL
)
5684 omp_firstprivatize_variable (ctx
, DECL_FIELD_OFFSET (field
));
5685 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (field
));
5691 case REFERENCE_TYPE
:
5692 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5699 omp_firstprivatize_variable (ctx
, TYPE_SIZE (type
));
5700 omp_firstprivatize_variable (ctx
, TYPE_SIZE_UNIT (type
));
5701 lang_hooks
.types
.omp_firstprivatize_type_sizes (ctx
, type
);
5704 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
5707 omp_add_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned int flags
)
5710 unsigned int nflags
;
5713 if (error_operand_p (decl
))
5716 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5717 there are constructors involved somewhere. */
5718 if (TREE_ADDRESSABLE (TREE_TYPE (decl
))
5719 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
5722 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5725 /* We shouldn't be re-adding the decl with the same data
5727 gcc_assert ((n
->value
& GOVD_DATA_SHARE_CLASS
& flags
) == 0);
5728 /* The only combination of data sharing classes we should see is
5729 FIRSTPRIVATE and LASTPRIVATE. */
5730 nflags
= n
->value
| flags
;
5731 gcc_assert ((nflags
& GOVD_DATA_SHARE_CLASS
)
5732 == (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
));
5737 /* When adding a variable-sized variable, we have to handle all sorts
5738 of additional bits of data: the pointer replacement variable, and
5739 the parameters of the type. */
5740 if (DECL_SIZE (decl
) && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5742 /* Add the pointer replacement variable as PRIVATE if the variable
5743 replacement is private, else FIRSTPRIVATE since we'll need the
5744 address of the original variable either for SHARED, or for the
5745 copy into or out of the context. */
5746 if (!(flags
& GOVD_LOCAL
))
5748 nflags
= flags
& GOVD_PRIVATE
? GOVD_PRIVATE
: GOVD_FIRSTPRIVATE
;
5749 nflags
|= flags
& GOVD_SEEN
;
5750 t
= DECL_VALUE_EXPR (decl
);
5751 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5752 t
= TREE_OPERAND (t
, 0);
5753 gcc_assert (DECL_P (t
));
5754 omp_add_variable (ctx
, t
, nflags
);
5757 /* Add all of the variable and type parameters (which should have
5758 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5759 omp_firstprivatize_variable (ctx
, DECL_SIZE_UNIT (decl
));
5760 omp_firstprivatize_variable (ctx
, DECL_SIZE (decl
));
5761 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5763 /* The variable-sized variable itself is never SHARED, only some form
5764 of PRIVATE. The sharing would take place via the pointer variable
5765 which we remapped above. */
5766 if (flags
& GOVD_SHARED
)
5767 flags
= GOVD_PRIVATE
| GOVD_DEBUG_PRIVATE
5768 | (flags
& (GOVD_SEEN
| GOVD_EXPLICIT
));
5770 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5771 alloca statement we generate for the variable, so make sure it
5772 is available. This isn't automatically needed for the SHARED
5773 case, since we won't be allocating local storage then.
5774 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5775 in this case omp_notice_variable will be called later
5776 on when it is gimplified. */
5777 else if (! (flags
& GOVD_LOCAL
)
5778 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl
))))
5779 omp_notice_variable (ctx
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)), true);
5781 else if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
5783 gcc_assert ((flags
& GOVD_LOCAL
) == 0);
5784 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5786 /* Similar to the direct variable sized case above, we'll need the
5787 size of references being privatized. */
5788 if ((flags
& GOVD_SHARED
) == 0)
5790 t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
5791 if (TREE_CODE (t
) != INTEGER_CST
)
5792 omp_notice_variable (ctx
, t
, true);
5796 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, flags
);
5799 /* Notice a threadprivate variable DECL used in OpenMP context CTX.
5800 This just prints out diagnostics about threadprivate variable uses
5801 in untied tasks. If DECL2 is non-NULL, prevent this warning
5802 on that variable. */
5805 omp_notice_threadprivate_variable (struct gimplify_omp_ctx
*ctx
, tree decl
,
5810 if (ctx
->region_type
!= ORT_UNTIED_TASK
)
5812 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5815 error ("threadprivate variable %qE used in untied task",
5817 error_at (ctx
->location
, "enclosing task");
5818 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, 0);
5821 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl2
, 0);
5825 /* Record the fact that DECL was used within the OpenMP context CTX.
5826 IN_CODE is true when real code uses DECL, and false when we should
5827 merely emit default(none) errors. Return true if DECL is going to
5828 be remapped and thus DECL shouldn't be gimplified into its
5829 DECL_VALUE_EXPR (if any). */
5832 omp_notice_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, bool in_code
)
5835 unsigned flags
= in_code
? GOVD_SEEN
: 0;
5836 bool ret
= false, shared
;
5838 if (error_operand_p (decl
))
5841 /* Threadprivate variables are predetermined. */
5842 if (is_global_var (decl
))
5844 if (DECL_THREAD_LOCAL_P (decl
))
5845 return omp_notice_threadprivate_variable (ctx
, decl
, NULL_TREE
);
5847 if (DECL_HAS_VALUE_EXPR_P (decl
))
5849 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
5851 if (value
&& DECL_P (value
) && DECL_THREAD_LOCAL_P (value
))
5852 return omp_notice_threadprivate_variable (ctx
, decl
, value
);
5856 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5859 enum omp_clause_default_kind default_kind
, kind
;
5860 struct gimplify_omp_ctx
*octx
;
5862 if (ctx
->region_type
== ORT_WORKSHARE
)
5865 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
5866 remapped firstprivate instead of shared. To some extent this is
5867 addressed in omp_firstprivatize_type_sizes, but not effectively. */
5868 default_kind
= ctx
->default_kind
;
5869 kind
= lang_hooks
.decls
.omp_predetermined_sharing (decl
);
5870 if (kind
!= OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
5871 default_kind
= kind
;
5873 switch (default_kind
)
5875 case OMP_CLAUSE_DEFAULT_NONE
:
5876 error ("%qE not specified in enclosing parallel",
5877 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5878 if ((ctx
->region_type
& ORT_TASK
) != 0)
5879 error_at (ctx
->location
, "enclosing task");
5881 error_at (ctx
->location
, "enclosing parallel");
5883 case OMP_CLAUSE_DEFAULT_SHARED
:
5884 flags
|= GOVD_SHARED
;
5886 case OMP_CLAUSE_DEFAULT_PRIVATE
:
5887 flags
|= GOVD_PRIVATE
;
5889 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
5890 flags
|= GOVD_FIRSTPRIVATE
;
5892 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
5893 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
5894 gcc_assert ((ctx
->region_type
& ORT_TASK
) != 0);
5895 if (ctx
->outer_context
)
5896 omp_notice_variable (ctx
->outer_context
, decl
, in_code
);
5897 for (octx
= ctx
->outer_context
; octx
; octx
= octx
->outer_context
)
5901 n2
= splay_tree_lookup (octx
->variables
, (splay_tree_key
) decl
);
5902 if (n2
&& (n2
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
)
5904 flags
|= GOVD_FIRSTPRIVATE
;
5907 if ((octx
->region_type
& ORT_PARALLEL
) != 0)
5910 if (flags
& GOVD_FIRSTPRIVATE
)
5913 && (TREE_CODE (decl
) == PARM_DECL
5914 || (!is_global_var (decl
)
5915 && DECL_CONTEXT (decl
) == current_function_decl
)))
5917 flags
|= GOVD_FIRSTPRIVATE
;
5920 flags
|= GOVD_SHARED
;
5926 if ((flags
& GOVD_PRIVATE
)
5927 && lang_hooks
.decls
.omp_private_outer_ref (decl
))
5928 flags
|= GOVD_PRIVATE_OUTER_REF
;
5930 omp_add_variable (ctx
, decl
, flags
);
5932 shared
= (flags
& GOVD_SHARED
) != 0;
5933 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
5937 if ((n
->value
& (GOVD_SEEN
| GOVD_LOCAL
)) == 0
5938 && (flags
& (GOVD_SEEN
| GOVD_LOCAL
)) == GOVD_SEEN
5940 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5943 tree t
= DECL_VALUE_EXPR (decl
);
5944 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5945 t
= TREE_OPERAND (t
, 0);
5946 gcc_assert (DECL_P (t
));
5947 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
5948 n2
->value
|= GOVD_SEEN
;
5951 shared
= ((flags
| n
->value
) & GOVD_SHARED
) != 0;
5952 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
5954 /* If nothing changed, there's nothing left to do. */
5955 if ((n
->value
& flags
) == flags
)
5961 /* If the variable is private in the current context, then we don't
5962 need to propagate anything to an outer context. */
5963 if ((flags
& GOVD_PRIVATE
) && !(flags
& GOVD_PRIVATE_OUTER_REF
))
5965 if (ctx
->outer_context
5966 && omp_notice_variable (ctx
->outer_context
, decl
, in_code
))
5971 /* Verify that DECL is private within CTX. If there's specific information
5972 to the contrary in the innermost scope, generate an error. */
5975 omp_is_private (struct gimplify_omp_ctx
*ctx
, tree decl
)
5979 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5982 if (n
->value
& GOVD_SHARED
)
5984 if (ctx
== gimplify_omp_ctxp
)
5986 error ("iteration variable %qE should be private",
5988 n
->value
= GOVD_PRIVATE
;
5994 else if ((n
->value
& GOVD_EXPLICIT
) != 0
5995 && (ctx
== gimplify_omp_ctxp
5996 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
5997 && gimplify_omp_ctxp
->outer_context
== ctx
)))
5999 if ((n
->value
& GOVD_FIRSTPRIVATE
) != 0)
6000 error ("iteration variable %qE should not be firstprivate",
6002 else if ((n
->value
& GOVD_REDUCTION
) != 0)
6003 error ("iteration variable %qE should not be reduction",
6006 return (ctx
== gimplify_omp_ctxp
6007 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6008 && gimplify_omp_ctxp
->outer_context
== ctx
));
6011 if (ctx
->region_type
!= ORT_WORKSHARE
)
6013 else if (ctx
->outer_context
)
6014 return omp_is_private (ctx
->outer_context
, decl
);
6018 /* Return true if DECL is private within a parallel region
6019 that binds to the current construct's context or in parallel
6020 region's REDUCTION clause. */
6023 omp_check_private (struct gimplify_omp_ctx
*ctx
, tree decl
)
6029 ctx
= ctx
->outer_context
;
6031 return !(is_global_var (decl
)
6032 /* References might be private, but might be shared too. */
6033 || lang_hooks
.decls
.omp_privatize_by_reference (decl
));
6035 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6037 return (n
->value
& GOVD_SHARED
) == 0;
6039 while (ctx
->region_type
== ORT_WORKSHARE
);
6043 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
6044 and previous omp contexts. */
6047 gimplify_scan_omp_clauses (tree
*list_p
, gimple_seq
*pre_p
,
6048 enum omp_region_type region_type
)
6050 struct gimplify_omp_ctx
*ctx
, *outer_ctx
;
6051 struct gimplify_ctx gctx
;
6054 ctx
= new_omp_context (region_type
);
6055 outer_ctx
= ctx
->outer_context
;
6057 while ((c
= *list_p
) != NULL
)
6059 bool remove
= false;
6060 bool notice_outer
= true;
6061 const char *check_non_private
= NULL
;
6065 switch (OMP_CLAUSE_CODE (c
))
6067 case OMP_CLAUSE_PRIVATE
:
6068 flags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
6069 if (lang_hooks
.decls
.omp_private_outer_ref (OMP_CLAUSE_DECL (c
)))
6071 flags
|= GOVD_PRIVATE_OUTER_REF
;
6072 OMP_CLAUSE_PRIVATE_OUTER_REF (c
) = 1;
6075 notice_outer
= false;
6077 case OMP_CLAUSE_SHARED
:
6078 flags
= GOVD_SHARED
| GOVD_EXPLICIT
;
6080 case OMP_CLAUSE_FIRSTPRIVATE
:
6081 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
6082 check_non_private
= "firstprivate";
6084 case OMP_CLAUSE_LASTPRIVATE
:
6085 flags
= GOVD_LASTPRIVATE
| GOVD_SEEN
| GOVD_EXPLICIT
;
6086 check_non_private
= "lastprivate";
6088 case OMP_CLAUSE_REDUCTION
:
6089 flags
= GOVD_REDUCTION
| GOVD_SEEN
| GOVD_EXPLICIT
;
6090 check_non_private
= "reduction";
6094 decl
= OMP_CLAUSE_DECL (c
);
6095 if (error_operand_p (decl
))
6100 omp_add_variable (ctx
, decl
, flags
);
6101 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
6102 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
6104 omp_add_variable (ctx
, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
),
6105 GOVD_LOCAL
| GOVD_SEEN
);
6106 gimplify_omp_ctxp
= ctx
;
6107 push_gimplify_context (&gctx
);
6109 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = gimple_seq_alloc ();
6110 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = gimple_seq_alloc ();
6112 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c
),
6113 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
6114 pop_gimplify_context
6115 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
)));
6116 push_gimplify_context (&gctx
);
6117 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c
),
6118 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
6119 pop_gimplify_context
6120 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
)));
6121 OMP_CLAUSE_REDUCTION_INIT (c
) = NULL_TREE
;
6122 OMP_CLAUSE_REDUCTION_MERGE (c
) = NULL_TREE
;
6124 gimplify_omp_ctxp
= outer_ctx
;
6126 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6127 && OMP_CLAUSE_LASTPRIVATE_STMT (c
))
6129 gimplify_omp_ctxp
= ctx
;
6130 push_gimplify_context (&gctx
);
6131 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c
)) != BIND_EXPR
)
6133 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
6135 TREE_SIDE_EFFECTS (bind
) = 1;
6136 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LASTPRIVATE_STMT (c
);
6137 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = bind
;
6139 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c
),
6140 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6141 pop_gimplify_context
6142 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
)));
6143 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = NULL_TREE
;
6145 gimplify_omp_ctxp
= outer_ctx
;
6151 case OMP_CLAUSE_COPYIN
:
6152 case OMP_CLAUSE_COPYPRIVATE
:
6153 decl
= OMP_CLAUSE_DECL (c
);
6154 if (error_operand_p (decl
))
6161 omp_notice_variable (outer_ctx
, decl
, true);
6162 if (check_non_private
6163 && region_type
== ORT_WORKSHARE
6164 && omp_check_private (ctx
, decl
))
6166 error ("%s variable %qE is private in outer context",
6167 check_non_private
, DECL_NAME (decl
));
6172 case OMP_CLAUSE_FINAL
:
6174 OMP_CLAUSE_OPERAND (c
, 0)
6175 = gimple_boolify (OMP_CLAUSE_OPERAND (c
, 0));
6178 case OMP_CLAUSE_SCHEDULE
:
6179 case OMP_CLAUSE_NUM_THREADS
:
6180 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
6181 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6185 case OMP_CLAUSE_NOWAIT
:
6186 case OMP_CLAUSE_ORDERED
:
6187 case OMP_CLAUSE_UNTIED
:
6188 case OMP_CLAUSE_COLLAPSE
:
6189 case OMP_CLAUSE_MERGEABLE
:
6192 case OMP_CLAUSE_DEFAULT
:
6193 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
6201 *list_p
= OMP_CLAUSE_CHAIN (c
);
6203 list_p
= &OMP_CLAUSE_CHAIN (c
);
6206 gimplify_omp_ctxp
= ctx
;
6209 /* For all variables that were not actually used within the context,
6210 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
6213 gimplify_adjust_omp_clauses_1 (splay_tree_node n
, void *data
)
6215 tree
*list_p
= (tree
*) data
;
6216 tree decl
= (tree
) n
->key
;
6217 unsigned flags
= n
->value
;
6218 enum omp_clause_code code
;
6222 if (flags
& (GOVD_EXPLICIT
| GOVD_LOCAL
))
6224 if ((flags
& GOVD_SEEN
) == 0)
6226 if (flags
& GOVD_DEBUG_PRIVATE
)
6228 gcc_assert ((flags
& GOVD_DATA_SHARE_CLASS
) == GOVD_PRIVATE
);
6229 private_debug
= true;
6233 = lang_hooks
.decls
.omp_private_debug_clause (decl
,
6234 !!(flags
& GOVD_SHARED
));
6236 code
= OMP_CLAUSE_PRIVATE
;
6237 else if (flags
& GOVD_SHARED
)
6239 if (is_global_var (decl
))
6241 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
6245 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6246 if (on
&& (on
->value
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
6247 | GOVD_PRIVATE
| GOVD_REDUCTION
)) != 0)
6249 ctx
= ctx
->outer_context
;
6254 code
= OMP_CLAUSE_SHARED
;
6256 else if (flags
& GOVD_PRIVATE
)
6257 code
= OMP_CLAUSE_PRIVATE
;
6258 else if (flags
& GOVD_FIRSTPRIVATE
)
6259 code
= OMP_CLAUSE_FIRSTPRIVATE
;
6263 clause
= build_omp_clause (input_location
, code
);
6264 OMP_CLAUSE_DECL (clause
) = decl
;
6265 OMP_CLAUSE_CHAIN (clause
) = *list_p
;
6267 OMP_CLAUSE_PRIVATE_DEBUG (clause
) = 1;
6268 else if (code
== OMP_CLAUSE_PRIVATE
&& (flags
& GOVD_PRIVATE_OUTER_REF
))
6269 OMP_CLAUSE_PRIVATE_OUTER_REF (clause
) = 1;
6271 lang_hooks
.decls
.omp_finish_clause (clause
);
6277 gimplify_adjust_omp_clauses (tree
*list_p
)
6279 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6282 while ((c
= *list_p
) != NULL
)
6285 bool remove
= false;
6287 switch (OMP_CLAUSE_CODE (c
))
6289 case OMP_CLAUSE_PRIVATE
:
6290 case OMP_CLAUSE_SHARED
:
6291 case OMP_CLAUSE_FIRSTPRIVATE
:
6292 decl
= OMP_CLAUSE_DECL (c
);
6293 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6294 remove
= !(n
->value
& GOVD_SEEN
);
6297 bool shared
= OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
;
6298 if ((n
->value
& GOVD_DEBUG_PRIVATE
)
6299 || lang_hooks
.decls
.omp_private_debug_clause (decl
, shared
))
6301 gcc_assert ((n
->value
& GOVD_DEBUG_PRIVATE
) == 0
6302 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
6304 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_PRIVATE
);
6305 OMP_CLAUSE_PRIVATE_DEBUG (c
) = 1;
6310 case OMP_CLAUSE_LASTPRIVATE
:
6311 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
6312 accurately reflect the presence of a FIRSTPRIVATE clause. */
6313 decl
= OMP_CLAUSE_DECL (c
);
6314 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6315 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
6316 = (n
->value
& GOVD_FIRSTPRIVATE
) != 0;
6319 case OMP_CLAUSE_REDUCTION
:
6320 case OMP_CLAUSE_COPYIN
:
6321 case OMP_CLAUSE_COPYPRIVATE
:
6323 case OMP_CLAUSE_NUM_THREADS
:
6324 case OMP_CLAUSE_SCHEDULE
:
6325 case OMP_CLAUSE_NOWAIT
:
6326 case OMP_CLAUSE_ORDERED
:
6327 case OMP_CLAUSE_DEFAULT
:
6328 case OMP_CLAUSE_UNTIED
:
6329 case OMP_CLAUSE_COLLAPSE
:
6330 case OMP_CLAUSE_FINAL
:
6331 case OMP_CLAUSE_MERGEABLE
:
6339 *list_p
= OMP_CLAUSE_CHAIN (c
);
6341 list_p
= &OMP_CLAUSE_CHAIN (c
);
6344 /* Add in any implicit data sharing. */
6345 splay_tree_foreach (ctx
->variables
, gimplify_adjust_omp_clauses_1
, list_p
);
6347 gimplify_omp_ctxp
= ctx
->outer_context
;
6348 delete_omp_context (ctx
);
6351 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
6352 gimplification of the body, as well as scanning the body for used
6353 variables. We need to do this scan now, because variable-sized
6354 decls will be decomposed during gimplification. */
6357 gimplify_omp_parallel (tree
*expr_p
, gimple_seq
*pre_p
)
6359 tree expr
= *expr_p
;
6361 gimple_seq body
= NULL
;
6362 struct gimplify_ctx gctx
;
6364 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
), pre_p
,
6365 OMP_PARALLEL_COMBINED (expr
)
6366 ? ORT_COMBINED_PARALLEL
6369 push_gimplify_context (&gctx
);
6371 g
= gimplify_and_return_first (OMP_PARALLEL_BODY (expr
), &body
);
6372 if (gimple_code (g
) == GIMPLE_BIND
)
6373 pop_gimplify_context (g
);
6375 pop_gimplify_context (NULL
);
6377 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
));
6379 g
= gimple_build_omp_parallel (body
,
6380 OMP_PARALLEL_CLAUSES (expr
),
6381 NULL_TREE
, NULL_TREE
);
6382 if (OMP_PARALLEL_COMBINED (expr
))
6383 gimple_omp_set_subcode (g
, GF_OMP_PARALLEL_COMBINED
);
6384 gimplify_seq_add_stmt (pre_p
, g
);
6385 *expr_p
= NULL_TREE
;
6388 /* Gimplify the contents of an OMP_TASK statement. This involves
6389 gimplification of the body, as well as scanning the body for used
6390 variables. We need to do this scan now, because variable-sized
6391 decls will be decomposed during gimplification. */
6394 gimplify_omp_task (tree
*expr_p
, gimple_seq
*pre_p
)
6396 tree expr
= *expr_p
;
6398 gimple_seq body
= NULL
;
6399 struct gimplify_ctx gctx
;
6401 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr
), pre_p
,
6402 find_omp_clause (OMP_TASK_CLAUSES (expr
),
6404 ? ORT_UNTIED_TASK
: ORT_TASK
);
6406 push_gimplify_context (&gctx
);
6408 g
= gimplify_and_return_first (OMP_TASK_BODY (expr
), &body
);
6409 if (gimple_code (g
) == GIMPLE_BIND
)
6410 pop_gimplify_context (g
);
6412 pop_gimplify_context (NULL
);
6414 gimplify_adjust_omp_clauses (&OMP_TASK_CLAUSES (expr
));
6416 g
= gimple_build_omp_task (body
,
6417 OMP_TASK_CLAUSES (expr
),
6418 NULL_TREE
, NULL_TREE
,
6419 NULL_TREE
, NULL_TREE
, NULL_TREE
);
6420 gimplify_seq_add_stmt (pre_p
, g
);
6421 *expr_p
= NULL_TREE
;
6424 /* Gimplify the gross structure of an OMP_FOR statement. */
6426 static enum gimplify_status
6427 gimplify_omp_for (tree
*expr_p
, gimple_seq
*pre_p
)
6429 tree for_stmt
, decl
, var
, t
;
6430 enum gimplify_status ret
= GS_ALL_DONE
;
6431 enum gimplify_status tret
;
6433 gimple_seq for_body
, for_pre_body
;
6438 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
), pre_p
,
6441 /* Handle OMP_FOR_INIT. */
6442 for_pre_body
= NULL
;
6443 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
6444 OMP_FOR_PRE_BODY (for_stmt
) = NULL_TREE
;
6446 for_body
= gimple_seq_alloc ();
6447 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6448 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt
)));
6449 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6450 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt
)));
6451 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6453 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6454 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6455 decl
= TREE_OPERAND (t
, 0);
6456 gcc_assert (DECL_P (decl
));
6457 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl
))
6458 || POINTER_TYPE_P (TREE_TYPE (decl
)));
6460 /* Make sure the iteration variable is private. */
6461 if (omp_is_private (gimplify_omp_ctxp
, decl
))
6462 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
6464 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_PRIVATE
| GOVD_SEEN
);
6466 /* If DECL is not a gimple register, create a temporary variable to act
6467 as an iteration counter. This is valid, since DECL cannot be
6468 modified in the body of the loop. */
6469 if (!is_gimple_reg (decl
))
6471 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
6472 TREE_OPERAND (t
, 0) = var
;
6474 gimplify_seq_add_stmt (&for_body
, gimple_build_assign (decl
, var
));
6476 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
6481 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6482 is_gimple_val
, fb_rvalue
);
6483 ret
= MIN (ret
, tret
);
6484 if (ret
== GS_ERROR
)
6487 /* Handle OMP_FOR_COND. */
6488 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
6489 gcc_assert (COMPARISON_CLASS_P (t
));
6490 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6492 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6493 is_gimple_val
, fb_rvalue
);
6494 ret
= MIN (ret
, tret
);
6496 /* Handle OMP_FOR_INCR. */
6497 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6498 switch (TREE_CODE (t
))
6500 case PREINCREMENT_EXPR
:
6501 case POSTINCREMENT_EXPR
:
6502 t
= build_int_cst (TREE_TYPE (decl
), 1);
6503 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6504 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6505 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6508 case PREDECREMENT_EXPR
:
6509 case POSTDECREMENT_EXPR
:
6510 t
= build_int_cst (TREE_TYPE (decl
), -1);
6511 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6512 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6513 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6517 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6518 TREE_OPERAND (t
, 0) = var
;
6520 t
= TREE_OPERAND (t
, 1);
6521 switch (TREE_CODE (t
))
6524 if (TREE_OPERAND (t
, 1) == decl
)
6526 TREE_OPERAND (t
, 1) = TREE_OPERAND (t
, 0);
6527 TREE_OPERAND (t
, 0) = var
;
6533 case POINTER_PLUS_EXPR
:
6534 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6535 TREE_OPERAND (t
, 0) = var
;
6541 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6542 is_gimple_val
, fb_rvalue
);
6543 ret
= MIN (ret
, tret
);
6550 if (var
!= decl
|| TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1)
6553 for (c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
6554 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6555 && OMP_CLAUSE_DECL (c
) == decl
6556 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) == NULL
)
6558 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6559 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6560 gcc_assert (TREE_OPERAND (t
, 0) == var
);
6561 t
= TREE_OPERAND (t
, 1);
6562 gcc_assert (TREE_CODE (t
) == PLUS_EXPR
6563 || TREE_CODE (t
) == MINUS_EXPR
6564 || TREE_CODE (t
) == POINTER_PLUS_EXPR
);
6565 gcc_assert (TREE_OPERAND (t
, 0) == var
);
6566 t
= build2 (TREE_CODE (t
), TREE_TYPE (decl
), decl
,
6567 TREE_OPERAND (t
, 1));
6568 gimplify_assign (decl
, t
,
6569 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6574 gimplify_and_add (OMP_FOR_BODY (for_stmt
), &for_body
);
6576 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
));
6578 gfor
= gimple_build_omp_for (for_body
, OMP_FOR_CLAUSES (for_stmt
),
6579 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)),
6582 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6584 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6585 gimple_omp_for_set_index (gfor
, i
, TREE_OPERAND (t
, 0));
6586 gimple_omp_for_set_initial (gfor
, i
, TREE_OPERAND (t
, 1));
6587 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
6588 gimple_omp_for_set_cond (gfor
, i
, TREE_CODE (t
));
6589 gimple_omp_for_set_final (gfor
, i
, TREE_OPERAND (t
, 1));
6590 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6591 gimple_omp_for_set_incr (gfor
, i
, TREE_OPERAND (t
, 1));
6594 gimplify_seq_add_stmt (pre_p
, gfor
);
6595 return ret
== GS_ALL_DONE
? GS_ALL_DONE
: GS_ERROR
;
6598 /* Gimplify the gross structure of other OpenMP worksharing constructs.
6599 In particular, OMP_SECTIONS and OMP_SINGLE. */
6602 gimplify_omp_workshare (tree
*expr_p
, gimple_seq
*pre_p
)
6604 tree expr
= *expr_p
;
6606 gimple_seq body
= NULL
;
6608 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr
), pre_p
, ORT_WORKSHARE
);
6609 gimplify_and_add (OMP_BODY (expr
), &body
);
6610 gimplify_adjust_omp_clauses (&OMP_CLAUSES (expr
));
6612 if (TREE_CODE (expr
) == OMP_SECTIONS
)
6613 stmt
= gimple_build_omp_sections (body
, OMP_CLAUSES (expr
));
6614 else if (TREE_CODE (expr
) == OMP_SINGLE
)
6615 stmt
= gimple_build_omp_single (body
, OMP_CLAUSES (expr
));
6619 gimplify_seq_add_stmt (pre_p
, stmt
);
6622 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
6623 stabilized the lhs of the atomic operation as *ADDR. Return true if
6624 EXPR is this stabilized form. */
6627 goa_lhs_expr_p (tree expr
, tree addr
)
6629 /* Also include casts to other type variants. The C front end is fond
6630 of adding these for e.g. volatile variables. This is like
6631 STRIP_TYPE_NOPS but includes the main variant lookup. */
6632 STRIP_USELESS_TYPE_CONVERSION (expr
);
6634 if (TREE_CODE (expr
) == INDIRECT_REF
)
6636 expr
= TREE_OPERAND (expr
, 0);
6638 && (CONVERT_EXPR_P (expr
)
6639 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
6640 && TREE_CODE (expr
) == TREE_CODE (addr
)
6641 && types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (addr
)))
6643 expr
= TREE_OPERAND (expr
, 0);
6644 addr
= TREE_OPERAND (addr
, 0);
6648 return (TREE_CODE (addr
) == ADDR_EXPR
6649 && TREE_CODE (expr
) == ADDR_EXPR
6650 && TREE_OPERAND (addr
, 0) == TREE_OPERAND (expr
, 0));
6652 if (TREE_CODE (addr
) == ADDR_EXPR
&& expr
== TREE_OPERAND (addr
, 0))
6657 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
6658 expression does not involve the lhs, evaluate it into a temporary.
6659 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
6660 or -1 if an error was encountered. */
6663 goa_stabilize_expr (tree
*expr_p
, gimple_seq
*pre_p
, tree lhs_addr
,
6666 tree expr
= *expr_p
;
6669 if (goa_lhs_expr_p (expr
, lhs_addr
))
6674 if (is_gimple_val (expr
))
6678 switch (TREE_CODE_CLASS (TREE_CODE (expr
)))
6681 case tcc_comparison
:
6682 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
, lhs_addr
,
6685 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
, lhs_addr
,
6688 case tcc_expression
:
6689 switch (TREE_CODE (expr
))
6691 case TRUTH_ANDIF_EXPR
:
6692 case TRUTH_ORIF_EXPR
:
6693 case TRUTH_AND_EXPR
:
6695 case TRUTH_XOR_EXPR
:
6696 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
,
6698 case TRUTH_NOT_EXPR
:
6699 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
6703 /* Break out any preevaluations from cp_build_modify_expr. */
6704 for (; TREE_CODE (expr
) == COMPOUND_EXPR
;
6705 expr
= TREE_OPERAND (expr
, 1))
6706 gimplify_stmt (&TREE_OPERAND (expr
, 0), pre_p
);
6708 return goa_stabilize_expr (expr_p
, pre_p
, lhs_addr
, lhs_var
);
6719 enum gimplify_status gs
;
6720 gs
= gimplify_expr (expr_p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
6721 if (gs
!= GS_ALL_DONE
)
6728 /* Gimplify an OMP_ATOMIC statement. */
6730 static enum gimplify_status
6731 gimplify_omp_atomic (tree
*expr_p
, gimple_seq
*pre_p
)
6733 tree addr
= TREE_OPERAND (*expr_p
, 0);
6734 tree rhs
= TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
6735 ? NULL
: TREE_OPERAND (*expr_p
, 1);
6736 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
6738 gimple loadstmt
, storestmt
;
6740 tmp_load
= create_tmp_reg (type
, NULL
);
6741 if (rhs
&& goa_stabilize_expr (&rhs
, pre_p
, addr
, tmp_load
) < 0)
6744 if (gimplify_expr (&addr
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
6748 loadstmt
= gimple_build_omp_atomic_load (tmp_load
, addr
);
6749 gimplify_seq_add_stmt (pre_p
, loadstmt
);
6750 if (rhs
&& gimplify_expr (&rhs
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
6754 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
)
6756 storestmt
= gimple_build_omp_atomic_store (rhs
);
6757 gimplify_seq_add_stmt (pre_p
, storestmt
);
6758 switch (TREE_CODE (*expr_p
))
6760 case OMP_ATOMIC_READ
:
6761 case OMP_ATOMIC_CAPTURE_OLD
:
6763 gimple_omp_atomic_set_need_value (loadstmt
);
6765 case OMP_ATOMIC_CAPTURE_NEW
:
6767 gimple_omp_atomic_set_need_value (storestmt
);
6777 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
6778 body, and adding some EH bits. */
6780 static enum gimplify_status
6781 gimplify_transaction (tree
*expr_p
, gimple_seq
*pre_p
)
6783 tree expr
= *expr_p
, temp
, tbody
= TRANSACTION_EXPR_BODY (expr
);
6785 gimple_seq body
= NULL
;
6786 struct gimplify_ctx gctx
;
6789 /* Wrap the transaction body in a BIND_EXPR so we have a context
6790 where to put decls for OpenMP. */
6791 if (TREE_CODE (tbody
) != BIND_EXPR
)
6793 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, tbody
, NULL
);
6794 TREE_SIDE_EFFECTS (bind
) = 1;
6795 SET_EXPR_LOCATION (bind
, EXPR_LOCATION (tbody
));
6796 TRANSACTION_EXPR_BODY (expr
) = bind
;
6799 push_gimplify_context (&gctx
);
6800 temp
= voidify_wrapper_expr (*expr_p
, NULL
);
6802 g
= gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr
), &body
);
6803 pop_gimplify_context (g
);
6805 g
= gimple_build_transaction (body
, NULL
);
6806 if (TRANSACTION_EXPR_OUTER (expr
))
6807 subcode
= GTMA_IS_OUTER
;
6808 else if (TRANSACTION_EXPR_RELAXED (expr
))
6809 subcode
= GTMA_IS_RELAXED
;
6810 gimple_transaction_set_subcode (g
, subcode
);
6812 gimplify_seq_add_stmt (pre_p
, g
);
6820 *expr_p
= NULL_TREE
;
6824 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
6825 expression produces a value to be used as an operand inside a GIMPLE
6826 statement, the value will be stored back in *EXPR_P. This value will
6827 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
6828 an SSA_NAME. The corresponding sequence of GIMPLE statements is
6829 emitted in PRE_P and POST_P.
6831 Additionally, this process may overwrite parts of the input
6832 expression during gimplification. Ideally, it should be
6833 possible to do non-destructive gimplification.
6835 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
6836 the expression needs to evaluate to a value to be used as
6837 an operand in a GIMPLE statement, this value will be stored in
6838 *EXPR_P on exit. This happens when the caller specifies one
6839 of fb_lvalue or fb_rvalue fallback flags.
6841 PRE_P will contain the sequence of GIMPLE statements corresponding
6842 to the evaluation of EXPR and all the side-effects that must
6843 be executed before the main expression. On exit, the last
6844 statement of PRE_P is the core statement being gimplified. For
6845 instance, when gimplifying 'if (++a)' the last statement in
6846 PRE_P will be 'if (t.1)' where t.1 is the result of
6847 pre-incrementing 'a'.
6849 POST_P will contain the sequence of GIMPLE statements corresponding
6850 to the evaluation of all the side-effects that must be executed
6851 after the main expression. If this is NULL, the post
6852 side-effects are stored at the end of PRE_P.
6854 The reason why the output is split in two is to handle post
6855 side-effects explicitly. In some cases, an expression may have
6856 inner and outer post side-effects which need to be emitted in
6857 an order different from the one given by the recursive
6858 traversal. For instance, for the expression (*p--)++ the post
6859 side-effects of '--' must actually occur *after* the post
6860 side-effects of '++'. However, gimplification will first visit
6861 the inner expression, so if a separate POST sequence was not
6862 used, the resulting sequence would be:
6869 However, the post-decrement operation in line #2 must not be
6870 evaluated until after the store to *p at line #4, so the
6871 correct sequence should be:
6878 So, by specifying a separate post queue, it is possible
6879 to emit the post side-effects in the correct order.
6880 If POST_P is NULL, an internal queue will be used. Before
6881 returning to the caller, the sequence POST_P is appended to
6882 the main output sequence PRE_P.
6884 GIMPLE_TEST_F points to a function that takes a tree T and
6885 returns nonzero if T is in the GIMPLE form requested by the
6886 caller. The GIMPLE predicates are in gimple.c.
6888 FALLBACK tells the function what sort of a temporary we want if
6889 gimplification cannot produce an expression that complies with
6892 fb_none means that no temporary should be generated
6893 fb_rvalue means that an rvalue is OK to generate
6894 fb_lvalue means that an lvalue is OK to generate
6895 fb_either means that either is OK, but an lvalue is preferable.
6896 fb_mayfail means that gimplification may fail (in which case
6897 GS_ERROR will be returned)
6899 The return value is either GS_ERROR or GS_ALL_DONE, since this
6900 function iterates until EXPR is completely gimplified or an error
6903 enum gimplify_status
6904 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
6905 bool (*gimple_test_f
) (tree
), fallback_t fallback
)
6908 gimple_seq internal_pre
= NULL
;
6909 gimple_seq internal_post
= NULL
;
6912 location_t saved_location
;
6913 enum gimplify_status ret
;
6914 gimple_stmt_iterator pre_last_gsi
, post_last_gsi
;
6916 save_expr
= *expr_p
;
6917 if (save_expr
== NULL_TREE
)
6920 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
6921 is_statement
= gimple_test_f
== is_gimple_stmt
;
6925 /* Consistency checks. */
6926 if (gimple_test_f
== is_gimple_reg
)
6927 gcc_assert (fallback
& (fb_rvalue
| fb_lvalue
));
6928 else if (gimple_test_f
== is_gimple_val
6929 || gimple_test_f
== is_gimple_call_addr
6930 || gimple_test_f
== is_gimple_condexpr
6931 || gimple_test_f
== is_gimple_mem_rhs
6932 || gimple_test_f
== is_gimple_mem_rhs_or_call
6933 || gimple_test_f
== is_gimple_reg_rhs
6934 || gimple_test_f
== is_gimple_reg_rhs_or_call
6935 || gimple_test_f
== is_gimple_asm_val
6936 || gimple_test_f
== is_gimple_mem_ref_addr
)
6937 gcc_assert (fallback
& fb_rvalue
);
6938 else if (gimple_test_f
== is_gimple_min_lval
6939 || gimple_test_f
== is_gimple_lvalue
)
6940 gcc_assert (fallback
& fb_lvalue
);
6941 else if (gimple_test_f
== is_gimple_addressable
)
6942 gcc_assert (fallback
& fb_either
);
6943 else if (gimple_test_f
== is_gimple_stmt
)
6944 gcc_assert (fallback
== fb_none
);
6947 /* We should have recognized the GIMPLE_TEST_F predicate to
6948 know what kind of fallback to use in case a temporary is
6949 needed to hold the value or address of *EXPR_P. */
6953 /* We used to check the predicate here and return immediately if it
6954 succeeds. This is wrong; the design is for gimplification to be
6955 idempotent, and for the predicates to only test for valid forms, not
6956 whether they are fully simplified. */
6958 pre_p
= &internal_pre
;
6961 post_p
= &internal_post
;
6963 /* Remember the last statements added to PRE_P and POST_P. Every
6964 new statement added by the gimplification helpers needs to be
6965 annotated with location information. To centralize the
6966 responsibility, we remember the last statement that had been
6967 added to both queues before gimplifying *EXPR_P. If
6968 gimplification produces new statements in PRE_P and POST_P, those
6969 statements will be annotated with the same location information
6971 pre_last_gsi
= gsi_last (*pre_p
);
6972 post_last_gsi
= gsi_last (*post_p
);
6974 saved_location
= input_location
;
6975 if (save_expr
!= error_mark_node
6976 && EXPR_HAS_LOCATION (*expr_p
))
6977 input_location
= EXPR_LOCATION (*expr_p
);
6979 /* Loop over the specific gimplifiers until the toplevel node
6980 remains the same. */
6983 /* Strip away as many useless type conversions as possible
6985 STRIP_USELESS_TYPE_CONVERSION (*expr_p
);
6987 /* Remember the expr. */
6988 save_expr
= *expr_p
;
6990 /* Die, die, die, my darling. */
6991 if (save_expr
== error_mark_node
6992 || (TREE_TYPE (save_expr
)
6993 && TREE_TYPE (save_expr
) == error_mark_node
))
6999 /* Do any language-specific gimplification. */
7000 ret
= ((enum gimplify_status
)
7001 lang_hooks
.gimplify_expr (expr_p
, pre_p
, post_p
));
7004 if (*expr_p
== NULL_TREE
)
7006 if (*expr_p
!= save_expr
)
7009 else if (ret
!= GS_UNHANDLED
)
7012 /* Make sure that all the cases set 'ret' appropriately. */
7014 switch (TREE_CODE (*expr_p
))
7016 /* First deal with the special cases. */
7018 case POSTINCREMENT_EXPR
:
7019 case POSTDECREMENT_EXPR
:
7020 case PREINCREMENT_EXPR
:
7021 case PREDECREMENT_EXPR
:
7022 ret
= gimplify_self_mod_expr (expr_p
, pre_p
, post_p
,
7023 fallback
!= fb_none
);
7027 case ARRAY_RANGE_REF
:
7031 case VIEW_CONVERT_EXPR
:
7032 ret
= gimplify_compound_lval (expr_p
, pre_p
, post_p
,
7033 fallback
? fallback
: fb_rvalue
);
7037 ret
= gimplify_cond_expr (expr_p
, pre_p
, fallback
);
7039 /* C99 code may assign to an array in a structure value of a
7040 conditional expression, and this has undefined behavior
7041 only on execution, so create a temporary if an lvalue is
7043 if (fallback
== fb_lvalue
)
7045 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7046 mark_addressable (*expr_p
);
7052 ret
= gimplify_call_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7054 /* C99 code may assign to an array in a structure returned
7055 from a function, and this has undefined behavior only on
7056 execution, so create a temporary if an lvalue is
7058 if (fallback
== fb_lvalue
)
7060 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7061 mark_addressable (*expr_p
);
7070 ret
= gimplify_compound_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7073 case COMPOUND_LITERAL_EXPR
:
7074 ret
= gimplify_compound_literal_expr (expr_p
, pre_p
);
7079 ret
= gimplify_modify_expr (expr_p
, pre_p
, post_p
,
7080 fallback
!= fb_none
);
7083 case TRUTH_ANDIF_EXPR
:
7084 case TRUTH_ORIF_EXPR
:
7086 /* Preserve the original type of the expression and the
7087 source location of the outer expression. */
7088 tree org_type
= TREE_TYPE (*expr_p
);
7089 *expr_p
= gimple_boolify (*expr_p
);
7090 *expr_p
= build3_loc (input_location
, COND_EXPR
,
7094 org_type
, boolean_true_node
),
7097 org_type
, boolean_false_node
));
7102 case TRUTH_NOT_EXPR
:
7104 tree type
= TREE_TYPE (*expr_p
);
7105 /* The parsers are careful to generate TRUTH_NOT_EXPR
7106 only with operands that are always zero or one.
7107 We do not fold here but handle the only interesting case
7108 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
7109 *expr_p
= gimple_boolify (*expr_p
);
7110 if (TYPE_PRECISION (TREE_TYPE (*expr_p
)) == 1)
7111 *expr_p
= build1_loc (input_location
, BIT_NOT_EXPR
,
7112 TREE_TYPE (*expr_p
),
7113 TREE_OPERAND (*expr_p
, 0));
7115 *expr_p
= build2_loc (input_location
, BIT_XOR_EXPR
,
7116 TREE_TYPE (*expr_p
),
7117 TREE_OPERAND (*expr_p
, 0),
7118 build_int_cst (TREE_TYPE (*expr_p
), 1));
7119 if (!useless_type_conversion_p (type
, TREE_TYPE (*expr_p
)))
7120 *expr_p
= fold_convert_loc (input_location
, type
, *expr_p
);
7126 ret
= gimplify_addr_expr (expr_p
, pre_p
, post_p
);
7130 ret
= gimplify_va_arg_expr (expr_p
, pre_p
, post_p
);
7134 if (IS_EMPTY_STMT (*expr_p
))
7140 if (VOID_TYPE_P (TREE_TYPE (*expr_p
))
7141 || fallback
== fb_none
)
7143 /* Just strip a conversion to void (or in void context) and
7145 *expr_p
= TREE_OPERAND (*expr_p
, 0);
7150 ret
= gimplify_conversion (expr_p
);
7151 if (ret
== GS_ERROR
)
7153 if (*expr_p
!= save_expr
)
7157 case FIX_TRUNC_EXPR
:
7158 /* unary_expr: ... | '(' cast ')' val | ... */
7159 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7160 is_gimple_val
, fb_rvalue
);
7161 recalculate_side_effects (*expr_p
);
7166 bool volatilep
= TREE_THIS_VOLATILE (*expr_p
);
7167 bool notrap
= TREE_THIS_NOTRAP (*expr_p
);
7168 tree saved_ptr_type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 0));
7170 *expr_p
= fold_indirect_ref_loc (input_location
, *expr_p
);
7171 if (*expr_p
!= save_expr
)
7177 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7178 is_gimple_reg
, fb_rvalue
);
7179 if (ret
== GS_ERROR
)
7182 recalculate_side_effects (*expr_p
);
7183 *expr_p
= fold_build2_loc (input_location
, MEM_REF
,
7184 TREE_TYPE (*expr_p
),
7185 TREE_OPERAND (*expr_p
, 0),
7186 build_int_cst (saved_ptr_type
, 0));
7187 TREE_THIS_VOLATILE (*expr_p
) = volatilep
;
7188 TREE_THIS_NOTRAP (*expr_p
) = notrap
;
7193 /* We arrive here through the various re-gimplifcation paths. */
7195 /* First try re-folding the whole thing. */
7196 tmp
= fold_binary (MEM_REF
, TREE_TYPE (*expr_p
),
7197 TREE_OPERAND (*expr_p
, 0),
7198 TREE_OPERAND (*expr_p
, 1));
7202 recalculate_side_effects (*expr_p
);
7206 /* Avoid re-gimplifying the address operand if it is already
7207 in suitable form. Re-gimplifying would mark the address
7208 operand addressable. Always gimplify when not in SSA form
7209 as we still may have to gimplify decls with value-exprs. */
7210 if (!gimplify_ctxp
|| !gimplify_ctxp
->into_ssa
7211 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p
, 0)))
7213 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7214 is_gimple_mem_ref_addr
, fb_rvalue
);
7215 if (ret
== GS_ERROR
)
7218 recalculate_side_effects (*expr_p
);
7222 /* Constants need not be gimplified. */
7233 /* If we require an lvalue, such as for ADDR_EXPR, retain the
7234 CONST_DECL node. Otherwise the decl is replaceable by its
7236 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
7237 if (fallback
& fb_lvalue
)
7241 *expr_p
= DECL_INITIAL (*expr_p
);
7247 ret
= gimplify_decl_expr (expr_p
, pre_p
);
7251 ret
= gimplify_bind_expr (expr_p
, pre_p
);
7255 ret
= gimplify_loop_expr (expr_p
, pre_p
);
7259 ret
= gimplify_switch_expr (expr_p
, pre_p
);
7263 ret
= gimplify_exit_expr (expr_p
);
7267 /* If the target is not LABEL, then it is a computed jump
7268 and the target needs to be gimplified. */
7269 if (TREE_CODE (GOTO_DESTINATION (*expr_p
)) != LABEL_DECL
)
7271 ret
= gimplify_expr (&GOTO_DESTINATION (*expr_p
), pre_p
,
7272 NULL
, is_gimple_val
, fb_rvalue
);
7273 if (ret
== GS_ERROR
)
7276 gimplify_seq_add_stmt (pre_p
,
7277 gimple_build_goto (GOTO_DESTINATION (*expr_p
)));
7282 gimplify_seq_add_stmt (pre_p
,
7283 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p
),
7284 PREDICT_EXPR_OUTCOME (*expr_p
)));
7290 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p
))
7291 == current_function_decl
);
7292 gimplify_seq_add_stmt (pre_p
,
7293 gimple_build_label (LABEL_EXPR_LABEL (*expr_p
)));
7296 case CASE_LABEL_EXPR
:
7297 ret
= gimplify_case_label_expr (expr_p
, pre_p
);
7301 ret
= gimplify_return_expr (*expr_p
, pre_p
);
7305 /* Don't reduce this in place; let gimplify_init_constructor work its
7306 magic. Buf if we're just elaborating this for side effects, just
7307 gimplify any element that has side-effects. */
7308 if (fallback
== fb_none
)
7310 unsigned HOST_WIDE_INT ix
;
7312 tree temp
= NULL_TREE
;
7313 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p
), ix
, val
)
7314 if (TREE_SIDE_EFFECTS (val
))
7315 append_to_statement_list (val
, &temp
);
7318 ret
= temp
? GS_OK
: GS_ALL_DONE
;
7320 /* C99 code may assign to an array in a constructed
7321 structure or union, and this has undefined behavior only
7322 on execution, so create a temporary if an lvalue is
7324 else if (fallback
== fb_lvalue
)
7326 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7327 mark_addressable (*expr_p
);
7334 /* The following are special cases that are not handled by the
7335 original GIMPLE grammar. */
7337 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
7340 ret
= gimplify_save_expr (expr_p
, pre_p
, post_p
);
7345 enum gimplify_status r0
, r1
, r2
;
7347 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7348 post_p
, is_gimple_lvalue
, fb_either
);
7349 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7350 post_p
, is_gimple_val
, fb_rvalue
);
7351 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
7352 post_p
, is_gimple_val
, fb_rvalue
);
7353 recalculate_side_effects (*expr_p
);
7355 ret
= MIN (r0
, MIN (r1
, r2
));
7359 case TARGET_MEM_REF
:
7361 enum gimplify_status r0
= GS_ALL_DONE
, r1
= GS_ALL_DONE
;
7363 if (TMR_BASE (*expr_p
))
7364 r0
= gimplify_expr (&TMR_BASE (*expr_p
), pre_p
,
7365 post_p
, is_gimple_mem_ref_addr
, fb_either
);
7366 if (TMR_INDEX (*expr_p
))
7367 r1
= gimplify_expr (&TMR_INDEX (*expr_p
), pre_p
,
7368 post_p
, is_gimple_val
, fb_rvalue
);
7369 if (TMR_INDEX2 (*expr_p
))
7370 r1
= gimplify_expr (&TMR_INDEX2 (*expr_p
), pre_p
,
7371 post_p
, is_gimple_val
, fb_rvalue
);
7372 /* TMR_STEP and TMR_OFFSET are always integer constants. */
7377 case NON_LVALUE_EXPR
:
7378 /* This should have been stripped above. */
7382 ret
= gimplify_asm_expr (expr_p
, pre_p
, post_p
);
7385 case TRY_FINALLY_EXPR
:
7386 case TRY_CATCH_EXPR
:
7388 gimple_seq eval
, cleanup
;
7391 eval
= cleanup
= NULL
;
7392 gimplify_and_add (TREE_OPERAND (*expr_p
, 0), &eval
);
7393 gimplify_and_add (TREE_OPERAND (*expr_p
, 1), &cleanup
);
7394 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
7395 if (gimple_seq_empty_p (cleanup
))
7397 gimple_seq_add_seq (pre_p
, eval
);
7401 try_
= gimple_build_try (eval
, cleanup
,
7402 TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
7403 ? GIMPLE_TRY_FINALLY
7404 : GIMPLE_TRY_CATCH
);
7405 if (TREE_CODE (*expr_p
) == TRY_CATCH_EXPR
)
7406 gimple_try_set_catch_is_cleanup (try_
,
7407 TRY_CATCH_IS_CLEANUP (*expr_p
));
7408 gimplify_seq_add_stmt (pre_p
, try_
);
7413 case CLEANUP_POINT_EXPR
:
7414 ret
= gimplify_cleanup_point_expr (expr_p
, pre_p
);
7418 ret
= gimplify_target_expr (expr_p
, pre_p
, post_p
);
7424 gimple_seq handler
= NULL
;
7425 gimplify_and_add (CATCH_BODY (*expr_p
), &handler
);
7426 c
= gimple_build_catch (CATCH_TYPES (*expr_p
), handler
);
7427 gimplify_seq_add_stmt (pre_p
, c
);
7432 case EH_FILTER_EXPR
:
7435 gimple_seq failure
= NULL
;
7437 gimplify_and_add (EH_FILTER_FAILURE (*expr_p
), &failure
);
7438 ehf
= gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p
), failure
);
7439 gimple_set_no_warning (ehf
, TREE_NO_WARNING (*expr_p
));
7440 gimplify_seq_add_stmt (pre_p
, ehf
);
7447 enum gimplify_status r0
, r1
;
7448 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
,
7449 post_p
, is_gimple_val
, fb_rvalue
);
7450 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
,
7451 post_p
, is_gimple_val
, fb_rvalue
);
7452 TREE_SIDE_EFFECTS (*expr_p
) = 0;
7458 /* We get here when taking the address of a label. We mark
7459 the label as "forced"; meaning it can never be removed and
7460 it is a potential target for any computed goto. */
7461 FORCED_LABEL (*expr_p
) = 1;
7465 case STATEMENT_LIST
:
7466 ret
= gimplify_statement_list (expr_p
, pre_p
);
7469 case WITH_SIZE_EXPR
:
7471 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7472 post_p
== &internal_post
? NULL
: post_p
,
7473 gimple_test_f
, fallback
);
7474 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
7475 is_gimple_val
, fb_rvalue
);
7482 ret
= gimplify_var_or_parm_decl (expr_p
);
7486 /* When within an OpenMP context, notice uses of variables. */
7487 if (gimplify_omp_ctxp
)
7488 omp_notice_variable (gimplify_omp_ctxp
, *expr_p
, true);
7493 /* Allow callbacks into the gimplifier during optimization. */
7498 gimplify_omp_parallel (expr_p
, pre_p
);
7503 gimplify_omp_task (expr_p
, pre_p
);
7508 ret
= gimplify_omp_for (expr_p
, pre_p
);
7513 gimplify_omp_workshare (expr_p
, pre_p
);
7522 gimple_seq body
= NULL
;
7525 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
7526 switch (TREE_CODE (*expr_p
))
7529 g
= gimple_build_omp_section (body
);
7532 g
= gimple_build_omp_master (body
);
7535 g
= gimple_build_omp_ordered (body
);
7538 g
= gimple_build_omp_critical (body
,
7539 OMP_CRITICAL_NAME (*expr_p
));
7544 gimplify_seq_add_stmt (pre_p
, g
);
7550 case OMP_ATOMIC_READ
:
7551 case OMP_ATOMIC_CAPTURE_OLD
:
7552 case OMP_ATOMIC_CAPTURE_NEW
:
7553 ret
= gimplify_omp_atomic (expr_p
, pre_p
);
7556 case TRANSACTION_EXPR
:
7557 ret
= gimplify_transaction (expr_p
, pre_p
);
7560 case TRUTH_AND_EXPR
:
7562 case TRUTH_XOR_EXPR
:
7564 tree orig_type
= TREE_TYPE (*expr_p
);
7565 tree new_type
, xop0
, xop1
;
7566 *expr_p
= gimple_boolify (*expr_p
);
7567 new_type
= TREE_TYPE (*expr_p
);
7568 if (!useless_type_conversion_p (orig_type
, new_type
))
7570 *expr_p
= fold_convert_loc (input_location
, orig_type
, *expr_p
);
7575 /* Boolified binary truth expressions are semantically equivalent
7576 to bitwise binary expressions. Canonicalize them to the
7578 switch (TREE_CODE (*expr_p
))
7580 case TRUTH_AND_EXPR
:
7581 TREE_SET_CODE (*expr_p
, BIT_AND_EXPR
);
7584 TREE_SET_CODE (*expr_p
, BIT_IOR_EXPR
);
7586 case TRUTH_XOR_EXPR
:
7587 TREE_SET_CODE (*expr_p
, BIT_XOR_EXPR
);
7592 /* Now make sure that operands have compatible type to
7593 expression's new_type. */
7594 xop0
= TREE_OPERAND (*expr_p
, 0);
7595 xop1
= TREE_OPERAND (*expr_p
, 1);
7596 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop0
)))
7597 TREE_OPERAND (*expr_p
, 0) = fold_convert_loc (input_location
,
7600 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop1
)))
7601 TREE_OPERAND (*expr_p
, 1) = fold_convert_loc (input_location
,
7604 /* Continue classified as tcc_binary. */
7610 /* Classified as tcc_expression. */
7613 case POINTER_PLUS_EXPR
:
7615 enum gimplify_status r0
, r1
;
7616 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7617 post_p
, is_gimple_val
, fb_rvalue
);
7618 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7619 post_p
, is_gimple_val
, fb_rvalue
);
7620 recalculate_side_effects (*expr_p
);
7622 /* Convert &X + CST to invariant &MEM[&X, CST]. Do this
7623 after gimplifying operands - this is similar to how
7624 it would be folding all gimplified stmts on creation
7625 to have them canonicalized, which is what we eventually
7626 should do anyway. */
7627 if (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == INTEGER_CST
7628 && is_gimple_min_invariant (TREE_OPERAND (*expr_p
, 0)))
7630 *expr_p
= build_fold_addr_expr_with_type_loc
7632 fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (*expr_p
)),
7633 TREE_OPERAND (*expr_p
, 0),
7634 fold_convert (ptr_type_node
,
7635 TREE_OPERAND (*expr_p
, 1))),
7636 TREE_TYPE (*expr_p
));
7637 ret
= MIN (ret
, GS_OK
);
7643 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p
)))
7645 case tcc_comparison
:
7646 /* Handle comparison of objects of non scalar mode aggregates
7647 with a call to memcmp. It would be nice to only have to do
7648 this for variable-sized objects, but then we'd have to allow
7649 the same nest of reference nodes we allow for MODIFY_EXPR and
7652 Compare scalar mode aggregates as scalar mode values. Using
7653 memcmp for them would be very inefficient at best, and is
7654 plain wrong if bitfields are involved. */
7656 tree type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 1));
7658 /* Vector comparisons need no boolification. */
7659 if (TREE_CODE (type
) == VECTOR_TYPE
)
7661 else if (!AGGREGATE_TYPE_P (type
))
7663 tree org_type
= TREE_TYPE (*expr_p
);
7664 *expr_p
= gimple_boolify (*expr_p
);
7665 if (!useless_type_conversion_p (org_type
,
7666 TREE_TYPE (*expr_p
)))
7668 *expr_p
= fold_convert_loc (input_location
,
7675 else if (TYPE_MODE (type
) != BLKmode
)
7676 ret
= gimplify_scalar_mode_aggregate_compare (expr_p
);
7678 ret
= gimplify_variable_sized_compare (expr_p
);
7683 /* If *EXPR_P does not need to be special-cased, handle it
7684 according to its class. */
7686 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7687 post_p
, is_gimple_val
, fb_rvalue
);
7693 enum gimplify_status r0
, r1
;
7695 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7696 post_p
, is_gimple_val
, fb_rvalue
);
7697 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7698 post_p
, is_gimple_val
, fb_rvalue
);
7706 enum gimplify_status r0
, r1
, r2
;
7708 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7709 post_p
, is_gimple_val
, fb_rvalue
);
7710 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7711 post_p
, is_gimple_val
, fb_rvalue
);
7712 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
7713 post_p
, is_gimple_val
, fb_rvalue
);
7715 ret
= MIN (MIN (r0
, r1
), r2
);
7719 case tcc_declaration
:
7722 goto dont_recalculate
;
7728 recalculate_side_effects (*expr_p
);
7734 gcc_assert (*expr_p
|| ret
!= GS_OK
);
7736 while (ret
== GS_OK
);
7738 /* If we encountered an error_mark somewhere nested inside, either
7739 stub out the statement or propagate the error back out. */
7740 if (ret
== GS_ERROR
)
7747 /* This was only valid as a return value from the langhook, which
7748 we handled. Make sure it doesn't escape from any other context. */
7749 gcc_assert (ret
!= GS_UNHANDLED
);
7751 if (fallback
== fb_none
&& *expr_p
&& !is_gimple_stmt (*expr_p
))
7753 /* We aren't looking for a value, and we don't have a valid
7754 statement. If it doesn't have side-effects, throw it away. */
7755 if (!TREE_SIDE_EFFECTS (*expr_p
))
7757 else if (!TREE_THIS_VOLATILE (*expr_p
))
7759 /* This is probably a _REF that contains something nested that
7760 has side effects. Recurse through the operands to find it. */
7761 enum tree_code code
= TREE_CODE (*expr_p
);
7768 case VIEW_CONVERT_EXPR
:
7769 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7770 gimple_test_f
, fallback
);
7774 case ARRAY_RANGE_REF
:
7775 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7776 gimple_test_f
, fallback
);
7777 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
7778 gimple_test_f
, fallback
);
7782 /* Anything else with side-effects must be converted to
7783 a valid statement before we get here. */
7789 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p
))
7790 && TYPE_MODE (TREE_TYPE (*expr_p
)) != BLKmode
)
7792 /* Historically, the compiler has treated a bare reference
7793 to a non-BLKmode volatile lvalue as forcing a load. */
7794 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p
));
7796 /* Normally, we do not want to create a temporary for a
7797 TREE_ADDRESSABLE type because such a type should not be
7798 copied by bitwise-assignment. However, we make an
7799 exception here, as all we are doing here is ensuring that
7800 we read the bytes that make up the type. We use
7801 create_tmp_var_raw because create_tmp_var will abort when
7802 given a TREE_ADDRESSABLE type. */
7803 tree tmp
= create_tmp_var_raw (type
, "vol");
7804 gimple_add_tmp_var (tmp
);
7805 gimplify_assign (tmp
, *expr_p
, pre_p
);
7809 /* We can't do anything useful with a volatile reference to
7810 an incomplete type, so just throw it away. Likewise for
7811 a BLKmode type, since any implicit inner load should
7812 already have been turned into an explicit one by the
7813 gimplification process. */
7817 /* If we are gimplifying at the statement level, we're done. Tack
7818 everything together and return. */
7819 if (fallback
== fb_none
|| is_statement
)
7821 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
7822 it out for GC to reclaim it. */
7823 *expr_p
= NULL_TREE
;
7825 if (!gimple_seq_empty_p (internal_pre
)
7826 || !gimple_seq_empty_p (internal_post
))
7828 gimplify_seq_add_seq (&internal_pre
, internal_post
);
7829 gimplify_seq_add_seq (pre_p
, internal_pre
);
7832 /* The result of gimplifying *EXPR_P is going to be the last few
7833 statements in *PRE_P and *POST_P. Add location information
7834 to all the statements that were added by the gimplification
7836 if (!gimple_seq_empty_p (*pre_p
))
7837 annotate_all_with_location_after (*pre_p
, pre_last_gsi
, input_location
);
7839 if (!gimple_seq_empty_p (*post_p
))
7840 annotate_all_with_location_after (*post_p
, post_last_gsi
,
7846 #ifdef ENABLE_GIMPLE_CHECKING
7849 enum tree_code code
= TREE_CODE (*expr_p
);
7850 /* These expressions should already be in gimple IR form. */
7851 gcc_assert (code
!= MODIFY_EXPR
7853 && code
!= BIND_EXPR
7854 && code
!= CATCH_EXPR
7855 && (code
!= COND_EXPR
|| gimplify_ctxp
->allow_rhs_cond_expr
)
7856 && code
!= EH_FILTER_EXPR
7857 && code
!= GOTO_EXPR
7858 && code
!= LABEL_EXPR
7859 && code
!= LOOP_EXPR
7860 && code
!= SWITCH_EXPR
7861 && code
!= TRY_FINALLY_EXPR
7862 && code
!= OMP_CRITICAL
7864 && code
!= OMP_MASTER
7865 && code
!= OMP_ORDERED
7866 && code
!= OMP_PARALLEL
7867 && code
!= OMP_SECTIONS
7868 && code
!= OMP_SECTION
7869 && code
!= OMP_SINGLE
);
7873 /* Otherwise we're gimplifying a subexpression, so the resulting
7874 value is interesting. If it's a valid operand that matches
7875 GIMPLE_TEST_F, we're done. Unless we are handling some
7876 post-effects internally; if that's the case, we need to copy into
7877 a temporary before adding the post-effects to POST_P. */
7878 if (gimple_seq_empty_p (internal_post
) && (*gimple_test_f
) (*expr_p
))
7881 /* Otherwise, we need to create a new temporary for the gimplified
7884 /* We can't return an lvalue if we have an internal postqueue. The
7885 object the lvalue refers to would (probably) be modified by the
7886 postqueue; we need to copy the value out first, which means an
7888 if ((fallback
& fb_lvalue
)
7889 && gimple_seq_empty_p (internal_post
)
7890 && is_gimple_addressable (*expr_p
))
7892 /* An lvalue will do. Take the address of the expression, store it
7893 in a temporary, and replace the expression with an INDIRECT_REF of
7895 tmp
= build_fold_addr_expr_loc (input_location
, *expr_p
);
7896 gimplify_expr (&tmp
, pre_p
, post_p
, is_gimple_reg
, fb_rvalue
);
7897 *expr_p
= build_simple_mem_ref (tmp
);
7899 else if ((fallback
& fb_rvalue
) && is_gimple_reg_rhs_or_call (*expr_p
))
7901 /* An rvalue will do. Assign the gimplified expression into a
7902 new temporary TMP and replace the original expression with
7903 TMP. First, make sure that the expression has a type so that
7904 it can be assigned into a temporary. */
7905 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p
)));
7907 if (!gimple_seq_empty_p (internal_post
) || (fallback
& fb_lvalue
))
7908 /* The postqueue might change the value of the expression between
7909 the initialization and use of the temporary, so we can't use a
7910 formal temp. FIXME do we care? */
7912 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7913 if (TREE_CODE (TREE_TYPE (*expr_p
)) == COMPLEX_TYPE
7914 || TREE_CODE (TREE_TYPE (*expr_p
)) == VECTOR_TYPE
)
7915 DECL_GIMPLE_REG_P (*expr_p
) = 1;
7918 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
7922 #ifdef ENABLE_GIMPLE_CHECKING
7923 if (!(fallback
& fb_mayfail
))
7925 fprintf (stderr
, "gimplification failed:\n");
7926 print_generic_expr (stderr
, *expr_p
, 0);
7927 debug_tree (*expr_p
);
7928 internal_error ("gimplification failed");
7931 gcc_assert (fallback
& fb_mayfail
);
7933 /* If this is an asm statement, and the user asked for the
7934 impossible, don't die. Fail and let gimplify_asm_expr
7940 /* Make sure the temporary matches our predicate. */
7941 gcc_assert ((*gimple_test_f
) (*expr_p
));
7943 if (!gimple_seq_empty_p (internal_post
))
7945 annotate_all_with_location (internal_post
, input_location
);
7946 gimplify_seq_add_seq (pre_p
, internal_post
);
7950 input_location
= saved_location
;
7954 /* Look through TYPE for variable-sized objects and gimplify each such
7955 size that we find. Add to LIST_P any statements generated. */
7958 gimplify_type_sizes (tree type
, gimple_seq
*list_p
)
7962 if (type
== NULL
|| type
== error_mark_node
)
7965 /* We first do the main variant, then copy into any other variants. */
7966 type
= TYPE_MAIN_VARIANT (type
);
7968 /* Avoid infinite recursion. */
7969 if (TYPE_SIZES_GIMPLIFIED (type
))
7972 TYPE_SIZES_GIMPLIFIED (type
) = 1;
7974 switch (TREE_CODE (type
))
7980 case FIXED_POINT_TYPE
:
7981 gimplify_one_sizepos (&TYPE_MIN_VALUE (type
), list_p
);
7982 gimplify_one_sizepos (&TYPE_MAX_VALUE (type
), list_p
);
7984 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
7986 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (type
);
7987 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (type
);
7992 /* These types may not have declarations, so handle them here. */
7993 gimplify_type_sizes (TREE_TYPE (type
), list_p
);
7994 gimplify_type_sizes (TYPE_DOMAIN (type
), list_p
);
7995 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
7996 with assigned stack slots, for -O1+ -g they should be tracked
7998 if (!(TYPE_NAME (type
)
7999 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
8000 && DECL_IGNORED_P (TYPE_NAME (type
)))
8001 && TYPE_DOMAIN (type
)
8002 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type
)))
8004 t
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
8005 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8006 DECL_IGNORED_P (t
) = 0;
8007 t
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
8008 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8009 DECL_IGNORED_P (t
) = 0;
8015 case QUAL_UNION_TYPE
:
8016 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
8017 if (TREE_CODE (field
) == FIELD_DECL
)
8019 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field
), list_p
);
8020 gimplify_one_sizepos (&DECL_SIZE (field
), list_p
);
8021 gimplify_one_sizepos (&DECL_SIZE_UNIT (field
), list_p
);
8022 gimplify_type_sizes (TREE_TYPE (field
), list_p
);
8027 case REFERENCE_TYPE
:
8028 /* We used to recurse on the pointed-to type here, which turned out to
8029 be incorrect because its definition might refer to variables not
8030 yet initialized at this point if a forward declaration is involved.
8032 It was actually useful for anonymous pointed-to types to ensure
8033 that the sizes evaluation dominates every possible later use of the
8034 values. Restricting to such types here would be safe since there
8035 is no possible forward declaration around, but would introduce an
8036 undesirable middle-end semantic to anonymity. We then defer to
8037 front-ends the responsibility of ensuring that the sizes are
8038 evaluated both early and late enough, e.g. by attaching artificial
8039 type declarations to the tree. */
8046 gimplify_one_sizepos (&TYPE_SIZE (type
), list_p
);
8047 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type
), list_p
);
8049 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8051 TYPE_SIZE (t
) = TYPE_SIZE (type
);
8052 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (type
);
8053 TYPE_SIZES_GIMPLIFIED (t
) = 1;
8057 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
8058 a size or position, has had all of its SAVE_EXPRs evaluated.
8059 We add any required statements to *STMT_P. */
8062 gimplify_one_sizepos (tree
*expr_p
, gimple_seq
*stmt_p
)
8064 tree type
, expr
= *expr_p
;
8066 /* We don't do anything if the value isn't there, is constant, or contains
8067 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
8068 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
8069 will want to replace it with a new variable, but that will cause problems
8070 if this type is from outside the function. It's OK to have that here. */
8071 if (expr
== NULL_TREE
|| TREE_CONSTANT (expr
)
8072 || TREE_CODE (expr
) == VAR_DECL
8073 || CONTAINS_PLACEHOLDER_P (expr
))
8076 type
= TREE_TYPE (expr
);
8077 *expr_p
= unshare_expr (expr
);
8079 gimplify_expr (expr_p
, stmt_p
, NULL
, is_gimple_val
, fb_rvalue
);
8082 /* Verify that we've an exact type match with the original expression.
8083 In particular, we do not wish to drop a "sizetype" in favour of a
8084 type of similar dimensions. We don't want to pollute the generic
8085 type-stripping code with this knowledge because it doesn't matter
8086 for the bulk of GENERIC/GIMPLE. It only matters that TYPE_SIZE_UNIT
8087 and friends retain their "sizetype-ness". */
8088 if (TREE_TYPE (expr
) != type
8089 && TREE_CODE (type
) == INTEGER_TYPE
8090 && TYPE_IS_SIZETYPE (type
))
8095 *expr_p
= create_tmp_var (type
, NULL
);
8096 tmp
= build1 (NOP_EXPR
, type
, expr
);
8097 stmt
= gimplify_assign (*expr_p
, tmp
, stmt_p
);
8098 gimple_set_location (stmt
, EXPR_LOC_OR_HERE (expr
));
8102 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
8103 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
8104 is true, also gimplify the parameters. */
8107 gimplify_body (tree fndecl
, bool do_parms
)
8109 location_t saved_location
= input_location
;
8110 gimple_seq parm_stmts
, seq
;
8112 struct gimplify_ctx gctx
;
8113 struct cgraph_node
*cgn
;
8115 timevar_push (TV_TREE_GIMPLIFY
);
8117 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
8119 default_rtl_profile ();
8121 gcc_assert (gimplify_ctxp
== NULL
);
8122 push_gimplify_context (&gctx
);
8124 /* Unshare most shared trees in the body and in that of any nested functions.
8125 It would seem we don't have to do this for nested functions because
8126 they are supposed to be output and then the outer function gimplified
8127 first, but the g++ front end doesn't always do it that way. */
8128 unshare_body (fndecl
);
8129 unvisit_body (fndecl
);
8131 cgn
= cgraph_get_node (fndecl
);
8132 if (cgn
&& cgn
->origin
)
8133 nonlocal_vlas
= pointer_set_create ();
8135 /* Make sure input_location isn't set to something weird. */
8136 input_location
= DECL_SOURCE_LOCATION (fndecl
);
8138 /* Resolve callee-copies. This has to be done before processing
8139 the body so that DECL_VALUE_EXPR gets processed correctly. */
8140 parm_stmts
= do_parms
? gimplify_parameters () : NULL
;
8142 /* Gimplify the function's body. */
8144 gimplify_stmt (&DECL_SAVED_TREE (fndecl
), &seq
);
8145 outer_bind
= gimple_seq_first_stmt (seq
);
8148 outer_bind
= gimple_build_nop ();
8149 gimplify_seq_add_stmt (&seq
, outer_bind
);
8152 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
8153 not the case, wrap everything in a GIMPLE_BIND to make it so. */
8154 if (gimple_code (outer_bind
) == GIMPLE_BIND
8155 && gimple_seq_first (seq
) == gimple_seq_last (seq
))
8158 outer_bind
= gimple_build_bind (NULL_TREE
, seq
, NULL
);
8160 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
8162 /* If we had callee-copies statements, insert them at the beginning
8163 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
8164 if (!gimple_seq_empty_p (parm_stmts
))
8168 gimplify_seq_add_seq (&parm_stmts
, gimple_bind_body (outer_bind
));
8169 gimple_bind_set_body (outer_bind
, parm_stmts
);
8171 for (parm
= DECL_ARGUMENTS (current_function_decl
);
8172 parm
; parm
= DECL_CHAIN (parm
))
8173 if (DECL_HAS_VALUE_EXPR_P (parm
))
8175 DECL_HAS_VALUE_EXPR_P (parm
) = 0;
8176 DECL_IGNORED_P (parm
) = 0;
8182 pointer_set_destroy (nonlocal_vlas
);
8183 nonlocal_vlas
= NULL
;
8186 pop_gimplify_context (outer_bind
);
8187 gcc_assert (gimplify_ctxp
== NULL
);
8190 verify_gimple_in_seq (gimple_bind_body (outer_bind
));
8192 timevar_pop (TV_TREE_GIMPLIFY
);
8193 input_location
= saved_location
;
8198 typedef char *char_p
; /* For DEF_VEC_P. */
8200 DEF_VEC_ALLOC_P(char_p
,heap
);
8202 /* Return whether we should exclude FNDECL from instrumentation. */
8205 flag_instrument_functions_exclude_p (tree fndecl
)
8207 VEC(char_p
,heap
) *vec
;
8209 vec
= (VEC(char_p
,heap
) *) flag_instrument_functions_exclude_functions
;
8210 if (VEC_length (char_p
, vec
) > 0)
8216 name
= lang_hooks
.decl_printable_name (fndecl
, 0);
8217 FOR_EACH_VEC_ELT (char_p
, vec
, i
, s
)
8218 if (strstr (name
, s
) != NULL
)
8222 vec
= (VEC(char_p
,heap
) *) flag_instrument_functions_exclude_files
;
8223 if (VEC_length (char_p
, vec
) > 0)
8229 name
= DECL_SOURCE_FILE (fndecl
);
8230 FOR_EACH_VEC_ELT (char_p
, vec
, i
, s
)
8231 if (strstr (name
, s
) != NULL
)
8238 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
8239 node for the function we want to gimplify.
8241 Return the sequence of GIMPLE statements corresponding to the body
8245 gimplify_function_tree (tree fndecl
)
8247 tree oldfn
, parm
, ret
;
8251 gcc_assert (!gimple_body (fndecl
));
8253 oldfn
= current_function_decl
;
8254 current_function_decl
= fndecl
;
8255 if (DECL_STRUCT_FUNCTION (fndecl
))
8256 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
8258 push_struct_function (fndecl
);
8260 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
8262 /* Preliminarily mark non-addressed complex variables as eligible
8263 for promotion to gimple registers. We'll transform their uses
8265 if ((TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
8266 || TREE_CODE (TREE_TYPE (parm
)) == VECTOR_TYPE
)
8267 && !TREE_THIS_VOLATILE (parm
)
8268 && !needs_to_live_in_memory (parm
))
8269 DECL_GIMPLE_REG_P (parm
) = 1;
8272 ret
= DECL_RESULT (fndecl
);
8273 if ((TREE_CODE (TREE_TYPE (ret
)) == COMPLEX_TYPE
8274 || TREE_CODE (TREE_TYPE (ret
)) == VECTOR_TYPE
)
8275 && !needs_to_live_in_memory (ret
))
8276 DECL_GIMPLE_REG_P (ret
) = 1;
8278 bind
= gimplify_body (fndecl
, true);
8280 /* The tree body of the function is no longer needed, replace it
8281 with the new GIMPLE body. */
8282 seq
= gimple_seq_alloc ();
8283 gimple_seq_add_stmt (&seq
, bind
);
8284 gimple_set_body (fndecl
, seq
);
8286 /* If we're instrumenting function entry/exit, then prepend the call to
8287 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
8288 catch the exit hook. */
8289 /* ??? Add some way to ignore exceptions for this TFE. */
8290 if (flag_instrument_function_entry_exit
8291 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
)
8292 && !flag_instrument_functions_exclude_p (fndecl
))
8297 gimple_seq cleanup
= NULL
, body
= NULL
;
8301 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
8302 call
= gimple_build_call (x
, 1, integer_zero_node
);
8303 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
8304 gimple_call_set_lhs (call
, tmp_var
);
8305 gimplify_seq_add_stmt (&cleanup
, call
);
8306 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT
);
8307 call
= gimple_build_call (x
, 2,
8308 build_fold_addr_expr (current_function_decl
),
8310 gimplify_seq_add_stmt (&cleanup
, call
);
8311 tf
= gimple_build_try (seq
, cleanup
, GIMPLE_TRY_FINALLY
);
8313 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
8314 call
= gimple_build_call (x
, 1, integer_zero_node
);
8315 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
8316 gimple_call_set_lhs (call
, tmp_var
);
8317 gimplify_seq_add_stmt (&body
, call
);
8318 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER
);
8319 call
= gimple_build_call (x
, 2,
8320 build_fold_addr_expr (current_function_decl
),
8322 gimplify_seq_add_stmt (&body
, call
);
8323 gimplify_seq_add_stmt (&body
, tf
);
8324 new_bind
= gimple_build_bind (NULL
, body
, gimple_bind_block (bind
));
8325 /* Clear the block for BIND, since it is no longer directly inside
8326 the function, but within a try block. */
8327 gimple_bind_set_block (bind
, NULL
);
8329 /* Replace the current function body with the body
8330 wrapped in the try/finally TF. */
8331 seq
= gimple_seq_alloc ();
8332 gimple_seq_add_stmt (&seq
, new_bind
);
8333 gimple_set_body (fndecl
, seq
);
8336 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
8337 cfun
->curr_properties
= PROP_gimple_any
;
8339 current_function_decl
= oldfn
;
8343 /* Some transformations like inlining may invalidate the GIMPLE form
8344 for operands. This function traverses all the operands in STMT and
8345 gimplifies anything that is not a valid gimple operand. Any new
8346 GIMPLE statements are inserted before *GSI_P. */
8349 gimple_regimplify_operands (gimple stmt
, gimple_stmt_iterator
*gsi_p
)
8352 tree orig_lhs
= NULL_TREE
, lhs
, t
;
8353 gimple_seq pre
= NULL
;
8354 gimple post_stmt
= NULL
;
8355 struct gimplify_ctx gctx
;
8357 push_gimplify_context (&gctx
);
8358 gimplify_ctxp
->into_ssa
= gimple_in_ssa_p (cfun
);
8360 switch (gimple_code (stmt
))
8363 gimplify_expr (gimple_cond_lhs_ptr (stmt
), &pre
, NULL
,
8364 is_gimple_val
, fb_rvalue
);
8365 gimplify_expr (gimple_cond_rhs_ptr (stmt
), &pre
, NULL
,
8366 is_gimple_val
, fb_rvalue
);
8369 gimplify_expr (gimple_switch_index_ptr (stmt
), &pre
, NULL
,
8370 is_gimple_val
, fb_rvalue
);
8372 case GIMPLE_OMP_ATOMIC_LOAD
:
8373 gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt
), &pre
, NULL
,
8374 is_gimple_val
, fb_rvalue
);
8378 size_t i
, noutputs
= gimple_asm_noutputs (stmt
);
8379 const char *constraint
, **oconstraints
;
8380 bool allows_mem
, allows_reg
, is_inout
;
8383 = (const char **) alloca ((noutputs
) * sizeof (const char *));
8384 for (i
= 0; i
< noutputs
; i
++)
8386 tree op
= gimple_asm_output_op (stmt
, i
);
8387 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op
)));
8388 oconstraints
[i
] = constraint
;
8389 parse_output_constraint (&constraint
, i
, 0, 0, &allows_mem
,
8390 &allows_reg
, &is_inout
);
8391 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8392 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
8393 fb_lvalue
| fb_mayfail
);
8395 for (i
= 0; i
< gimple_asm_ninputs (stmt
); i
++)
8397 tree op
= gimple_asm_input_op (stmt
, i
);
8398 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op
)));
8399 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
8400 oconstraints
, &allows_mem
, &allows_reg
);
8401 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op
))) && allows_mem
)
8403 if (!allows_reg
&& allows_mem
)
8404 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8405 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
8407 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8408 is_gimple_asm_val
, fb_rvalue
);
8413 /* NOTE: We start gimplifying operands from last to first to
8414 make sure that side-effects on the RHS of calls, assignments
8415 and ASMs are executed before the LHS. The ordering is not
8416 important for other statements. */
8417 num_ops
= gimple_num_ops (stmt
);
8418 orig_lhs
= gimple_get_lhs (stmt
);
8419 for (i
= num_ops
; i
> 0; i
--)
8421 tree op
= gimple_op (stmt
, i
- 1);
8422 if (op
== NULL_TREE
)
8424 if (i
== 1 && (is_gimple_call (stmt
) || is_gimple_assign (stmt
)))
8425 gimplify_expr (&op
, &pre
, NULL
, is_gimple_lvalue
, fb_lvalue
);
8427 && is_gimple_assign (stmt
)
8429 && get_gimple_rhs_class (gimple_expr_code (stmt
))
8430 == GIMPLE_SINGLE_RHS
)
8431 gimplify_expr (&op
, &pre
, NULL
,
8432 rhs_predicate_for (gimple_assign_lhs (stmt
)),
8434 else if (i
== 2 && is_gimple_call (stmt
))
8436 if (TREE_CODE (op
) == FUNCTION_DECL
)
8438 gimplify_expr (&op
, &pre
, NULL
, is_gimple_call_addr
, fb_rvalue
);
8441 gimplify_expr (&op
, &pre
, NULL
, is_gimple_val
, fb_rvalue
);
8442 gimple_set_op (stmt
, i
- 1, op
);
8445 lhs
= gimple_get_lhs (stmt
);
8446 /* If the LHS changed it in a way that requires a simple RHS,
8447 create temporary. */
8448 if (lhs
&& !is_gimple_reg (lhs
))
8450 bool need_temp
= false;
8452 if (is_gimple_assign (stmt
)
8454 && get_gimple_rhs_class (gimple_expr_code (stmt
))
8455 == GIMPLE_SINGLE_RHS
)
8456 gimplify_expr (gimple_assign_rhs1_ptr (stmt
), &pre
, NULL
,
8457 rhs_predicate_for (gimple_assign_lhs (stmt
)),
8459 else if (is_gimple_reg (lhs
))
8461 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
8463 if (is_gimple_call (stmt
))
8465 i
= gimple_call_flags (stmt
);
8466 if ((i
& ECF_LOOPING_CONST_OR_PURE
)
8467 || !(i
& (ECF_CONST
| ECF_PURE
)))
8470 if (stmt_can_throw_internal (stmt
))
8476 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
8478 else if (TYPE_MODE (TREE_TYPE (lhs
)) != BLKmode
)
8480 if (is_gimple_call (stmt
))
8482 tree fndecl
= gimple_call_fndecl (stmt
);
8484 if (!aggregate_value_p (TREE_TYPE (lhs
), fndecl
)
8485 && !(fndecl
&& DECL_RESULT (fndecl
)
8486 && DECL_BY_REFERENCE (DECL_RESULT (fndecl
))))
8495 tree temp
= create_tmp_reg (TREE_TYPE (lhs
), NULL
);
8497 if (TREE_CODE (orig_lhs
) == SSA_NAME
)
8498 orig_lhs
= SSA_NAME_VAR (orig_lhs
);
8500 if (gimple_in_ssa_p (cfun
))
8501 temp
= make_ssa_name (temp
, NULL
);
8502 gimple_set_lhs (stmt
, temp
);
8503 post_stmt
= gimple_build_assign (lhs
, temp
);
8504 if (TREE_CODE (lhs
) == SSA_NAME
)
8505 SSA_NAME_DEF_STMT (lhs
) = post_stmt
;
8511 if (gimple_referenced_vars (cfun
))
8512 for (t
= gimplify_ctxp
->temps
; t
; t
= TREE_CHAIN (t
))
8513 add_referenced_var (t
);
8515 if (!gimple_seq_empty_p (pre
))
8517 if (gimple_in_ssa_p (cfun
))
8519 gimple_stmt_iterator i
;
8521 for (i
= gsi_start (pre
); !gsi_end_p (i
); gsi_next (&i
))
8522 mark_symbols_for_renaming (gsi_stmt (i
));
8524 gsi_insert_seq_before (gsi_p
, pre
, GSI_SAME_STMT
);
8527 gsi_insert_after (gsi_p
, post_stmt
, GSI_NEW_STMT
);
8529 pop_gimplify_context (NULL
);
8532 /* Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
8533 the predicate that will hold for the result. If VAR is not NULL, make the
8534 base variable of the final destination be VAR if suitable. */
8537 force_gimple_operand_1 (tree expr
, gimple_seq
*stmts
,
8538 gimple_predicate gimple_test_f
, tree var
)
8541 enum gimplify_status ret
;
8542 struct gimplify_ctx gctx
;
8546 /* gimple_test_f might be more strict than is_gimple_val, make
8547 sure we pass both. Just checking gimple_test_f doesn't work
8548 because most gimple predicates do not work recursively. */
8549 if (is_gimple_val (expr
)
8550 && (*gimple_test_f
) (expr
))
8553 push_gimplify_context (&gctx
);
8554 gimplify_ctxp
->into_ssa
= gimple_in_ssa_p (cfun
);
8555 gimplify_ctxp
->allow_rhs_cond_expr
= true;
8558 expr
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, expr
);
8560 if (TREE_CODE (expr
) != MODIFY_EXPR
8561 && TREE_TYPE (expr
) == void_type_node
)
8563 gimplify_and_add (expr
, stmts
);
8568 ret
= gimplify_expr (&expr
, stmts
, NULL
, gimple_test_f
, fb_rvalue
);
8569 gcc_assert (ret
!= GS_ERROR
);
8572 if (gimple_referenced_vars (cfun
))
8573 for (t
= gimplify_ctxp
->temps
; t
; t
= DECL_CHAIN (t
))
8574 add_referenced_var (t
);
8576 pop_gimplify_context (NULL
);
8581 /* Expand EXPR to list of gimple statements STMTS. If SIMPLE is true,
8582 force the result to be either ssa_name or an invariant, otherwise
8583 just force it to be a rhs expression. If VAR is not NULL, make the
8584 base variable of the final destination be VAR if suitable. */
8587 force_gimple_operand (tree expr
, gimple_seq
*stmts
, bool simple
, tree var
)
8589 return force_gimple_operand_1 (expr
, stmts
,
8590 simple
? is_gimple_val
: is_gimple_reg_rhs
,
8594 /* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
8595 and VAR. If some statements are produced, emits them at GSI.
8596 If BEFORE is true. the statements are appended before GSI, otherwise
8597 they are appended after it. M specifies the way GSI moves after
8598 insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values). */
8601 force_gimple_operand_gsi_1 (gimple_stmt_iterator
*gsi
, tree expr
,
8602 gimple_predicate gimple_test_f
,
8603 tree var
, bool before
,
8604 enum gsi_iterator_update m
)
8608 expr
= force_gimple_operand_1 (expr
, &stmts
, gimple_test_f
, var
);
8610 if (!gimple_seq_empty_p (stmts
))
8612 if (gimple_in_ssa_p (cfun
))
8614 gimple_stmt_iterator i
;
8616 for (i
= gsi_start (stmts
); !gsi_end_p (i
); gsi_next (&i
))
8617 mark_symbols_for_renaming (gsi_stmt (i
));
8621 gsi_insert_seq_before (gsi
, stmts
, m
);
8623 gsi_insert_seq_after (gsi
, stmts
, m
);
8629 /* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
8630 If SIMPLE is true, force the result to be either ssa_name or an invariant,
8631 otherwise just force it to be a rhs expression. If some statements are
8632 produced, emits them at GSI. If BEFORE is true, the statements are
8633 appended before GSI, otherwise they are appended after it. M specifies
8634 the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
8635 are the usual values). */
8638 force_gimple_operand_gsi (gimple_stmt_iterator
*gsi
, tree expr
,
8639 bool simple_p
, tree var
, bool before
,
8640 enum gsi_iterator_update m
)
8642 return force_gimple_operand_gsi_1 (gsi
, expr
,
8644 ? is_gimple_val
: is_gimple_reg_rhs
,
8649 #include "gt-gimplify.h"