1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002-2013 Free Software Foundation, Inc.
4 Major work done by Sebastian Pop <s.pop@laposte.net>,
5 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
29 #include "tree-iterator.h"
30 #include "tree-inline.h"
31 #include "tree-pretty-print.h"
32 #include "langhooks.h"
33 #include "tree-flow.h"
40 #include "diagnostic-core.h"
42 #include "pointer-set.h"
43 #include "splay-tree.h"
47 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
48 #include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
50 enum gimplify_omp_var_data
56 GOVD_FIRSTPRIVATE
= 16,
57 GOVD_LASTPRIVATE
= 32,
60 GOVD_DEBUG_PRIVATE
= 256,
61 GOVD_PRIVATE_OUTER_REF
= 512,
62 GOVD_DATA_SHARE_CLASS
= (GOVD_SHARED
| GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
63 | GOVD_LASTPRIVATE
| GOVD_REDUCTION
| GOVD_LOCAL
)
71 ORT_COMBINED_PARALLEL
= 3,
76 struct gimplify_omp_ctx
78 struct gimplify_omp_ctx
*outer_context
;
80 struct pointer_set_t
*privatized_types
;
82 enum omp_clause_default_kind default_kind
;
83 enum omp_region_type region_type
;
86 static struct gimplify_ctx
*gimplify_ctxp
;
87 static struct gimplify_omp_ctx
*gimplify_omp_ctxp
;
90 /* Forward declaration. */
91 static enum gimplify_status
gimplify_compound_expr (tree
*, gimple_seq
*, bool);
93 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
94 form and we don't do any syntax checking. */
97 mark_addressable (tree x
)
99 while (handled_component_p (x
))
100 x
= TREE_OPERAND (x
, 0);
101 if (TREE_CODE (x
) == MEM_REF
102 && TREE_CODE (TREE_OPERAND (x
, 0)) == ADDR_EXPR
)
103 x
= TREE_OPERAND (TREE_OPERAND (x
, 0), 0);
104 if (TREE_CODE (x
) != VAR_DECL
105 && TREE_CODE (x
) != PARM_DECL
106 && TREE_CODE (x
) != RESULT_DECL
)
108 TREE_ADDRESSABLE (x
) = 1;
110 /* Also mark the artificial SSA_NAME that points to the partition of X. */
111 if (TREE_CODE (x
) == VAR_DECL
112 && !DECL_EXTERNAL (x
)
114 && cfun
->gimple_df
!= NULL
115 && cfun
->gimple_df
->decls_to_pointers
!= NULL
)
118 = pointer_map_contains (cfun
->gimple_df
->decls_to_pointers
, x
);
120 TREE_ADDRESSABLE (*(tree
*)namep
) = 1;
124 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
125 *SEQ_P is NULL, a new sequence is allocated. This function is
126 similar to gimple_seq_add_stmt, but does not scan the operands.
127 During gimplification, we need to manipulate statement sequences
128 before the def/use vectors have been constructed. */
131 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
133 gimple_stmt_iterator si
;
138 si
= gsi_last (*seq_p
);
139 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
142 /* Shorter alias name for the above function for use in gimplify.c
146 gimplify_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
148 gimple_seq_add_stmt_without_update (seq_p
, gs
);
151 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
152 NULL, a new sequence is allocated. This function is
153 similar to gimple_seq_add_seq, but does not scan the operands.
154 During gimplification, we need to manipulate statement sequences
155 before the def/use vectors have been constructed. */
158 gimplify_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
160 gimple_stmt_iterator si
;
165 si
= gsi_last (*dst_p
);
166 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
169 /* Set up a context for the gimplifier. */
172 push_gimplify_context (struct gimplify_ctx
*c
)
174 memset (c
, '\0', sizeof (*c
));
175 c
->prev_context
= gimplify_ctxp
;
179 /* Tear down a context for the gimplifier. If BODY is non-null, then
180 put the temporaries into the outer BIND_EXPR. Otherwise, put them
183 BODY is not a sequence, but the first tuple in a sequence. */
186 pop_gimplify_context (gimple body
)
188 struct gimplify_ctx
*c
= gimplify_ctxp
;
191 && (!c
->bind_expr_stack
.exists ()
192 || c
->bind_expr_stack
.is_empty ()));
193 c
->bind_expr_stack
.release ();
194 gimplify_ctxp
= c
->prev_context
;
197 declare_vars (c
->temps
, body
, false);
199 record_vars (c
->temps
);
201 if (c
->temp_htab
.is_created ())
202 c
->temp_htab
.dispose ();
205 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
208 gimple_push_bind_expr (gimple gimple_bind
)
210 gimplify_ctxp
->bind_expr_stack
.reserve (8);
211 gimplify_ctxp
->bind_expr_stack
.safe_push (gimple_bind
);
214 /* Pop the first element off the stack of bindings. */
217 gimple_pop_bind_expr (void)
219 gimplify_ctxp
->bind_expr_stack
.pop ();
222 /* Return the first element of the stack of bindings. */
225 gimple_current_bind_expr (void)
227 return gimplify_ctxp
->bind_expr_stack
.last ();
230 /* Return the stack of bindings created during gimplification. */
233 gimple_bind_expr_stack (void)
235 return gimplify_ctxp
->bind_expr_stack
;
238 /* Return true iff there is a COND_EXPR between us and the innermost
239 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
242 gimple_conditional_context (void)
244 return gimplify_ctxp
->conditions
> 0;
247 /* Note that we've entered a COND_EXPR. */
250 gimple_push_condition (void)
252 #ifdef ENABLE_GIMPLE_CHECKING
253 if (gimplify_ctxp
->conditions
== 0)
254 gcc_assert (gimple_seq_empty_p (gimplify_ctxp
->conditional_cleanups
));
256 ++(gimplify_ctxp
->conditions
);
259 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
260 now, add any conditional cleanups we've seen to the prequeue. */
263 gimple_pop_condition (gimple_seq
*pre_p
)
265 int conds
= --(gimplify_ctxp
->conditions
);
267 gcc_assert (conds
>= 0);
270 gimplify_seq_add_seq (pre_p
, gimplify_ctxp
->conditional_cleanups
);
271 gimplify_ctxp
->conditional_cleanups
= NULL
;
275 /* A stable comparison routine for use with splay trees and DECLs. */
278 splay_tree_compare_decl_uid (splay_tree_key xa
, splay_tree_key xb
)
283 return DECL_UID (a
) - DECL_UID (b
);
286 /* Create a new omp construct that deals with variable remapping. */
288 static struct gimplify_omp_ctx
*
289 new_omp_context (enum omp_region_type region_type
)
291 struct gimplify_omp_ctx
*c
;
293 c
= XCNEW (struct gimplify_omp_ctx
);
294 c
->outer_context
= gimplify_omp_ctxp
;
295 c
->variables
= splay_tree_new (splay_tree_compare_decl_uid
, 0, 0);
296 c
->privatized_types
= pointer_set_create ();
297 c
->location
= input_location
;
298 c
->region_type
= region_type
;
299 if ((region_type
& ORT_TASK
) == 0)
300 c
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
302 c
->default_kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
307 /* Destroy an omp construct that deals with variable remapping. */
310 delete_omp_context (struct gimplify_omp_ctx
*c
)
312 splay_tree_delete (c
->variables
);
313 pointer_set_destroy (c
->privatized_types
);
317 static void omp_add_variable (struct gimplify_omp_ctx
*, tree
, unsigned int);
318 static bool omp_notice_variable (struct gimplify_omp_ctx
*, tree
, bool);
320 /* Both gimplify the statement T and append it to *SEQ_P. This function
321 behaves exactly as gimplify_stmt, but you don't have to pass T as a
325 gimplify_and_add (tree t
, gimple_seq
*seq_p
)
327 gimplify_stmt (&t
, seq_p
);
330 /* Gimplify statement T into sequence *SEQ_P, and return the first
331 tuple in the sequence of generated tuples for this statement.
332 Return NULL if gimplifying T produced no tuples. */
335 gimplify_and_return_first (tree t
, gimple_seq
*seq_p
)
337 gimple_stmt_iterator last
= gsi_last (*seq_p
);
339 gimplify_and_add (t
, seq_p
);
341 if (!gsi_end_p (last
))
344 return gsi_stmt (last
);
347 return gimple_seq_first_stmt (*seq_p
);
350 /* Strip off a legitimate source ending from the input string NAME of
351 length LEN. Rather than having to know the names used by all of
352 our front ends, we strip off an ending of a period followed by
353 up to five characters. (Java uses ".class".) */
356 remove_suffix (char *name
, int len
)
360 for (i
= 2; i
< 8 && len
> i
; i
++)
362 if (name
[len
- i
] == '.')
364 name
[len
- i
] = '\0';
370 /* Create a new temporary name with PREFIX. Return an identifier. */
372 static GTY(()) unsigned int tmp_var_id_num
;
375 create_tmp_var_name (const char *prefix
)
381 char *preftmp
= ASTRDUP (prefix
);
383 remove_suffix (preftmp
, strlen (preftmp
));
384 clean_symbol_name (preftmp
);
389 ASM_FORMAT_PRIVATE_NAME (tmp_name
, prefix
? prefix
: "T", tmp_var_id_num
++);
390 return get_identifier (tmp_name
);
393 /* Create a new temporary variable declaration of type TYPE.
394 Do NOT push it into the current binding. */
397 create_tmp_var_raw (tree type
, const char *prefix
)
401 tmp_var
= build_decl (input_location
,
402 VAR_DECL
, prefix
? create_tmp_var_name (prefix
) : NULL
,
405 /* The variable was declared by the compiler. */
406 DECL_ARTIFICIAL (tmp_var
) = 1;
407 /* And we don't want debug info for it. */
408 DECL_IGNORED_P (tmp_var
) = 1;
410 /* Make the variable writable. */
411 TREE_READONLY (tmp_var
) = 0;
413 DECL_EXTERNAL (tmp_var
) = 0;
414 TREE_STATIC (tmp_var
) = 0;
415 TREE_USED (tmp_var
) = 1;
420 /* Create a new temporary variable declaration of type TYPE. DO push the
421 variable into the current binding. Further, assume that this is called
422 only from gimplification or optimization, at which point the creation of
423 certain types are bugs. */
426 create_tmp_var (tree type
, const char *prefix
)
430 /* We don't allow types that are addressable (meaning we can't make copies),
431 or incomplete. We also used to reject every variable size objects here,
432 but now support those for which a constant upper bound can be obtained.
433 The processing for variable sizes is performed in gimple_add_tmp_var,
434 point at which it really matters and possibly reached via paths not going
435 through this function, e.g. after direct calls to create_tmp_var_raw. */
436 gcc_assert (!TREE_ADDRESSABLE (type
) && COMPLETE_TYPE_P (type
));
438 tmp_var
= create_tmp_var_raw (type
, prefix
);
439 gimple_add_tmp_var (tmp_var
);
443 /* Create a new temporary variable declaration of type TYPE by calling
444 create_tmp_var and if TYPE is a vector or a complex number, mark the new
445 temporary as gimple register. */
448 create_tmp_reg (tree type
, const char *prefix
)
452 tmp
= create_tmp_var (type
, prefix
);
453 if (TREE_CODE (type
) == COMPLEX_TYPE
454 || TREE_CODE (type
) == VECTOR_TYPE
)
455 DECL_GIMPLE_REG_P (tmp
) = 1;
460 /* Returns true iff T is a valid RHS for an assignment to a renamed
461 user -- or front-end generated artificial -- variable. */
464 is_gimple_reg_rhs (tree t
)
466 return get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
;
469 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
470 LHS, or for a call argument. */
473 is_gimple_mem_rhs (tree t
)
475 /* If we're dealing with a renamable type, either source or dest must be
476 a renamed variable. */
477 if (is_gimple_reg_type (TREE_TYPE (t
)))
478 return is_gimple_val (t
);
480 return is_gimple_val (t
) || is_gimple_lvalue (t
);
483 /* Return true if T is a CALL_EXPR or an expression that can be
484 assigned to a temporary. Note that this predicate should only be
485 used during gimplification. See the rationale for this in
486 gimplify_modify_expr. */
489 is_gimple_reg_rhs_or_call (tree t
)
491 return (get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
492 || TREE_CODE (t
) == CALL_EXPR
);
495 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
496 this predicate should only be used during gimplification. See the
497 rationale for this in gimplify_modify_expr. */
500 is_gimple_mem_rhs_or_call (tree t
)
502 /* If we're dealing with a renamable type, either source or dest must be
503 a renamed variable. */
504 if (is_gimple_reg_type (TREE_TYPE (t
)))
505 return is_gimple_val (t
);
507 return (is_gimple_val (t
) || is_gimple_lvalue (t
)
508 || TREE_CODE (t
) == CALL_EXPR
);
511 /* Create a temporary with a name derived from VAL. Subroutine of
512 lookup_tmp_var; nobody else should call this function. */
515 create_tmp_from_val (tree val
, bool is_formal
)
517 /* Drop all qualifiers and address-space information from the value type. */
518 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (val
));
519 tree var
= create_tmp_var (type
, get_name (val
));
521 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
522 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
))
523 DECL_GIMPLE_REG_P (var
) = 1;
527 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
528 an existing expression temporary. */
531 lookup_tmp_var (tree val
, bool is_formal
)
535 /* If not optimizing, never really reuse a temporary. local-alloc
536 won't allocate any variable that is used in more than one basic
537 block, which means it will go into memory, causing much extra
538 work in reload and final and poorer code generation, outweighing
539 the extra memory allocation here. */
540 if (!optimize
|| !is_formal
|| TREE_SIDE_EFFECTS (val
))
541 ret
= create_tmp_from_val (val
, is_formal
);
548 if (!gimplify_ctxp
->temp_htab
.is_created ())
549 gimplify_ctxp
->temp_htab
.create (1000);
550 slot
= gimplify_ctxp
->temp_htab
.find_slot (&elt
, INSERT
);
553 elt_p
= XNEW (elt_t
);
555 elt_p
->temp
= ret
= create_tmp_from_val (val
, is_formal
);
568 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
571 internal_get_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
576 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
577 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
578 gimplify_expr (&val
, pre_p
, post_p
, is_gimple_reg_rhs_or_call
,
581 if (gimplify_ctxp
->into_ssa
582 && is_gimple_reg_type (TREE_TYPE (val
)))
583 t
= make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val
)), NULL
);
585 t
= lookup_tmp_var (val
, is_formal
);
587 mod
= build2 (INIT_EXPR
, TREE_TYPE (t
), t
, unshare_expr (val
));
589 SET_EXPR_LOCATION (mod
, EXPR_LOC_OR_HERE (val
));
591 /* gimplify_modify_expr might want to reduce this further. */
592 gimplify_and_add (mod
, pre_p
);
598 /* Return a formal temporary variable initialized with VAL. PRE_P is as
599 in gimplify_expr. Only use this function if:
601 1) The value of the unfactored expression represented by VAL will not
602 change between the initialization and use of the temporary, and
603 2) The temporary will not be otherwise modified.
605 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
606 and #2 means it is inappropriate for && temps.
608 For other cases, use get_initialized_tmp_var instead. */
611 get_formal_tmp_var (tree val
, gimple_seq
*pre_p
)
613 return internal_get_tmp_var (val
, pre_p
, NULL
, true);
616 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
617 are as in gimplify_expr. */
620 get_initialized_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
622 return internal_get_tmp_var (val
, pre_p
, post_p
, false);
625 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
626 generate debug info for them; otherwise don't. */
629 declare_vars (tree vars
, gimple scope
, bool debug_info
)
636 gcc_assert (gimple_code (scope
) == GIMPLE_BIND
);
638 temps
= nreverse (last
);
640 block
= gimple_bind_block (scope
);
641 gcc_assert (!block
|| TREE_CODE (block
) == BLOCK
);
642 if (!block
|| !debug_info
)
644 DECL_CHAIN (last
) = gimple_bind_vars (scope
);
645 gimple_bind_set_vars (scope
, temps
);
649 /* We need to attach the nodes both to the BIND_EXPR and to its
650 associated BLOCK for debugging purposes. The key point here
651 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
652 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
653 if (BLOCK_VARS (block
))
654 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), temps
);
657 gimple_bind_set_vars (scope
,
658 chainon (gimple_bind_vars (scope
), temps
));
659 BLOCK_VARS (block
) = temps
;
665 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
666 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
667 no such upper bound can be obtained. */
670 force_constant_size (tree var
)
672 /* The only attempt we make is by querying the maximum size of objects
673 of the variable's type. */
675 HOST_WIDE_INT max_size
;
677 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
679 max_size
= max_int_size_in_bytes (TREE_TYPE (var
));
681 gcc_assert (max_size
>= 0);
684 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var
)), max_size
);
686 = build_int_cst (TREE_TYPE (DECL_SIZE (var
)), max_size
* BITS_PER_UNIT
);
689 /* Push the temporary variable TMP into the current binding. */
692 gimple_add_tmp_var (tree tmp
)
694 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
696 /* Later processing assumes that the object size is constant, which might
697 not be true at this point. Force the use of a constant upper bound in
699 if (!host_integerp (DECL_SIZE_UNIT (tmp
), 1))
700 force_constant_size (tmp
);
702 DECL_CONTEXT (tmp
) = current_function_decl
;
703 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
707 DECL_CHAIN (tmp
) = gimplify_ctxp
->temps
;
708 gimplify_ctxp
->temps
= tmp
;
710 /* Mark temporaries local within the nearest enclosing parallel. */
711 if (gimplify_omp_ctxp
)
713 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
714 while (ctx
&& ctx
->region_type
== ORT_WORKSHARE
)
715 ctx
= ctx
->outer_context
;
717 omp_add_variable (ctx
, tmp
, GOVD_LOCAL
| GOVD_SEEN
);
726 /* This case is for nested functions. We need to expose the locals
728 body_seq
= gimple_body (current_function_decl
);
729 declare_vars (tmp
, gimple_seq_first_stmt (body_seq
), false);
733 /* Determine whether to assign a location to the statement GS. */
736 should_carry_location_p (gimple gs
)
738 /* Don't emit a line note for a label. We particularly don't want to
739 emit one for the break label, since it doesn't actually correspond
740 to the beginning of the loop/switch. */
741 if (gimple_code (gs
) == GIMPLE_LABEL
)
747 /* Return true if a location should not be emitted for this statement
748 by annotate_one_with_location. */
751 gimple_do_not_emit_location_p (gimple g
)
753 return gimple_plf (g
, GF_PLF_1
);
756 /* Mark statement G so a location will not be emitted by
757 annotate_one_with_location. */
760 gimple_set_do_not_emit_location (gimple g
)
762 /* The PLF flags are initialized to 0 when a new tuple is created,
763 so no need to initialize it anywhere. */
764 gimple_set_plf (g
, GF_PLF_1
, true);
767 /* Set the location for gimple statement GS to LOCATION. */
770 annotate_one_with_location (gimple gs
, location_t location
)
772 if (!gimple_has_location (gs
)
773 && !gimple_do_not_emit_location_p (gs
)
774 && should_carry_location_p (gs
))
775 gimple_set_location (gs
, location
);
778 /* Set LOCATION for all the statements after iterator GSI in sequence
779 SEQ. If GSI is pointing to the end of the sequence, start with the
780 first statement in SEQ. */
783 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
787 gsi
= gsi_start (seq
);
791 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
792 annotate_one_with_location (gsi_stmt (gsi
), location
);
795 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
798 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
800 gimple_stmt_iterator i
;
802 if (gimple_seq_empty_p (stmt_p
))
805 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
807 gimple gs
= gsi_stmt (i
);
808 annotate_one_with_location (gs
, location
);
812 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
813 nodes that are referenced more than once in GENERIC functions. This is
814 necessary because gimplification (translation into GIMPLE) is performed
815 by modifying tree nodes in-place, so gimplication of a shared node in a
816 first context could generate an invalid GIMPLE form in a second context.
818 This is achieved with a simple mark/copy/unmark algorithm that walks the
819 GENERIC representation top-down, marks nodes with TREE_VISITED the first
820 time it encounters them, duplicates them if they already have TREE_VISITED
821 set, and finally removes the TREE_VISITED marks it has set.
823 The algorithm works only at the function level, i.e. it generates a GENERIC
824 representation of a function with no nodes shared within the function when
825 passed a GENERIC function (except for nodes that are allowed to be shared).
827 At the global level, it is also necessary to unshare tree nodes that are
828 referenced in more than one function, for the same aforementioned reason.
829 This requires some cooperation from the front-end. There are 2 strategies:
831 1. Manual unsharing. The front-end needs to call unshare_expr on every
832 expression that might end up being shared across functions.
834 2. Deep unsharing. This is an extension of regular unsharing. Instead
835 of calling unshare_expr on expressions that might be shared across
836 functions, the front-end pre-marks them with TREE_VISITED. This will
837 ensure that they are unshared on the first reference within functions
838 when the regular unsharing algorithm runs. The counterpart is that
839 this algorithm must look deeper than for manual unsharing, which is
840 specified by LANG_HOOKS_DEEP_UNSHARING.
842 If there are only few specific cases of node sharing across functions, it is
843 probably easier for a front-end to unshare the expressions manually. On the
844 contrary, if the expressions generated at the global level are as widespread
845 as expressions generated within functions, deep unsharing is very likely the
848 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
849 These nodes model computations that must be done once. If we were to
850 unshare something like SAVE_EXPR(i++), the gimplification process would
851 create wrong code. However, if DATA is non-null, it must hold a pointer
852 set that is used to unshare the subtrees of these nodes. */
855 mostly_copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
858 enum tree_code code
= TREE_CODE (t
);
860 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
861 copy their subtrees if we can make sure to do it only once. */
862 if (code
== SAVE_EXPR
|| code
== TARGET_EXPR
|| code
== BIND_EXPR
)
864 if (data
&& !pointer_set_insert ((struct pointer_set_t
*)data
, t
))
870 /* Stop at types, decls, constants like copy_tree_r. */
871 else if (TREE_CODE_CLASS (code
) == tcc_type
872 || TREE_CODE_CLASS (code
) == tcc_declaration
873 || TREE_CODE_CLASS (code
) == tcc_constant
874 /* We can't do anything sensible with a BLOCK used as an
875 expression, but we also can't just die when we see it
876 because of non-expression uses. So we avert our eyes
877 and cross our fingers. Silly Java. */
881 /* Cope with the statement expression extension. */
882 else if (code
== STATEMENT_LIST
)
885 /* Leave the bulk of the work to copy_tree_r itself. */
887 copy_tree_r (tp
, walk_subtrees
, NULL
);
892 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
893 If *TP has been visited already, then *TP is deeply copied by calling
894 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
897 copy_if_shared_r (tree
*tp
, int *walk_subtrees
, void *data
)
900 enum tree_code code
= TREE_CODE (t
);
902 /* Skip types, decls, and constants. But we do want to look at their
903 types and the bounds of types. Mark them as visited so we properly
904 unmark their subtrees on the unmark pass. If we've already seen them,
905 don't look down further. */
906 if (TREE_CODE_CLASS (code
) == tcc_type
907 || TREE_CODE_CLASS (code
) == tcc_declaration
908 || TREE_CODE_CLASS (code
) == tcc_constant
)
910 if (TREE_VISITED (t
))
913 TREE_VISITED (t
) = 1;
916 /* If this node has been visited already, unshare it and don't look
918 else if (TREE_VISITED (t
))
920 walk_tree (tp
, mostly_copy_tree_r
, data
, NULL
);
924 /* Otherwise, mark the node as visited and keep looking. */
926 TREE_VISITED (t
) = 1;
931 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
932 copy_if_shared_r callback unmodified. */
935 copy_if_shared (tree
*tp
, void *data
)
937 walk_tree (tp
, copy_if_shared_r
, data
, NULL
);
940 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
941 any nested functions. */
944 unshare_body (tree fndecl
)
946 struct cgraph_node
*cgn
= cgraph_get_node (fndecl
);
947 /* If the language requires deep unsharing, we need a pointer set to make
948 sure we don't repeatedly unshare subtrees of unshareable nodes. */
949 struct pointer_set_t
*visited
950 = lang_hooks
.deep_unsharing
? pointer_set_create () : NULL
;
952 copy_if_shared (&DECL_SAVED_TREE (fndecl
), visited
);
953 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl
)), visited
);
954 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)), visited
);
957 pointer_set_destroy (visited
);
960 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
961 unshare_body (cgn
->symbol
.decl
);
964 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
965 Subtrees are walked until the first unvisited node is encountered. */
968 unmark_visited_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
972 /* If this node has been visited, unmark it and keep looking. */
973 if (TREE_VISITED (t
))
974 TREE_VISITED (t
) = 0;
976 /* Otherwise, don't look any deeper. */
983 /* Unmark the visited trees rooted at *TP. */
986 unmark_visited (tree
*tp
)
988 walk_tree (tp
, unmark_visited_r
, NULL
, NULL
);
991 /* Likewise, but mark all trees as not visited. */
994 unvisit_body (tree fndecl
)
996 struct cgraph_node
*cgn
= cgraph_get_node (fndecl
);
998 unmark_visited (&DECL_SAVED_TREE (fndecl
));
999 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl
)));
1000 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)));
1003 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
1004 unvisit_body (cgn
->symbol
.decl
);
1007 /* Unconditionally make an unshared copy of EXPR. This is used when using
1008 stored expressions which span multiple functions, such as BINFO_VTABLE,
1009 as the normal unsharing process can't tell that they're shared. */
1012 unshare_expr (tree expr
)
1014 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
1018 /* Worker for unshare_expr_without_location. */
1021 prune_expr_location (tree
*tp
, int *walk_subtrees
, void *)
1024 SET_EXPR_LOCATION (*tp
, UNKNOWN_LOCATION
);
1030 /* Similar to unshare_expr but also prune all expression locations
1034 unshare_expr_without_location (tree expr
)
1036 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
1038 walk_tree (&expr
, prune_expr_location
, NULL
, NULL
);
1042 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1043 contain statements and have a value. Assign its value to a temporary
1044 and give it void_type_node. Return the temporary, or NULL_TREE if
1045 WRAPPER was already void. */
1048 voidify_wrapper_expr (tree wrapper
, tree temp
)
1050 tree type
= TREE_TYPE (wrapper
);
1051 if (type
&& !VOID_TYPE_P (type
))
1055 /* Set p to point to the body of the wrapper. Loop until we find
1056 something that isn't a wrapper. */
1057 for (p
= &wrapper
; p
&& *p
; )
1059 switch (TREE_CODE (*p
))
1062 TREE_SIDE_EFFECTS (*p
) = 1;
1063 TREE_TYPE (*p
) = void_type_node
;
1064 /* For a BIND_EXPR, the body is operand 1. */
1065 p
= &BIND_EXPR_BODY (*p
);
1068 case CLEANUP_POINT_EXPR
:
1069 case TRY_FINALLY_EXPR
:
1070 case TRY_CATCH_EXPR
:
1071 TREE_SIDE_EFFECTS (*p
) = 1;
1072 TREE_TYPE (*p
) = void_type_node
;
1073 p
= &TREE_OPERAND (*p
, 0);
1076 case STATEMENT_LIST
:
1078 tree_stmt_iterator i
= tsi_last (*p
);
1079 TREE_SIDE_EFFECTS (*p
) = 1;
1080 TREE_TYPE (*p
) = void_type_node
;
1081 p
= tsi_end_p (i
) ? NULL
: tsi_stmt_ptr (i
);
1086 /* Advance to the last statement. Set all container types to
1088 for (; TREE_CODE (*p
) == COMPOUND_EXPR
; p
= &TREE_OPERAND (*p
, 1))
1090 TREE_SIDE_EFFECTS (*p
) = 1;
1091 TREE_TYPE (*p
) = void_type_node
;
1095 case TRANSACTION_EXPR
:
1096 TREE_SIDE_EFFECTS (*p
) = 1;
1097 TREE_TYPE (*p
) = void_type_node
;
1098 p
= &TRANSACTION_EXPR_BODY (*p
);
1102 /* Assume that any tree upon which voidify_wrapper_expr is
1103 directly called is a wrapper, and that its body is op0. */
1106 TREE_SIDE_EFFECTS (*p
) = 1;
1107 TREE_TYPE (*p
) = void_type_node
;
1108 p
= &TREE_OPERAND (*p
, 0);
1116 if (p
== NULL
|| IS_EMPTY_STMT (*p
))
1120 /* The wrapper is on the RHS of an assignment that we're pushing
1122 gcc_assert (TREE_CODE (temp
) == INIT_EXPR
1123 || TREE_CODE (temp
) == MODIFY_EXPR
);
1124 TREE_OPERAND (temp
, 1) = *p
;
1129 temp
= create_tmp_var (type
, "retval");
1130 *p
= build2 (INIT_EXPR
, type
, temp
, *p
);
1139 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1140 a temporary through which they communicate. */
1143 build_stack_save_restore (gimple
*save
, gimple
*restore
)
1147 *save
= gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE
), 0);
1148 tmp_var
= create_tmp_var (ptr_type_node
, "saved_stack");
1149 gimple_call_set_lhs (*save
, tmp_var
);
1152 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE
),
1156 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1158 static enum gimplify_status
1159 gimplify_bind_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1161 tree bind_expr
= *expr_p
;
1162 bool old_save_stack
= gimplify_ctxp
->save_stack
;
1165 gimple_seq body
, cleanup
;
1168 tree temp
= voidify_wrapper_expr (bind_expr
, NULL
);
1170 /* Mark variables seen in this bind expr. */
1171 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1173 if (TREE_CODE (t
) == VAR_DECL
)
1175 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1177 /* Mark variable as local. */
1178 if (ctx
&& !DECL_EXTERNAL (t
)
1179 && (! DECL_SEEN_IN_BIND_EXPR_P (t
)
1180 || splay_tree_lookup (ctx
->variables
,
1181 (splay_tree_key
) t
) == NULL
))
1182 omp_add_variable (gimplify_omp_ctxp
, t
, GOVD_LOCAL
| GOVD_SEEN
);
1184 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
1186 if (DECL_HARD_REGISTER (t
) && !is_global_var (t
) && cfun
)
1187 cfun
->has_local_explicit_reg_vars
= true;
1190 /* Preliminarily mark non-addressed complex variables as eligible
1191 for promotion to gimple registers. We'll transform their uses
1193 if ((TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
1194 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1195 && !TREE_THIS_VOLATILE (t
)
1196 && (TREE_CODE (t
) == VAR_DECL
&& !DECL_HARD_REGISTER (t
))
1197 && !needs_to_live_in_memory (t
))
1198 DECL_GIMPLE_REG_P (t
) = 1;
1201 gimple_bind
= gimple_build_bind (BIND_EXPR_VARS (bind_expr
), NULL
,
1202 BIND_EXPR_BLOCK (bind_expr
));
1203 gimple_push_bind_expr (gimple_bind
);
1205 gimplify_ctxp
->save_stack
= false;
1207 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1209 gimplify_stmt (&BIND_EXPR_BODY (bind_expr
), &body
);
1210 gimple_bind_set_body (gimple_bind
, body
);
1214 if (gimplify_ctxp
->save_stack
)
1216 gimple stack_restore
;
1218 /* Save stack on entry and restore it on exit. Add a try_finally
1219 block to achieve this. Note that mudflap depends on the
1220 format of the emitted code: see mx_register_decls(). */
1221 build_stack_save_restore (&stack_save
, &stack_restore
);
1223 gimplify_seq_add_stmt (&cleanup
, stack_restore
);
1226 /* Add clobbers for all variables that go out of scope. */
1227 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1229 if (TREE_CODE (t
) == VAR_DECL
1230 && !is_global_var (t
)
1231 && DECL_CONTEXT (t
) == current_function_decl
1232 && !DECL_HARD_REGISTER (t
)
1233 && !TREE_THIS_VOLATILE (t
)
1234 && !DECL_HAS_VALUE_EXPR_P (t
)
1235 /* Only care for variables that have to be in memory. Others
1236 will be rewritten into SSA names, hence moved to the top-level. */
1237 && !is_gimple_reg (t
)
1238 && flag_stack_reuse
!= SR_NONE
)
1240 tree clobber
= build_constructor (TREE_TYPE (t
),
1242 TREE_THIS_VOLATILE (clobber
) = 1;
1243 gimplify_seq_add_stmt (&cleanup
, gimple_build_assign (t
, clobber
));
1250 gimple_seq new_body
;
1253 gs
= gimple_build_try (gimple_bind_body (gimple_bind
), cleanup
,
1254 GIMPLE_TRY_FINALLY
);
1257 gimplify_seq_add_stmt (&new_body
, stack_save
);
1258 gimplify_seq_add_stmt (&new_body
, gs
);
1259 gimple_bind_set_body (gimple_bind
, new_body
);
1262 gimplify_ctxp
->save_stack
= old_save_stack
;
1263 gimple_pop_bind_expr ();
1265 gimplify_seq_add_stmt (pre_p
, gimple_bind
);
1273 *expr_p
= NULL_TREE
;
1277 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1278 GIMPLE value, it is assigned to a new temporary and the statement is
1279 re-written to return the temporary.
1281 PRE_P points to the sequence where side effects that must happen before
1282 STMT should be stored. */
1284 static enum gimplify_status
1285 gimplify_return_expr (tree stmt
, gimple_seq
*pre_p
)
1288 tree ret_expr
= TREE_OPERAND (stmt
, 0);
1289 tree result_decl
, result
;
1291 if (ret_expr
== error_mark_node
)
1295 || TREE_CODE (ret_expr
) == RESULT_DECL
1296 || ret_expr
== error_mark_node
)
1298 gimple ret
= gimple_build_return (ret_expr
);
1299 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1300 gimplify_seq_add_stmt (pre_p
, ret
);
1304 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1305 result_decl
= NULL_TREE
;
1308 result_decl
= TREE_OPERAND (ret_expr
, 0);
1310 /* See through a return by reference. */
1311 if (TREE_CODE (result_decl
) == INDIRECT_REF
)
1312 result_decl
= TREE_OPERAND (result_decl
, 0);
1314 gcc_assert ((TREE_CODE (ret_expr
) == MODIFY_EXPR
1315 || TREE_CODE (ret_expr
) == INIT_EXPR
)
1316 && TREE_CODE (result_decl
) == RESULT_DECL
);
1319 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1320 Recall that aggregate_value_p is FALSE for any aggregate type that is
1321 returned in registers. If we're returning values in registers, then
1322 we don't want to extend the lifetime of the RESULT_DECL, particularly
1323 across another call. In addition, for those aggregates for which
1324 hard_function_value generates a PARALLEL, we'll die during normal
1325 expansion of structure assignments; there's special code in expand_return
1326 to handle this case that does not exist in expand_expr. */
1329 else if (aggregate_value_p (result_decl
, TREE_TYPE (current_function_decl
)))
1331 if (TREE_CODE (DECL_SIZE (result_decl
)) != INTEGER_CST
)
1333 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl
)))
1334 gimplify_type_sizes (TREE_TYPE (result_decl
), pre_p
);
1335 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1336 should be effectively allocated by the caller, i.e. all calls to
1337 this function must be subject to the Return Slot Optimization. */
1338 gimplify_one_sizepos (&DECL_SIZE (result_decl
), pre_p
);
1339 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl
), pre_p
);
1341 result
= result_decl
;
1343 else if (gimplify_ctxp
->return_temp
)
1344 result
= gimplify_ctxp
->return_temp
;
1347 result
= create_tmp_reg (TREE_TYPE (result_decl
), NULL
);
1349 /* ??? With complex control flow (usually involving abnormal edges),
1350 we can wind up warning about an uninitialized value for this. Due
1351 to how this variable is constructed and initialized, this is never
1352 true. Give up and never warn. */
1353 TREE_NO_WARNING (result
) = 1;
1355 gimplify_ctxp
->return_temp
= result
;
1358 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1359 Then gimplify the whole thing. */
1360 if (result
!= result_decl
)
1361 TREE_OPERAND (ret_expr
, 0) = result
;
1363 gimplify_and_add (TREE_OPERAND (stmt
, 0), pre_p
);
1365 ret
= gimple_build_return (result
);
1366 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1367 gimplify_seq_add_stmt (pre_p
, ret
);
1372 /* Gimplify a variable-length array DECL. */
1375 gimplify_vla_decl (tree decl
, gimple_seq
*seq_p
)
1377 /* This is a variable-sized decl. Simplify its size and mark it
1378 for deferred expansion. Note that mudflap depends on the format
1379 of the emitted code: see mx_register_decls(). */
1380 tree t
, addr
, ptr_type
;
1382 gimplify_one_sizepos (&DECL_SIZE (decl
), seq_p
);
1383 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl
), seq_p
);
1385 /* All occurrences of this decl in final gimplified code will be
1386 replaced by indirection. Setting DECL_VALUE_EXPR does two
1387 things: First, it lets the rest of the gimplifier know what
1388 replacement to use. Second, it lets the debug info know
1389 where to find the value. */
1390 ptr_type
= build_pointer_type (TREE_TYPE (decl
));
1391 addr
= create_tmp_var (ptr_type
, get_name (decl
));
1392 DECL_IGNORED_P (addr
) = 0;
1393 t
= build_fold_indirect_ref (addr
);
1394 TREE_THIS_NOTRAP (t
) = 1;
1395 SET_DECL_VALUE_EXPR (decl
, t
);
1396 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1398 t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
1399 t
= build_call_expr (t
, 2, DECL_SIZE_UNIT (decl
),
1400 size_int (DECL_ALIGN (decl
)));
1401 /* The call has been built for a variable-sized object. */
1402 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
1403 t
= fold_convert (ptr_type
, t
);
1404 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
1406 gimplify_and_add (t
, seq_p
);
1408 /* Indicate that we need to restore the stack level when the
1409 enclosing BIND_EXPR is exited. */
1410 gimplify_ctxp
->save_stack
= true;
1413 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1414 and initialization explicit. */
1416 static enum gimplify_status
1417 gimplify_decl_expr (tree
*stmt_p
, gimple_seq
*seq_p
)
1419 tree stmt
= *stmt_p
;
1420 tree decl
= DECL_EXPR_DECL (stmt
);
1422 *stmt_p
= NULL_TREE
;
1424 if (TREE_TYPE (decl
) == error_mark_node
)
1427 if ((TREE_CODE (decl
) == TYPE_DECL
1428 || TREE_CODE (decl
) == VAR_DECL
)
1429 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl
)))
1430 gimplify_type_sizes (TREE_TYPE (decl
), seq_p
);
1432 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1433 in case its size expressions contain problematic nodes like CALL_EXPR. */
1434 if (TREE_CODE (decl
) == TYPE_DECL
1435 && DECL_ORIGINAL_TYPE (decl
)
1436 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl
)))
1437 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl
), seq_p
);
1439 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1441 tree init
= DECL_INITIAL (decl
);
1443 if (TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1444 || (!TREE_STATIC (decl
)
1445 && flag_stack_check
== GENERIC_STACK_CHECK
1446 && compare_tree_int (DECL_SIZE_UNIT (decl
),
1447 STACK_CHECK_MAX_VAR_SIZE
) > 0))
1448 gimplify_vla_decl (decl
, seq_p
);
1450 /* Some front ends do not explicitly declare all anonymous
1451 artificial variables. We compensate here by declaring the
1452 variables, though it would be better if the front ends would
1453 explicitly declare them. */
1454 if (!DECL_SEEN_IN_BIND_EXPR_P (decl
)
1455 && DECL_ARTIFICIAL (decl
) && DECL_NAME (decl
) == NULL_TREE
)
1456 gimple_add_tmp_var (decl
);
1458 if (init
&& init
!= error_mark_node
)
1460 if (!TREE_STATIC (decl
))
1462 DECL_INITIAL (decl
) = NULL_TREE
;
1463 init
= build2 (INIT_EXPR
, void_type_node
, decl
, init
);
1464 gimplify_and_add (init
, seq_p
);
1468 /* We must still examine initializers for static variables
1469 as they may contain a label address. */
1470 walk_tree (&init
, force_labels_r
, NULL
, NULL
);
1477 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1478 and replacing the LOOP_EXPR with goto, but if the loop contains an
1479 EXIT_EXPR, we need to append a label for it to jump to. */
1481 static enum gimplify_status
1482 gimplify_loop_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1484 tree saved_label
= gimplify_ctxp
->exit_label
;
1485 tree start_label
= create_artificial_label (UNKNOWN_LOCATION
);
1487 gimplify_seq_add_stmt (pre_p
, gimple_build_label (start_label
));
1489 gimplify_ctxp
->exit_label
= NULL_TREE
;
1491 gimplify_and_add (LOOP_EXPR_BODY (*expr_p
), pre_p
);
1493 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (start_label
));
1495 if (gimplify_ctxp
->exit_label
)
1496 gimplify_seq_add_stmt (pre_p
,
1497 gimple_build_label (gimplify_ctxp
->exit_label
));
1499 gimplify_ctxp
->exit_label
= saved_label
;
1505 /* Gimplify a statement list onto a sequence. These may be created either
1506 by an enlightened front-end, or by shortcut_cond_expr. */
1508 static enum gimplify_status
1509 gimplify_statement_list (tree
*expr_p
, gimple_seq
*pre_p
)
1511 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
1513 tree_stmt_iterator i
= tsi_start (*expr_p
);
1515 while (!tsi_end_p (i
))
1517 gimplify_stmt (tsi_stmt_ptr (i
), pre_p
);
1530 /* Compare two case labels. Because the front end should already have
1531 made sure that case ranges do not overlap, it is enough to only compare
1532 the CASE_LOW values of each case label. */
1535 compare_case_labels (const void *p1
, const void *p2
)
1537 const_tree
const case1
= *(const_tree
const*)p1
;
1538 const_tree
const case2
= *(const_tree
const*)p2
;
1540 /* The 'default' case label always goes first. */
1541 if (!CASE_LOW (case1
))
1543 else if (!CASE_LOW (case2
))
1546 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
1549 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1552 sort_case_labels (vec
<tree
> label_vec
)
1554 label_vec
.qsort (compare_case_labels
);
1557 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
1559 LABELS is a vector that contains all case labels to look at.
1561 INDEX_TYPE is the type of the switch index expression. Case labels
1562 in LABELS are discarded if their values are not in the value range
1563 covered by INDEX_TYPE. The remaining case label values are folded
1566 If a default case exists in LABELS, it is removed from LABELS and
1567 returned in DEFAULT_CASEP. If no default case exists, but the
1568 case labels already cover the whole range of INDEX_TYPE, a default
1569 case is returned pointing to one of the existing case labels.
1570 Otherwise DEFAULT_CASEP is set to NULL_TREE.
1572 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
1573 apply and no action is taken regardless of whether a default case is
1577 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
1579 tree
*default_casep
)
1581 tree min_value
, max_value
;
1582 tree default_case
= NULL_TREE
;
1586 min_value
= TYPE_MIN_VALUE (index_type
);
1587 max_value
= TYPE_MAX_VALUE (index_type
);
1588 while (i
< labels
.length ())
1590 tree elt
= labels
[i
];
1591 tree low
= CASE_LOW (elt
);
1592 tree high
= CASE_HIGH (elt
);
1593 bool remove_element
= FALSE
;
1597 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
1598 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
1600 /* This is a non-default case label, i.e. it has a value.
1602 See if the case label is reachable within the range of
1603 the index type. Remove out-of-range case values. Turn
1604 case ranges into a canonical form (high > low strictly)
1605 and convert the case label values to the index type.
1607 NB: The type of gimple_switch_index() may be the promoted
1608 type, but the case labels retain the original type. */
1612 /* This is a case range. Discard empty ranges.
1613 If the bounds or the range are equal, turn this
1614 into a simple (one-value) case. */
1615 int cmp
= tree_int_cst_compare (high
, low
);
1617 remove_element
= TRUE
;
1624 /* If the simple case value is unreachable, ignore it. */
1625 if ((TREE_CODE (min_value
) == INTEGER_CST
1626 && tree_int_cst_compare (low
, min_value
) < 0)
1627 || (TREE_CODE (max_value
) == INTEGER_CST
1628 && tree_int_cst_compare (low
, max_value
) > 0))
1629 remove_element
= TRUE
;
1631 low
= fold_convert (index_type
, low
);
1635 /* If the entire case range is unreachable, ignore it. */
1636 if ((TREE_CODE (min_value
) == INTEGER_CST
1637 && tree_int_cst_compare (high
, min_value
) < 0)
1638 || (TREE_CODE (max_value
) == INTEGER_CST
1639 && tree_int_cst_compare (low
, max_value
) > 0))
1640 remove_element
= TRUE
;
1643 /* If the lower bound is less than the index type's
1644 minimum value, truncate the range bounds. */
1645 if (TREE_CODE (min_value
) == INTEGER_CST
1646 && tree_int_cst_compare (low
, min_value
) < 0)
1648 low
= fold_convert (index_type
, low
);
1650 /* If the upper bound is greater than the index type's
1651 maximum value, truncate the range bounds. */
1652 if (TREE_CODE (max_value
) == INTEGER_CST
1653 && tree_int_cst_compare (high
, max_value
) > 0)
1655 high
= fold_convert (index_type
, high
);
1657 /* We may have folded a case range to a one-value case. */
1658 if (tree_int_cst_equal (low
, high
))
1663 CASE_LOW (elt
) = low
;
1664 CASE_HIGH (elt
) = high
;
1668 gcc_assert (!default_case
);
1670 /* The default case must be passed separately to the
1671 gimple_build_switch routine. But if DEFAULT_CASEP
1672 is NULL, we do not remove the default case (it would
1673 be completely lost). */
1675 remove_element
= TRUE
;
1679 labels
.ordered_remove (i
);
1685 if (!labels
.is_empty ())
1686 sort_case_labels (labels
);
1688 if (default_casep
&& !default_case
)
1690 /* If the switch has no default label, add one, so that we jump
1691 around the switch body. If the labels already cover the whole
1692 range of the switch index_type, add the default label pointing
1693 to one of the existing labels. */
1695 && TYPE_MIN_VALUE (index_type
)
1696 && TYPE_MAX_VALUE (index_type
)
1697 && tree_int_cst_equal (CASE_LOW (labels
[0]),
1698 TYPE_MIN_VALUE (index_type
)))
1700 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
1702 high
= CASE_LOW (labels
[len
- 1]);
1703 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
1705 for (i
= 1; i
< len
; i
++)
1707 high
= CASE_LOW (labels
[i
]);
1708 low
= CASE_HIGH (labels
[i
- 1]);
1710 low
= CASE_LOW (labels
[i
- 1]);
1711 if ((TREE_INT_CST_LOW (low
) + 1
1712 != TREE_INT_CST_LOW (high
))
1713 || (TREE_INT_CST_HIGH (low
)
1714 + (TREE_INT_CST_LOW (high
) == 0)
1715 != TREE_INT_CST_HIGH (high
)))
1720 tree label
= CASE_LABEL (labels
[0]);
1721 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
1729 *default_casep
= default_case
;
1732 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
1735 static enum gimplify_status
1736 gimplify_switch_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1738 tree switch_expr
= *expr_p
;
1739 gimple_seq switch_body_seq
= NULL
;
1740 enum gimplify_status ret
;
1741 tree index_type
= TREE_TYPE (switch_expr
);
1742 if (index_type
== NULL_TREE
)
1743 index_type
= TREE_TYPE (SWITCH_COND (switch_expr
));
1745 ret
= gimplify_expr (&SWITCH_COND (switch_expr
), pre_p
, NULL
, is_gimple_val
,
1747 if (ret
== GS_ERROR
|| ret
== GS_UNHANDLED
)
1750 if (SWITCH_BODY (switch_expr
))
1753 vec
<tree
> saved_labels
;
1754 tree default_case
= NULL_TREE
;
1755 gimple gimple_switch
;
1757 /* If someone can be bothered to fill in the labels, they can
1758 be bothered to null out the body too. */
1759 gcc_assert (!SWITCH_LABELS (switch_expr
));
1761 /* Save old labels, get new ones from body, then restore the old
1762 labels. Save all the things from the switch body to append after. */
1763 saved_labels
= gimplify_ctxp
->case_labels
;
1764 gimplify_ctxp
->case_labels
.create (8);
1766 gimplify_stmt (&SWITCH_BODY (switch_expr
), &switch_body_seq
);
1767 labels
= gimplify_ctxp
->case_labels
;
1768 gimplify_ctxp
->case_labels
= saved_labels
;
1770 preprocess_case_label_vec_for_gimple (labels
, index_type
,
1778 = build_case_label (NULL_TREE
, NULL_TREE
,
1779 create_artificial_label (UNKNOWN_LOCATION
));
1780 new_default
= gimple_build_label (CASE_LABEL (default_case
));
1781 gimplify_seq_add_stmt (&switch_body_seq
, new_default
);
1784 gimple_switch
= gimple_build_switch (SWITCH_COND (switch_expr
),
1785 default_case
, labels
);
1786 gimplify_seq_add_stmt (pre_p
, gimple_switch
);
1787 gimplify_seq_add_seq (pre_p
, switch_body_seq
);
1791 gcc_assert (SWITCH_LABELS (switch_expr
));
1796 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
1798 static enum gimplify_status
1799 gimplify_case_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1801 struct gimplify_ctx
*ctxp
;
1802 gimple gimple_label
;
1804 /* Invalid OpenMP programs can play Duff's Device type games with
1805 #pragma omp parallel. At least in the C front end, we don't
1806 detect such invalid branches until after gimplification. */
1807 for (ctxp
= gimplify_ctxp
; ; ctxp
= ctxp
->prev_context
)
1808 if (ctxp
->case_labels
.exists ())
1811 gimple_label
= gimple_build_label (CASE_LABEL (*expr_p
));
1812 ctxp
->case_labels
.safe_push (*expr_p
);
1813 gimplify_seq_add_stmt (pre_p
, gimple_label
);
1818 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1822 build_and_jump (tree
*label_p
)
1824 if (label_p
== NULL
)
1825 /* If there's nowhere to jump, just fall through. */
1828 if (*label_p
== NULL_TREE
)
1830 tree label
= create_artificial_label (UNKNOWN_LOCATION
);
1834 return build1 (GOTO_EXPR
, void_type_node
, *label_p
);
1837 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1838 This also involves building a label to jump to and communicating it to
1839 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1841 static enum gimplify_status
1842 gimplify_exit_expr (tree
*expr_p
)
1844 tree cond
= TREE_OPERAND (*expr_p
, 0);
1847 expr
= build_and_jump (&gimplify_ctxp
->exit_label
);
1848 expr
= build3 (COND_EXPR
, void_type_node
, cond
, expr
, NULL_TREE
);
1854 /* A helper function to be called via walk_tree. Mark all labels under *TP
1855 as being forced. To be called for DECL_INITIAL of static variables. */
1858 force_labels_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1862 if (TREE_CODE (*tp
) == LABEL_DECL
)
1863 FORCED_LABEL (*tp
) = 1;
1868 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1869 different from its canonical type, wrap the whole thing inside a
1870 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1873 The canonical type of a COMPONENT_REF is the type of the field being
1874 referenced--unless the field is a bit-field which can be read directly
1875 in a smaller mode, in which case the canonical type is the
1876 sign-appropriate type corresponding to that mode. */
1879 canonicalize_component_ref (tree
*expr_p
)
1881 tree expr
= *expr_p
;
1884 gcc_assert (TREE_CODE (expr
) == COMPONENT_REF
);
1886 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
1887 type
= TREE_TYPE (get_unwidened (expr
, NULL_TREE
));
1889 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
1891 /* One could argue that all the stuff below is not necessary for
1892 the non-bitfield case and declare it a FE error if type
1893 adjustment would be needed. */
1894 if (TREE_TYPE (expr
) != type
)
1896 #ifdef ENABLE_TYPES_CHECKING
1897 tree old_type
= TREE_TYPE (expr
);
1901 /* We need to preserve qualifiers and propagate them from
1903 type_quals
= TYPE_QUALS (type
)
1904 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1905 if (TYPE_QUALS (type
) != type_quals
)
1906 type
= build_qualified_type (TYPE_MAIN_VARIANT (type
), type_quals
);
1908 /* Set the type of the COMPONENT_REF to the underlying type. */
1909 TREE_TYPE (expr
) = type
;
1911 #ifdef ENABLE_TYPES_CHECKING
1912 /* It is now a FE error, if the conversion from the canonical
1913 type to the original expression type is not useless. */
1914 gcc_assert (useless_type_conversion_p (old_type
, type
));
1919 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1920 to foo, embed that change in the ADDR_EXPR by converting
1925 where L is the lower bound. For simplicity, only do this for constant
1927 The constraint is that the type of &array[L] is trivially convertible
1931 canonicalize_addr_expr (tree
*expr_p
)
1933 tree expr
= *expr_p
;
1934 tree addr_expr
= TREE_OPERAND (expr
, 0);
1935 tree datype
, ddatype
, pddatype
;
1937 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1938 if (!POINTER_TYPE_P (TREE_TYPE (expr
))
1939 || TREE_CODE (addr_expr
) != ADDR_EXPR
)
1942 /* The addr_expr type should be a pointer to an array. */
1943 datype
= TREE_TYPE (TREE_TYPE (addr_expr
));
1944 if (TREE_CODE (datype
) != ARRAY_TYPE
)
1947 /* The pointer to element type shall be trivially convertible to
1948 the expression pointer type. */
1949 ddatype
= TREE_TYPE (datype
);
1950 pddatype
= build_pointer_type (ddatype
);
1951 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)),
1955 /* The lower bound and element sizes must be constant. */
1956 if (!TYPE_SIZE_UNIT (ddatype
)
1957 || TREE_CODE (TYPE_SIZE_UNIT (ddatype
)) != INTEGER_CST
1958 || !TYPE_DOMAIN (datype
) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))
1959 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))) != INTEGER_CST
)
1962 /* All checks succeeded. Build a new node to merge the cast. */
1963 *expr_p
= build4 (ARRAY_REF
, ddatype
, TREE_OPERAND (addr_expr
, 0),
1964 TYPE_MIN_VALUE (TYPE_DOMAIN (datype
)),
1965 NULL_TREE
, NULL_TREE
);
1966 *expr_p
= build1 (ADDR_EXPR
, pddatype
, *expr_p
);
1968 /* We can have stripped a required restrict qualifier above. */
1969 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
1970 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
1973 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1974 underneath as appropriate. */
1976 static enum gimplify_status
1977 gimplify_conversion (tree
*expr_p
)
1979 location_t loc
= EXPR_LOCATION (*expr_p
);
1980 gcc_assert (CONVERT_EXPR_P (*expr_p
));
1982 /* Then strip away all but the outermost conversion. */
1983 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p
, 0));
1985 /* And remove the outermost conversion if it's useless. */
1986 if (tree_ssa_useless_type_conversion (*expr_p
))
1987 *expr_p
= TREE_OPERAND (*expr_p
, 0);
1989 /* If we still have a conversion at the toplevel,
1990 then canonicalize some constructs. */
1991 if (CONVERT_EXPR_P (*expr_p
))
1993 tree sub
= TREE_OPERAND (*expr_p
, 0);
1995 /* If a NOP conversion is changing the type of a COMPONENT_REF
1996 expression, then canonicalize its type now in order to expose more
1997 redundant conversions. */
1998 if (TREE_CODE (sub
) == COMPONENT_REF
)
1999 canonicalize_component_ref (&TREE_OPERAND (*expr_p
, 0));
2001 /* If a NOP conversion is changing a pointer to array of foo
2002 to a pointer to foo, embed that change in the ADDR_EXPR. */
2003 else if (TREE_CODE (sub
) == ADDR_EXPR
)
2004 canonicalize_addr_expr (expr_p
);
2007 /* If we have a conversion to a non-register type force the
2008 use of a VIEW_CONVERT_EXPR instead. */
2009 if (CONVERT_EXPR_P (*expr_p
) && !is_gimple_reg_type (TREE_TYPE (*expr_p
)))
2010 *expr_p
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (*expr_p
),
2011 TREE_OPERAND (*expr_p
, 0));
2016 /* Nonlocal VLAs seen in the current function. */
2017 static struct pointer_set_t
*nonlocal_vlas
;
2019 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
2020 DECL_VALUE_EXPR, and it's worth re-examining things. */
2022 static enum gimplify_status
2023 gimplify_var_or_parm_decl (tree
*expr_p
)
2025 tree decl
= *expr_p
;
2027 /* ??? If this is a local variable, and it has not been seen in any
2028 outer BIND_EXPR, then it's probably the result of a duplicate
2029 declaration, for which we've already issued an error. It would
2030 be really nice if the front end wouldn't leak these at all.
2031 Currently the only known culprit is C++ destructors, as seen
2032 in g++.old-deja/g++.jason/binding.C. */
2033 if (TREE_CODE (decl
) == VAR_DECL
2034 && !DECL_SEEN_IN_BIND_EXPR_P (decl
)
2035 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)
2036 && decl_function_context (decl
) == current_function_decl
)
2038 gcc_assert (seen_error ());
2042 /* When within an OpenMP context, notice uses of variables. */
2043 if (gimplify_omp_ctxp
&& omp_notice_variable (gimplify_omp_ctxp
, decl
, true))
2046 /* If the decl is an alias for another expression, substitute it now. */
2047 if (DECL_HAS_VALUE_EXPR_P (decl
))
2049 tree value_expr
= DECL_VALUE_EXPR (decl
);
2051 /* For referenced nonlocal VLAs add a decl for debugging purposes
2052 to the current function. */
2053 if (TREE_CODE (decl
) == VAR_DECL
2054 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
2055 && nonlocal_vlas
!= NULL
2056 && TREE_CODE (value_expr
) == INDIRECT_REF
2057 && TREE_CODE (TREE_OPERAND (value_expr
, 0)) == VAR_DECL
2058 && decl_function_context (decl
) != current_function_decl
)
2060 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
2061 while (ctx
&& ctx
->region_type
== ORT_WORKSHARE
)
2062 ctx
= ctx
->outer_context
;
2063 if (!ctx
&& !pointer_set_insert (nonlocal_vlas
, decl
))
2065 tree copy
= copy_node (decl
), block
;
2067 lang_hooks
.dup_lang_specific_decl (copy
);
2068 SET_DECL_RTL (copy
, 0);
2069 TREE_USED (copy
) = 1;
2070 block
= DECL_INITIAL (current_function_decl
);
2071 DECL_CHAIN (copy
) = BLOCK_VARS (block
);
2072 BLOCK_VARS (block
) = copy
;
2073 SET_DECL_VALUE_EXPR (copy
, unshare_expr (value_expr
));
2074 DECL_HAS_VALUE_EXPR_P (copy
) = 1;
2078 *expr_p
= unshare_expr (value_expr
);
2085 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
2089 : min_lval '[' val ']'
2091 | compound_lval '[' val ']'
2092 | compound_lval '.' ID
2094 This is not part of the original SIMPLE definition, which separates
2095 array and member references, but it seems reasonable to handle them
2096 together. Also, this way we don't run into problems with union
2097 aliasing; gcc requires that for accesses through a union to alias, the
2098 union reference must be explicit, which was not always the case when we
2099 were splitting up array and member refs.
2101 PRE_P points to the sequence where side effects that must happen before
2102 *EXPR_P should be stored.
2104 POST_P points to the sequence where side effects that must happen after
2105 *EXPR_P should be stored. */
2107 static enum gimplify_status
2108 gimplify_compound_lval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2109 fallback_t fallback
)
2112 vec
<tree
> expr_stack
;
2113 enum gimplify_status ret
= GS_ALL_DONE
, tret
;
2115 location_t loc
= EXPR_LOCATION (*expr_p
);
2116 tree expr
= *expr_p
;
2118 /* Create a stack of the subexpressions so later we can walk them in
2119 order from inner to outer. */
2120 expr_stack
.create (10);
2122 /* We can handle anything that get_inner_reference can deal with. */
2123 for (p
= expr_p
; ; p
= &TREE_OPERAND (*p
, 0))
2126 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2127 if (TREE_CODE (*p
) == INDIRECT_REF
)
2128 *p
= fold_indirect_ref_loc (loc
, *p
);
2130 if (handled_component_p (*p
))
2132 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2133 additional COMPONENT_REFs. */
2134 else if ((TREE_CODE (*p
) == VAR_DECL
|| TREE_CODE (*p
) == PARM_DECL
)
2135 && gimplify_var_or_parm_decl (p
) == GS_OK
)
2140 expr_stack
.safe_push (*p
);
2143 gcc_assert (expr_stack
.length ());
2145 /* Now EXPR_STACK is a stack of pointers to all the refs we've
2146 walked through and P points to the innermost expression.
2148 Java requires that we elaborated nodes in source order. That
2149 means we must gimplify the inner expression followed by each of
2150 the indices, in order. But we can't gimplify the inner
2151 expression until we deal with any variable bounds, sizes, or
2152 positions in order to deal with PLACEHOLDER_EXPRs.
2154 So we do this in three steps. First we deal with the annotations
2155 for any variables in the components, then we gimplify the base,
2156 then we gimplify any indices, from left to right. */
2157 for (i
= expr_stack
.length () - 1; i
>= 0; i
--)
2159 tree t
= expr_stack
[i
];
2161 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2163 /* Gimplify the low bound and element type size and put them into
2164 the ARRAY_REF. If these values are set, they have already been
2166 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2168 tree low
= unshare_expr (array_ref_low_bound (t
));
2169 if (!is_gimple_min_invariant (low
))
2171 TREE_OPERAND (t
, 2) = low
;
2172 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2173 post_p
, is_gimple_reg
,
2175 ret
= MIN (ret
, tret
);
2180 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2181 is_gimple_reg
, fb_rvalue
);
2182 ret
= MIN (ret
, tret
);
2185 if (TREE_OPERAND (t
, 3) == NULL_TREE
)
2187 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0)));
2188 tree elmt_size
= unshare_expr (array_ref_element_size (t
));
2189 tree factor
= size_int (TYPE_ALIGN_UNIT (elmt_type
));
2191 /* Divide the element size by the alignment of the element
2194 = size_binop_loc (loc
, EXACT_DIV_EXPR
, elmt_size
, factor
);
2196 if (!is_gimple_min_invariant (elmt_size
))
2198 TREE_OPERAND (t
, 3) = elmt_size
;
2199 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
,
2200 post_p
, is_gimple_reg
,
2202 ret
= MIN (ret
, tret
);
2207 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
, post_p
,
2208 is_gimple_reg
, fb_rvalue
);
2209 ret
= MIN (ret
, tret
);
2212 else if (TREE_CODE (t
) == COMPONENT_REF
)
2214 /* Set the field offset into T and gimplify it. */
2215 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2217 tree offset
= unshare_expr (component_ref_field_offset (t
));
2218 tree field
= TREE_OPERAND (t
, 1);
2220 = size_int (DECL_OFFSET_ALIGN (field
) / BITS_PER_UNIT
);
2222 /* Divide the offset by its alignment. */
2223 offset
= size_binop_loc (loc
, EXACT_DIV_EXPR
, offset
, factor
);
2225 if (!is_gimple_min_invariant (offset
))
2227 TREE_OPERAND (t
, 2) = offset
;
2228 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2229 post_p
, is_gimple_reg
,
2231 ret
= MIN (ret
, tret
);
2236 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2237 is_gimple_reg
, fb_rvalue
);
2238 ret
= MIN (ret
, tret
);
2243 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2244 so as to match the min_lval predicate. Failure to do so may result
2245 in the creation of large aggregate temporaries. */
2246 tret
= gimplify_expr (p
, pre_p
, post_p
, is_gimple_min_lval
,
2247 fallback
| fb_lvalue
);
2248 ret
= MIN (ret
, tret
);
2250 /* And finally, the indices and operands of ARRAY_REF. During this
2251 loop we also remove any useless conversions. */
2252 for (; expr_stack
.length () > 0; )
2254 tree t
= expr_stack
.pop ();
2256 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2258 /* Gimplify the dimension. */
2259 if (!is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
2261 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2262 is_gimple_val
, fb_rvalue
);
2263 ret
= MIN (ret
, tret
);
2267 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t
, 0));
2269 /* The innermost expression P may have originally had
2270 TREE_SIDE_EFFECTS set which would have caused all the outer
2271 expressions in *EXPR_P leading to P to also have had
2272 TREE_SIDE_EFFECTS set. */
2273 recalculate_side_effects (t
);
2276 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2277 if ((fallback
& fb_rvalue
) && TREE_CODE (*expr_p
) == COMPONENT_REF
)
2279 canonicalize_component_ref (expr_p
);
2282 expr_stack
.release ();
2284 gcc_assert (*expr_p
== expr
|| ret
!= GS_ALL_DONE
);
2289 /* Gimplify the self modifying expression pointed to by EXPR_P
2292 PRE_P points to the list where side effects that must happen before
2293 *EXPR_P should be stored.
2295 POST_P points to the list where side effects that must happen after
2296 *EXPR_P should be stored.
2298 WANT_VALUE is nonzero iff we want to use the value of this expression
2299 in another expression.
2301 ARITH_TYPE is the type the computation should be performed in. */
2303 enum gimplify_status
2304 gimplify_self_mod_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2305 bool want_value
, tree arith_type
)
2307 enum tree_code code
;
2308 tree lhs
, lvalue
, rhs
, t1
;
2309 gimple_seq post
= NULL
, *orig_post_p
= post_p
;
2311 enum tree_code arith_code
;
2312 enum gimplify_status ret
;
2313 location_t loc
= EXPR_LOCATION (*expr_p
);
2315 code
= TREE_CODE (*expr_p
);
2317 gcc_assert (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
2318 || code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
);
2320 /* Prefix or postfix? */
2321 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
2322 /* Faster to treat as prefix if result is not used. */
2323 postfix
= want_value
;
2327 /* For postfix, make sure the inner expression's post side effects
2328 are executed after side effects from this expression. */
2332 /* Add or subtract? */
2333 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2334 arith_code
= PLUS_EXPR
;
2336 arith_code
= MINUS_EXPR
;
2338 /* Gimplify the LHS into a GIMPLE lvalue. */
2339 lvalue
= TREE_OPERAND (*expr_p
, 0);
2340 ret
= gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
2341 if (ret
== GS_ERROR
)
2344 /* Extract the operands to the arithmetic operation. */
2346 rhs
= TREE_OPERAND (*expr_p
, 1);
2348 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2349 that as the result value and in the postqueue operation. */
2352 ret
= gimplify_expr (&lhs
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
2353 if (ret
== GS_ERROR
)
2356 lhs
= get_initialized_tmp_var (lhs
, pre_p
, NULL
);
2359 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2360 if (POINTER_TYPE_P (TREE_TYPE (lhs
)))
2362 rhs
= convert_to_ptrofftype_loc (loc
, rhs
);
2363 if (arith_code
== MINUS_EXPR
)
2364 rhs
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
2365 t1
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (*expr_p
), lhs
, rhs
);
2368 t1
= fold_convert (TREE_TYPE (*expr_p
),
2369 fold_build2 (arith_code
, arith_type
,
2370 fold_convert (arith_type
, lhs
),
2371 fold_convert (arith_type
, rhs
)));
2375 gimplify_assign (lvalue
, t1
, pre_p
);
2376 gimplify_seq_add_seq (orig_post_p
, post
);
2382 *expr_p
= build2 (MODIFY_EXPR
, TREE_TYPE (lvalue
), lvalue
, t1
);
2387 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2390 maybe_with_size_expr (tree
*expr_p
)
2392 tree expr
= *expr_p
;
2393 tree type
= TREE_TYPE (expr
);
2396 /* If we've already wrapped this or the type is error_mark_node, we can't do
2398 if (TREE_CODE (expr
) == WITH_SIZE_EXPR
2399 || type
== error_mark_node
)
2402 /* If the size isn't known or is a constant, we have nothing to do. */
2403 size
= TYPE_SIZE_UNIT (type
);
2404 if (!size
|| TREE_CODE (size
) == INTEGER_CST
)
2407 /* Otherwise, make a WITH_SIZE_EXPR. */
2408 size
= unshare_expr (size
);
2409 size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (size
, expr
);
2410 *expr_p
= build2 (WITH_SIZE_EXPR
, type
, expr
, size
);
2413 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2414 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2417 static enum gimplify_status
2418 gimplify_arg (tree
*arg_p
, gimple_seq
*pre_p
, location_t call_location
)
2420 bool (*test
) (tree
);
2423 /* In general, we allow lvalues for function arguments to avoid
2424 extra overhead of copying large aggregates out of even larger
2425 aggregates into temporaries only to copy the temporaries to
2426 the argument list. Make optimizers happy by pulling out to
2427 temporaries those types that fit in registers. */
2428 if (is_gimple_reg_type (TREE_TYPE (*arg_p
)))
2429 test
= is_gimple_val
, fb
= fb_rvalue
;
2432 test
= is_gimple_lvalue
, fb
= fb_either
;
2433 /* Also strip a TARGET_EXPR that would force an extra copy. */
2434 if (TREE_CODE (*arg_p
) == TARGET_EXPR
)
2436 tree init
= TARGET_EXPR_INITIAL (*arg_p
);
2438 && !VOID_TYPE_P (TREE_TYPE (init
)))
2443 /* If this is a variable sized type, we must remember the size. */
2444 maybe_with_size_expr (arg_p
);
2446 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2447 /* Make sure arguments have the same location as the function call
2449 protected_set_expr_location (*arg_p
, call_location
);
2451 /* There is a sequence point before a function call. Side effects in
2452 the argument list must occur before the actual call. So, when
2453 gimplifying arguments, force gimplify_expr to use an internal
2454 post queue which is then appended to the end of PRE_P. */
2455 return gimplify_expr (arg_p
, pre_p
, NULL
, test
, fb
);
2458 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2459 WANT_VALUE is true if the result of the call is desired. */
2461 static enum gimplify_status
2462 gimplify_call_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
2464 tree fndecl
, parms
, p
, fnptrtype
;
2465 enum gimplify_status ret
;
2468 bool builtin_va_start_p
= FALSE
;
2469 location_t loc
= EXPR_LOCATION (*expr_p
);
2471 gcc_assert (TREE_CODE (*expr_p
) == CALL_EXPR
);
2473 /* For reliable diagnostics during inlining, it is necessary that
2474 every call_expr be annotated with file and line. */
2475 if (! EXPR_HAS_LOCATION (*expr_p
))
2476 SET_EXPR_LOCATION (*expr_p
, input_location
);
2478 /* This may be a call to a builtin function.
2480 Builtin function calls may be transformed into different
2481 (and more efficient) builtin function calls under certain
2482 circumstances. Unfortunately, gimplification can muck things
2483 up enough that the builtin expanders are not aware that certain
2484 transformations are still valid.
2486 So we attempt transformation/gimplification of the call before
2487 we gimplify the CALL_EXPR. At this time we do not manage to
2488 transform all calls in the same manner as the expanders do, but
2489 we do transform most of them. */
2490 fndecl
= get_callee_fndecl (*expr_p
);
2492 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
2493 switch (DECL_FUNCTION_CODE (fndecl
))
2495 case BUILT_IN_VA_START
:
2497 builtin_va_start_p
= TRUE
;
2498 if (call_expr_nargs (*expr_p
) < 2)
2500 error ("too few arguments to function %<va_start%>");
2501 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2505 if (fold_builtin_next_arg (*expr_p
, true))
2507 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2514 expanded_location loc
= expand_location (EXPR_LOCATION (*expr_p
));
2515 *expr_p
= build_int_cst (TREE_TYPE (*expr_p
), loc
.line
);
2520 expanded_location loc
= expand_location (EXPR_LOCATION (*expr_p
));
2521 *expr_p
= build_string_literal (strlen (loc
.file
) + 1, loc
.file
);
2524 case BUILT_IN_FUNCTION
:
2526 const char *function
;
2527 function
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
2528 *expr_p
= build_string_literal (strlen (function
) + 1, function
);
2534 if (fndecl
&& DECL_BUILT_IN (fndecl
))
2536 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2537 if (new_tree
&& new_tree
!= *expr_p
)
2539 /* There was a transformation of this call which computes the
2540 same value, but in a more efficient way. Return and try
2547 /* Remember the original function pointer type. */
2548 fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*expr_p
));
2550 /* There is a sequence point before the call, so any side effects in
2551 the calling expression must occur before the actual call. Force
2552 gimplify_expr to use an internal post queue. */
2553 ret
= gimplify_expr (&CALL_EXPR_FN (*expr_p
), pre_p
, NULL
,
2554 is_gimple_call_addr
, fb_rvalue
);
2556 nargs
= call_expr_nargs (*expr_p
);
2558 /* Get argument types for verification. */
2559 fndecl
= get_callee_fndecl (*expr_p
);
2562 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2563 else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p
))))
2564 parms
= TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p
))));
2566 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
2567 p
= DECL_ARGUMENTS (fndecl
);
2572 for (i
= 0; i
< nargs
&& p
; i
++, p
= TREE_CHAIN (p
))
2575 /* If the last argument is __builtin_va_arg_pack () and it is not
2576 passed as a named argument, decrease the number of CALL_EXPR
2577 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2580 && TREE_CODE (CALL_EXPR_ARG (*expr_p
, nargs
- 1)) == CALL_EXPR
)
2582 tree last_arg
= CALL_EXPR_ARG (*expr_p
, nargs
- 1);
2583 tree last_arg_fndecl
= get_callee_fndecl (last_arg
);
2586 && TREE_CODE (last_arg_fndecl
) == FUNCTION_DECL
2587 && DECL_BUILT_IN_CLASS (last_arg_fndecl
) == BUILT_IN_NORMAL
2588 && DECL_FUNCTION_CODE (last_arg_fndecl
) == BUILT_IN_VA_ARG_PACK
)
2590 tree call
= *expr_p
;
2593 *expr_p
= build_call_array_loc (loc
, TREE_TYPE (call
),
2594 CALL_EXPR_FN (call
),
2595 nargs
, CALL_EXPR_ARGP (call
));
2597 /* Copy all CALL_EXPR flags, location and block, except
2598 CALL_EXPR_VA_ARG_PACK flag. */
2599 CALL_EXPR_STATIC_CHAIN (*expr_p
) = CALL_EXPR_STATIC_CHAIN (call
);
2600 CALL_EXPR_TAILCALL (*expr_p
) = CALL_EXPR_TAILCALL (call
);
2601 CALL_EXPR_RETURN_SLOT_OPT (*expr_p
)
2602 = CALL_EXPR_RETURN_SLOT_OPT (call
);
2603 CALL_FROM_THUNK_P (*expr_p
) = CALL_FROM_THUNK_P (call
);
2604 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (call
));
2606 /* Set CALL_EXPR_VA_ARG_PACK. */
2607 CALL_EXPR_VA_ARG_PACK (*expr_p
) = 1;
2611 /* Finally, gimplify the function arguments. */
2614 for (i
= (PUSH_ARGS_REVERSED
? nargs
- 1 : 0);
2615 PUSH_ARGS_REVERSED
? i
>= 0 : i
< nargs
;
2616 PUSH_ARGS_REVERSED
? i
-- : i
++)
2618 enum gimplify_status t
;
2620 /* Avoid gimplifying the second argument to va_start, which needs to
2621 be the plain PARM_DECL. */
2622 if ((i
!= 1) || !builtin_va_start_p
)
2624 t
= gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
2625 EXPR_LOCATION (*expr_p
));
2633 /* Verify the function result. */
2634 if (want_value
&& fndecl
2635 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype
))))
2637 error_at (loc
, "using result of function returning %<void%>");
2641 /* Try this again in case gimplification exposed something. */
2642 if (ret
!= GS_ERROR
)
2644 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2646 if (new_tree
&& new_tree
!= *expr_p
)
2648 /* There was a transformation of this call which computes the
2649 same value, but in a more efficient way. Return and try
2657 *expr_p
= error_mark_node
;
2661 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2662 decl. This allows us to eliminate redundant or useless
2663 calls to "const" functions. */
2664 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
2666 int flags
= call_expr_flags (*expr_p
);
2667 if (flags
& (ECF_CONST
| ECF_PURE
)
2668 /* An infinite loop is considered a side effect. */
2669 && !(flags
& (ECF_LOOPING_CONST_OR_PURE
)))
2670 TREE_SIDE_EFFECTS (*expr_p
) = 0;
2673 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2674 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2675 form and delegate the creation of a GIMPLE_CALL to
2676 gimplify_modify_expr. This is always possible because when
2677 WANT_VALUE is true, the caller wants the result of this call into
2678 a temporary, which means that we will emit an INIT_EXPR in
2679 internal_get_tmp_var which will then be handled by
2680 gimplify_modify_expr. */
2683 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2684 have to do is replicate it as a GIMPLE_CALL tuple. */
2685 gimple_stmt_iterator gsi
;
2686 call
= gimple_build_call_from_tree (*expr_p
);
2687 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
2688 notice_special_calls (call
);
2689 gimplify_seq_add_stmt (pre_p
, call
);
2690 gsi
= gsi_last (*pre_p
);
2692 *expr_p
= NULL_TREE
;
2695 /* Remember the original function type. */
2696 CALL_EXPR_FN (*expr_p
) = build1 (NOP_EXPR
, fnptrtype
,
2697 CALL_EXPR_FN (*expr_p
));
2702 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2703 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2705 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2706 condition is true or false, respectively. If null, we should generate
2707 our own to skip over the evaluation of this specific expression.
2709 LOCUS is the source location of the COND_EXPR.
2711 This function is the tree equivalent of do_jump.
2713 shortcut_cond_r should only be called by shortcut_cond_expr. */
2716 shortcut_cond_r (tree pred
, tree
*true_label_p
, tree
*false_label_p
,
2719 tree local_label
= NULL_TREE
;
2720 tree t
, expr
= NULL
;
2722 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2723 retain the shortcut semantics. Just insert the gotos here;
2724 shortcut_cond_expr will append the real blocks later. */
2725 if (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2727 location_t new_locus
;
2729 /* Turn if (a && b) into
2731 if (a); else goto no;
2732 if (b) goto yes; else goto no;
2735 if (false_label_p
== NULL
)
2736 false_label_p
= &local_label
;
2738 /* Keep the original source location on the first 'if'. */
2739 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), NULL
, false_label_p
, locus
);
2740 append_to_statement_list (t
, &expr
);
2742 /* Set the source location of the && on the second 'if'. */
2743 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2744 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2746 append_to_statement_list (t
, &expr
);
2748 else if (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2750 location_t new_locus
;
2752 /* Turn if (a || b) into
2755 if (b) goto yes; else goto no;
2758 if (true_label_p
== NULL
)
2759 true_label_p
= &local_label
;
2761 /* Keep the original source location on the first 'if'. */
2762 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), true_label_p
, NULL
, locus
);
2763 append_to_statement_list (t
, &expr
);
2765 /* Set the source location of the || on the second 'if'. */
2766 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2767 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2769 append_to_statement_list (t
, &expr
);
2771 else if (TREE_CODE (pred
) == COND_EXPR
2772 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 1)))
2773 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 2))))
2775 location_t new_locus
;
2777 /* As long as we're messing with gotos, turn if (a ? b : c) into
2779 if (b) goto yes; else goto no;
2781 if (c) goto yes; else goto no;
2783 Don't do this if one of the arms has void type, which can happen
2784 in C++ when the arm is throw. */
2786 /* Keep the original source location on the first 'if'. Set the source
2787 location of the ? on the second 'if'. */
2788 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2789 expr
= build3 (COND_EXPR
, void_type_node
, TREE_OPERAND (pred
, 0),
2790 shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
,
2791 false_label_p
, locus
),
2792 shortcut_cond_r (TREE_OPERAND (pred
, 2), true_label_p
,
2793 false_label_p
, new_locus
));
2797 expr
= build3 (COND_EXPR
, void_type_node
, pred
,
2798 build_and_jump (true_label_p
),
2799 build_and_jump (false_label_p
));
2800 SET_EXPR_LOCATION (expr
, locus
);
2805 t
= build1 (LABEL_EXPR
, void_type_node
, local_label
);
2806 append_to_statement_list (t
, &expr
);
2812 /* Given a conditional expression EXPR with short-circuit boolean
2813 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2814 predicate apart into the equivalent sequence of conditionals. */
2817 shortcut_cond_expr (tree expr
)
2819 tree pred
= TREE_OPERAND (expr
, 0);
2820 tree then_
= TREE_OPERAND (expr
, 1);
2821 tree else_
= TREE_OPERAND (expr
, 2);
2822 tree true_label
, false_label
, end_label
, t
;
2824 tree
*false_label_p
;
2825 bool emit_end
, emit_false
, jump_over_else
;
2826 bool then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2827 bool else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2829 /* First do simple transformations. */
2832 /* If there is no 'else', turn
2835 if (a) if (b) then c. */
2836 while (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2838 /* Keep the original source location on the first 'if'. */
2839 location_t locus
= EXPR_LOC_OR_HERE (expr
);
2840 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2841 /* Set the source location of the && on the second 'if'. */
2842 if (EXPR_HAS_LOCATION (pred
))
2843 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2844 then_
= shortcut_cond_expr (expr
);
2845 then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2846 pred
= TREE_OPERAND (pred
, 0);
2847 expr
= build3 (COND_EXPR
, void_type_node
, pred
, then_
, NULL_TREE
);
2848 SET_EXPR_LOCATION (expr
, locus
);
2854 /* If there is no 'then', turn
2857 if (a); else if (b); else d. */
2858 while (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2860 /* Keep the original source location on the first 'if'. */
2861 location_t locus
= EXPR_LOC_OR_HERE (expr
);
2862 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2863 /* Set the source location of the || on the second 'if'. */
2864 if (EXPR_HAS_LOCATION (pred
))
2865 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2866 else_
= shortcut_cond_expr (expr
);
2867 else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2868 pred
= TREE_OPERAND (pred
, 0);
2869 expr
= build3 (COND_EXPR
, void_type_node
, pred
, NULL_TREE
, else_
);
2870 SET_EXPR_LOCATION (expr
, locus
);
2874 /* If we're done, great. */
2875 if (TREE_CODE (pred
) != TRUTH_ANDIF_EXPR
2876 && TREE_CODE (pred
) != TRUTH_ORIF_EXPR
)
2879 /* Otherwise we need to mess with gotos. Change
2882 if (a); else goto no;
2885 and recursively gimplify the condition. */
2887 true_label
= false_label
= end_label
= NULL_TREE
;
2889 /* If our arms just jump somewhere, hijack those labels so we don't
2890 generate jumps to jumps. */
2893 && TREE_CODE (then_
) == GOTO_EXPR
2894 && TREE_CODE (GOTO_DESTINATION (then_
)) == LABEL_DECL
)
2896 true_label
= GOTO_DESTINATION (then_
);
2902 && TREE_CODE (else_
) == GOTO_EXPR
2903 && TREE_CODE (GOTO_DESTINATION (else_
)) == LABEL_DECL
)
2905 false_label
= GOTO_DESTINATION (else_
);
2910 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2912 true_label_p
= &true_label
;
2914 true_label_p
= NULL
;
2916 /* The 'else' branch also needs a label if it contains interesting code. */
2917 if (false_label
|| else_se
)
2918 false_label_p
= &false_label
;
2920 false_label_p
= NULL
;
2922 /* If there was nothing else in our arms, just forward the label(s). */
2923 if (!then_se
&& !else_se
)
2924 return shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2925 EXPR_LOC_OR_HERE (expr
));
2927 /* If our last subexpression already has a terminal label, reuse it. */
2929 t
= expr_last (else_
);
2931 t
= expr_last (then_
);
2934 if (t
&& TREE_CODE (t
) == LABEL_EXPR
)
2935 end_label
= LABEL_EXPR_LABEL (t
);
2937 /* If we don't care about jumping to the 'else' branch, jump to the end
2938 if the condition is false. */
2940 false_label_p
= &end_label
;
2942 /* We only want to emit these labels if we aren't hijacking them. */
2943 emit_end
= (end_label
== NULL_TREE
);
2944 emit_false
= (false_label
== NULL_TREE
);
2946 /* We only emit the jump over the else clause if we have to--if the
2947 then clause may fall through. Otherwise we can wind up with a
2948 useless jump and a useless label at the end of gimplified code,
2949 which will cause us to think that this conditional as a whole
2950 falls through even if it doesn't. If we then inline a function
2951 which ends with such a condition, that can cause us to issue an
2952 inappropriate warning about control reaching the end of a
2953 non-void function. */
2954 jump_over_else
= block_may_fallthru (then_
);
2956 pred
= shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2957 EXPR_LOC_OR_HERE (expr
));
2960 append_to_statement_list (pred
, &expr
);
2962 append_to_statement_list (then_
, &expr
);
2967 tree last
= expr_last (expr
);
2968 t
= build_and_jump (&end_label
);
2969 if (EXPR_HAS_LOCATION (last
))
2970 SET_EXPR_LOCATION (t
, EXPR_LOCATION (last
));
2971 append_to_statement_list (t
, &expr
);
2975 t
= build1 (LABEL_EXPR
, void_type_node
, false_label
);
2976 append_to_statement_list (t
, &expr
);
2978 append_to_statement_list (else_
, &expr
);
2980 if (emit_end
&& end_label
)
2982 t
= build1 (LABEL_EXPR
, void_type_node
, end_label
);
2983 append_to_statement_list (t
, &expr
);
2989 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2992 gimple_boolify (tree expr
)
2994 tree type
= TREE_TYPE (expr
);
2995 location_t loc
= EXPR_LOCATION (expr
);
2997 if (TREE_CODE (expr
) == NE_EXPR
2998 && TREE_CODE (TREE_OPERAND (expr
, 0)) == CALL_EXPR
2999 && integer_zerop (TREE_OPERAND (expr
, 1)))
3001 tree call
= TREE_OPERAND (expr
, 0);
3002 tree fn
= get_callee_fndecl (call
);
3004 /* For __builtin_expect ((long) (x), y) recurse into x as well
3005 if x is truth_value_p. */
3007 && DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
3008 && DECL_FUNCTION_CODE (fn
) == BUILT_IN_EXPECT
3009 && call_expr_nargs (call
) == 2)
3011 tree arg
= CALL_EXPR_ARG (call
, 0);
3014 if (TREE_CODE (arg
) == NOP_EXPR
3015 && TREE_TYPE (arg
) == TREE_TYPE (call
))
3016 arg
= TREE_OPERAND (arg
, 0);
3017 if (truth_value_p (TREE_CODE (arg
)))
3019 arg
= gimple_boolify (arg
);
3020 CALL_EXPR_ARG (call
, 0)
3021 = fold_convert_loc (loc
, TREE_TYPE (call
), arg
);
3027 switch (TREE_CODE (expr
))
3029 case TRUTH_AND_EXPR
:
3031 case TRUTH_XOR_EXPR
:
3032 case TRUTH_ANDIF_EXPR
:
3033 case TRUTH_ORIF_EXPR
:
3034 /* Also boolify the arguments of truth exprs. */
3035 TREE_OPERAND (expr
, 1) = gimple_boolify (TREE_OPERAND (expr
, 1));
3038 case TRUTH_NOT_EXPR
:
3039 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3041 /* These expressions always produce boolean results. */
3042 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3043 TREE_TYPE (expr
) = boolean_type_node
;
3047 if (COMPARISON_CLASS_P (expr
))
3049 /* There expressions always prduce boolean results. */
3050 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3051 TREE_TYPE (expr
) = boolean_type_node
;
3054 /* Other expressions that get here must have boolean values, but
3055 might need to be converted to the appropriate mode. */
3056 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
3058 return fold_convert_loc (loc
, boolean_type_node
, expr
);
3062 /* Given a conditional expression *EXPR_P without side effects, gimplify
3063 its operands. New statements are inserted to PRE_P. */
3065 static enum gimplify_status
3066 gimplify_pure_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
)
3068 tree expr
= *expr_p
, cond
;
3069 enum gimplify_status ret
, tret
;
3070 enum tree_code code
;
3072 cond
= gimple_boolify (COND_EXPR_COND (expr
));
3074 /* We need to handle && and || specially, as their gimplification
3075 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
3076 code
= TREE_CODE (cond
);
3077 if (code
== TRUTH_ANDIF_EXPR
)
3078 TREE_SET_CODE (cond
, TRUTH_AND_EXPR
);
3079 else if (code
== TRUTH_ORIF_EXPR
)
3080 TREE_SET_CODE (cond
, TRUTH_OR_EXPR
);
3081 ret
= gimplify_expr (&cond
, pre_p
, NULL
, is_gimple_condexpr
, fb_rvalue
);
3082 COND_EXPR_COND (*expr_p
) = cond
;
3084 tret
= gimplify_expr (&COND_EXPR_THEN (expr
), pre_p
, NULL
,
3085 is_gimple_val
, fb_rvalue
);
3086 ret
= MIN (ret
, tret
);
3087 tret
= gimplify_expr (&COND_EXPR_ELSE (expr
), pre_p
, NULL
,
3088 is_gimple_val
, fb_rvalue
);
3090 return MIN (ret
, tret
);
3093 /* Return true if evaluating EXPR could trap.
3094 EXPR is GENERIC, while tree_could_trap_p can be called
3098 generic_expr_could_trap_p (tree expr
)
3102 if (!expr
|| is_gimple_val (expr
))
3105 if (!EXPR_P (expr
) || tree_could_trap_p (expr
))
3108 n
= TREE_OPERAND_LENGTH (expr
);
3109 for (i
= 0; i
< n
; i
++)
3110 if (generic_expr_could_trap_p (TREE_OPERAND (expr
, i
)))
3116 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3125 The second form is used when *EXPR_P is of type void.
3127 PRE_P points to the list where side effects that must happen before
3128 *EXPR_P should be stored. */
3130 static enum gimplify_status
3131 gimplify_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
, fallback_t fallback
)
3133 tree expr
= *expr_p
;
3134 tree type
= TREE_TYPE (expr
);
3135 location_t loc
= EXPR_LOCATION (expr
);
3136 tree tmp
, arm1
, arm2
;
3137 enum gimplify_status ret
;
3138 tree label_true
, label_false
, label_cont
;
3139 bool have_then_clause_p
, have_else_clause_p
;
3141 enum tree_code pred_code
;
3142 gimple_seq seq
= NULL
;
3144 /* If this COND_EXPR has a value, copy the values into a temporary within
3146 if (!VOID_TYPE_P (type
))
3148 tree then_
= TREE_OPERAND (expr
, 1), else_
= TREE_OPERAND (expr
, 2);
3151 /* If either an rvalue is ok or we do not require an lvalue, create the
3152 temporary. But we cannot do that if the type is addressable. */
3153 if (((fallback
& fb_rvalue
) || !(fallback
& fb_lvalue
))
3154 && !TREE_ADDRESSABLE (type
))
3156 if (gimplify_ctxp
->allow_rhs_cond_expr
3157 /* If either branch has side effects or could trap, it can't be
3158 evaluated unconditionally. */
3159 && !TREE_SIDE_EFFECTS (then_
)
3160 && !generic_expr_could_trap_p (then_
)
3161 && !TREE_SIDE_EFFECTS (else_
)
3162 && !generic_expr_could_trap_p (else_
))
3163 return gimplify_pure_cond_expr (expr_p
, pre_p
);
3165 tmp
= create_tmp_var (type
, "iftmp");
3169 /* Otherwise, only create and copy references to the values. */
3172 type
= build_pointer_type (type
);
3174 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3175 then_
= build_fold_addr_expr_loc (loc
, then_
);
3177 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3178 else_
= build_fold_addr_expr_loc (loc
, else_
);
3181 = build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0), then_
, else_
);
3183 tmp
= create_tmp_var (type
, "iftmp");
3184 result
= build_simple_mem_ref_loc (loc
, tmp
);
3187 /* Build the new then clause, `tmp = then_;'. But don't build the
3188 assignment if the value is void; in C++ it can be if it's a throw. */
3189 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3190 TREE_OPERAND (expr
, 1) = build2 (MODIFY_EXPR
, type
, tmp
, then_
);
3192 /* Similarly, build the new else clause, `tmp = else_;'. */
3193 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3194 TREE_OPERAND (expr
, 2) = build2 (MODIFY_EXPR
, type
, tmp
, else_
);
3196 TREE_TYPE (expr
) = void_type_node
;
3197 recalculate_side_effects (expr
);
3199 /* Move the COND_EXPR to the prequeue. */
3200 gimplify_stmt (&expr
, pre_p
);
3206 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
3207 STRIP_TYPE_NOPS (TREE_OPERAND (expr
, 0));
3208 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == COMPOUND_EXPR
)
3209 gimplify_compound_expr (&TREE_OPERAND (expr
, 0), pre_p
, true);
3211 /* Make sure the condition has BOOLEAN_TYPE. */
3212 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3214 /* Break apart && and || conditions. */
3215 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ANDIF_EXPR
3216 || TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ORIF_EXPR
)
3218 expr
= shortcut_cond_expr (expr
);
3220 if (expr
!= *expr_p
)
3224 /* We can't rely on gimplify_expr to re-gimplify the expanded
3225 form properly, as cleanups might cause the target labels to be
3226 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3227 set up a conditional context. */
3228 gimple_push_condition ();
3229 gimplify_stmt (expr_p
, &seq
);
3230 gimple_pop_condition (pre_p
);
3231 gimple_seq_add_seq (pre_p
, seq
);
3237 /* Now do the normal gimplification. */
3239 /* Gimplify condition. */
3240 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, NULL
, is_gimple_condexpr
,
3242 if (ret
== GS_ERROR
)
3244 gcc_assert (TREE_OPERAND (expr
, 0) != NULL_TREE
);
3246 gimple_push_condition ();
3248 have_then_clause_p
= have_else_clause_p
= false;
3249 if (TREE_OPERAND (expr
, 1) != NULL
3250 && TREE_CODE (TREE_OPERAND (expr
, 1)) == GOTO_EXPR
3251 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 1))) == LABEL_DECL
3252 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 1)))
3253 == current_function_decl
)
3254 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3255 have different locations, otherwise we end up with incorrect
3256 location information on the branches. */
3258 || !EXPR_HAS_LOCATION (expr
)
3259 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 1))
3260 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 1))))
3262 label_true
= GOTO_DESTINATION (TREE_OPERAND (expr
, 1));
3263 have_then_clause_p
= true;
3266 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
3267 if (TREE_OPERAND (expr
, 2) != NULL
3268 && TREE_CODE (TREE_OPERAND (expr
, 2)) == GOTO_EXPR
3269 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 2))) == LABEL_DECL
3270 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 2)))
3271 == current_function_decl
)
3272 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3273 have different locations, otherwise we end up with incorrect
3274 location information on the branches. */
3276 || !EXPR_HAS_LOCATION (expr
)
3277 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 2))
3278 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 2))))
3280 label_false
= GOTO_DESTINATION (TREE_OPERAND (expr
, 2));
3281 have_else_clause_p
= true;
3284 label_false
= create_artificial_label (UNKNOWN_LOCATION
);
3286 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr
), &pred_code
, &arm1
,
3289 gimple_cond
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
,
3292 gimplify_seq_add_stmt (&seq
, gimple_cond
);
3293 label_cont
= NULL_TREE
;
3294 if (!have_then_clause_p
)
3296 /* For if (...) {} else { code; } put label_true after
3298 if (TREE_OPERAND (expr
, 1) == NULL_TREE
3299 && !have_else_clause_p
3300 && TREE_OPERAND (expr
, 2) != NULL_TREE
)
3301 label_cont
= label_true
;
3304 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_true
));
3305 have_then_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 1), &seq
);
3306 /* For if (...) { code; } else {} or
3307 if (...) { code; } else goto label; or
3308 if (...) { code; return; } else { ... }
3309 label_cont isn't needed. */
3310 if (!have_else_clause_p
3311 && TREE_OPERAND (expr
, 2) != NULL_TREE
3312 && gimple_seq_may_fallthru (seq
))
3315 label_cont
= create_artificial_label (UNKNOWN_LOCATION
);
3317 g
= gimple_build_goto (label_cont
);
3319 /* GIMPLE_COND's are very low level; they have embedded
3320 gotos. This particular embedded goto should not be marked
3321 with the location of the original COND_EXPR, as it would
3322 correspond to the COND_EXPR's condition, not the ELSE or the
3323 THEN arms. To avoid marking it with the wrong location, flag
3324 it as "no location". */
3325 gimple_set_do_not_emit_location (g
);
3327 gimplify_seq_add_stmt (&seq
, g
);
3331 if (!have_else_clause_p
)
3333 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_false
));
3334 have_else_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 2), &seq
);
3337 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_cont
));
3339 gimple_pop_condition (pre_p
);
3340 gimple_seq_add_seq (pre_p
, seq
);
3342 if (ret
== GS_ERROR
)
3344 else if (have_then_clause_p
|| have_else_clause_p
)
3348 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3349 expr
= TREE_OPERAND (expr
, 0);
3350 gimplify_stmt (&expr
, pre_p
);
3357 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3358 to be marked addressable.
3360 We cannot rely on such an expression being directly markable if a temporary
3361 has been created by the gimplification. In this case, we create another
3362 temporary and initialize it with a copy, which will become a store after we
3363 mark it addressable. This can happen if the front-end passed us something
3364 that it could not mark addressable yet, like a Fortran pass-by-reference
3365 parameter (int) floatvar. */
3368 prepare_gimple_addressable (tree
*expr_p
, gimple_seq
*seq_p
)
3370 while (handled_component_p (*expr_p
))
3371 expr_p
= &TREE_OPERAND (*expr_p
, 0);
3372 if (is_gimple_reg (*expr_p
))
3373 *expr_p
= get_initialized_tmp_var (*expr_p
, seq_p
, NULL
);
3376 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3377 a call to __builtin_memcpy. */
3379 static enum gimplify_status
3380 gimplify_modify_expr_to_memcpy (tree
*expr_p
, tree size
, bool want_value
,
3383 tree t
, to
, to_ptr
, from
, from_ptr
;
3385 location_t loc
= EXPR_LOCATION (*expr_p
);
3387 to
= TREE_OPERAND (*expr_p
, 0);
3388 from
= TREE_OPERAND (*expr_p
, 1);
3390 /* Mark the RHS addressable. Beware that it may not be possible to do so
3391 directly if a temporary has been created by the gimplification. */
3392 prepare_gimple_addressable (&from
, seq_p
);
3394 mark_addressable (from
);
3395 from_ptr
= build_fold_addr_expr_loc (loc
, from
);
3396 gimplify_arg (&from_ptr
, seq_p
, loc
);
3398 mark_addressable (to
);
3399 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3400 gimplify_arg (&to_ptr
, seq_p
, loc
);
3402 t
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3404 gs
= gimple_build_call (t
, 3, to_ptr
, from_ptr
, size
);
3408 /* tmp = memcpy() */
3409 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3410 gimple_call_set_lhs (gs
, t
);
3411 gimplify_seq_add_stmt (seq_p
, gs
);
3413 *expr_p
= build_simple_mem_ref (t
);
3417 gimplify_seq_add_stmt (seq_p
, gs
);
3422 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3423 a call to __builtin_memset. In this case we know that the RHS is
3424 a CONSTRUCTOR with an empty element list. */
3426 static enum gimplify_status
3427 gimplify_modify_expr_to_memset (tree
*expr_p
, tree size
, bool want_value
,
3430 tree t
, from
, to
, to_ptr
;
3432 location_t loc
= EXPR_LOCATION (*expr_p
);
3434 /* Assert our assumptions, to abort instead of producing wrong code
3435 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3436 not be immediately exposed. */
3437 from
= TREE_OPERAND (*expr_p
, 1);
3438 if (TREE_CODE (from
) == WITH_SIZE_EXPR
)
3439 from
= TREE_OPERAND (from
, 0);
3441 gcc_assert (TREE_CODE (from
) == CONSTRUCTOR
3442 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from
)));
3445 to
= TREE_OPERAND (*expr_p
, 0);
3447 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3448 gimplify_arg (&to_ptr
, seq_p
, loc
);
3449 t
= builtin_decl_implicit (BUILT_IN_MEMSET
);
3451 gs
= gimple_build_call (t
, 3, to_ptr
, integer_zero_node
, size
);
3455 /* tmp = memset() */
3456 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3457 gimple_call_set_lhs (gs
, t
);
3458 gimplify_seq_add_stmt (seq_p
, gs
);
3460 *expr_p
= build1 (INDIRECT_REF
, TREE_TYPE (to
), t
);
3464 gimplify_seq_add_stmt (seq_p
, gs
);
3469 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3470 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3471 assignment. Return non-null if we detect a potential overlap. */
3473 struct gimplify_init_ctor_preeval_data
3475 /* The base decl of the lhs object. May be NULL, in which case we
3476 have to assume the lhs is indirect. */
3479 /* The alias set of the lhs object. */
3480 alias_set_type lhs_alias_set
;
3484 gimplify_init_ctor_preeval_1 (tree
*tp
, int *walk_subtrees
, void *xdata
)
3486 struct gimplify_init_ctor_preeval_data
*data
3487 = (struct gimplify_init_ctor_preeval_data
*) xdata
;
3490 /* If we find the base object, obviously we have overlap. */
3491 if (data
->lhs_base_decl
== t
)
3494 /* If the constructor component is indirect, determine if we have a
3495 potential overlap with the lhs. The only bits of information we
3496 have to go on at this point are addressability and alias sets. */
3497 if ((INDIRECT_REF_P (t
)
3498 || TREE_CODE (t
) == MEM_REF
)
3499 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3500 && alias_sets_conflict_p (data
->lhs_alias_set
, get_alias_set (t
)))
3503 /* If the constructor component is a call, determine if it can hide a
3504 potential overlap with the lhs through an INDIRECT_REF like above.
3505 ??? Ugh - this is completely broken. In fact this whole analysis
3506 doesn't look conservative. */
3507 if (TREE_CODE (t
) == CALL_EXPR
)
3509 tree type
, fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t
)));
3511 for (type
= TYPE_ARG_TYPES (fntype
); type
; type
= TREE_CHAIN (type
))
3512 if (POINTER_TYPE_P (TREE_VALUE (type
))
3513 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3514 && alias_sets_conflict_p (data
->lhs_alias_set
,
3516 (TREE_TYPE (TREE_VALUE (type
)))))
3520 if (IS_TYPE_OR_DECL_P (t
))
3525 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3526 force values that overlap with the lhs (as described by *DATA)
3527 into temporaries. */
3530 gimplify_init_ctor_preeval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3531 struct gimplify_init_ctor_preeval_data
*data
)
3533 enum gimplify_status one
;
3535 /* If the value is constant, then there's nothing to pre-evaluate. */
3536 if (TREE_CONSTANT (*expr_p
))
3538 /* Ensure it does not have side effects, it might contain a reference to
3539 the object we're initializing. */
3540 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p
));
3544 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3545 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p
)))
3548 /* Recurse for nested constructors. */
3549 if (TREE_CODE (*expr_p
) == CONSTRUCTOR
)
3551 unsigned HOST_WIDE_INT ix
;
3552 constructor_elt
*ce
;
3553 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (*expr_p
);
3555 FOR_EACH_VEC_SAFE_ELT (v
, ix
, ce
)
3556 gimplify_init_ctor_preeval (&ce
->value
, pre_p
, post_p
, data
);
3561 /* If this is a variable sized type, we must remember the size. */
3562 maybe_with_size_expr (expr_p
);
3564 /* Gimplify the constructor element to something appropriate for the rhs
3565 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3566 the gimplifier will consider this a store to memory. Doing this
3567 gimplification now means that we won't have to deal with complicated
3568 language-specific trees, nor trees like SAVE_EXPR that can induce
3569 exponential search behavior. */
3570 one
= gimplify_expr (expr_p
, pre_p
, post_p
, is_gimple_mem_rhs
, fb_rvalue
);
3571 if (one
== GS_ERROR
)
3577 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3578 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3579 always be true for all scalars, since is_gimple_mem_rhs insists on a
3580 temporary variable for them. */
3581 if (DECL_P (*expr_p
))
3584 /* If this is of variable size, we have no choice but to assume it doesn't
3585 overlap since we can't make a temporary for it. */
3586 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p
))) != INTEGER_CST
)
3589 /* Otherwise, we must search for overlap ... */
3590 if (!walk_tree (expr_p
, gimplify_init_ctor_preeval_1
, data
, NULL
))
3593 /* ... and if found, force the value into a temporary. */
3594 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
3597 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3598 a RANGE_EXPR in a CONSTRUCTOR for an array.
3602 object[var] = value;
3609 We increment var _after_ the loop exit check because we might otherwise
3610 fail if upper == TYPE_MAX_VALUE (type for upper).
3612 Note that we never have to deal with SAVE_EXPRs here, because this has
3613 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3615 static void gimplify_init_ctor_eval (tree
, vec
<constructor_elt
, va_gc
> *,
3616 gimple_seq
*, bool);
3619 gimplify_init_ctor_eval_range (tree object
, tree lower
, tree upper
,
3620 tree value
, tree array_elt_type
,
3621 gimple_seq
*pre_p
, bool cleared
)
3623 tree loop_entry_label
, loop_exit_label
, fall_thru_label
;
3624 tree var
, var_type
, cref
, tmp
;
3626 loop_entry_label
= create_artificial_label (UNKNOWN_LOCATION
);
3627 loop_exit_label
= create_artificial_label (UNKNOWN_LOCATION
);
3628 fall_thru_label
= create_artificial_label (UNKNOWN_LOCATION
);
3630 /* Create and initialize the index variable. */
3631 var_type
= TREE_TYPE (upper
);
3632 var
= create_tmp_var (var_type
, NULL
);
3633 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, lower
));
3635 /* Add the loop entry label. */
3636 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_entry_label
));
3638 /* Build the reference. */
3639 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3640 var
, NULL_TREE
, NULL_TREE
);
3642 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3643 the store. Otherwise just assign value to the reference. */
3645 if (TREE_CODE (value
) == CONSTRUCTOR
)
3646 /* NB we might have to call ourself recursively through
3647 gimplify_init_ctor_eval if the value is a constructor. */
3648 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3651 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (cref
, value
));
3653 /* We exit the loop when the index var is equal to the upper bound. */
3654 gimplify_seq_add_stmt (pre_p
,
3655 gimple_build_cond (EQ_EXPR
, var
, upper
,
3656 loop_exit_label
, fall_thru_label
));
3658 gimplify_seq_add_stmt (pre_p
, gimple_build_label (fall_thru_label
));
3660 /* Otherwise, increment the index var... */
3661 tmp
= build2 (PLUS_EXPR
, var_type
, var
,
3662 fold_convert (var_type
, integer_one_node
));
3663 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, tmp
));
3665 /* ...and jump back to the loop entry. */
3666 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (loop_entry_label
));
3668 /* Add the loop exit label. */
3669 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_exit_label
));
3672 /* Return true if FDECL is accessing a field that is zero sized. */
3675 zero_sized_field_decl (const_tree fdecl
)
3677 if (TREE_CODE (fdecl
) == FIELD_DECL
&& DECL_SIZE (fdecl
)
3678 && integer_zerop (DECL_SIZE (fdecl
)))
3683 /* Return true if TYPE is zero sized. */
3686 zero_sized_type (const_tree type
)
3688 if (AGGREGATE_TYPE_P (type
) && TYPE_SIZE (type
)
3689 && integer_zerop (TYPE_SIZE (type
)))
3694 /* A subroutine of gimplify_init_constructor. Generate individual
3695 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3696 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3697 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3701 gimplify_init_ctor_eval (tree object
, vec
<constructor_elt
, va_gc
> *elts
,
3702 gimple_seq
*pre_p
, bool cleared
)
3704 tree array_elt_type
= NULL
;
3705 unsigned HOST_WIDE_INT ix
;
3706 tree purpose
, value
;
3708 if (TREE_CODE (TREE_TYPE (object
)) == ARRAY_TYPE
)
3709 array_elt_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object
)));
3711 FOR_EACH_CONSTRUCTOR_ELT (elts
, ix
, purpose
, value
)
3715 /* NULL values are created above for gimplification errors. */
3719 if (cleared
&& initializer_zerop (value
))
3722 /* ??? Here's to hoping the front end fills in all of the indices,
3723 so we don't have to figure out what's missing ourselves. */
3724 gcc_assert (purpose
);
3726 /* Skip zero-sized fields, unless value has side-effects. This can
3727 happen with calls to functions returning a zero-sized type, which
3728 we shouldn't discard. As a number of downstream passes don't
3729 expect sets of zero-sized fields, we rely on the gimplification of
3730 the MODIFY_EXPR we make below to drop the assignment statement. */
3731 if (! TREE_SIDE_EFFECTS (value
) && zero_sized_field_decl (purpose
))
3734 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3736 if (TREE_CODE (purpose
) == RANGE_EXPR
)
3738 tree lower
= TREE_OPERAND (purpose
, 0);
3739 tree upper
= TREE_OPERAND (purpose
, 1);
3741 /* If the lower bound is equal to upper, just treat it as if
3742 upper was the index. */
3743 if (simple_cst_equal (lower
, upper
))
3747 gimplify_init_ctor_eval_range (object
, lower
, upper
, value
,
3748 array_elt_type
, pre_p
, cleared
);
3755 /* Do not use bitsizetype for ARRAY_REF indices. */
3756 if (TYPE_DOMAIN (TREE_TYPE (object
)))
3758 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object
))),
3760 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3761 purpose
, NULL_TREE
, NULL_TREE
);
3765 gcc_assert (TREE_CODE (purpose
) == FIELD_DECL
);
3766 cref
= build3 (COMPONENT_REF
, TREE_TYPE (purpose
),
3767 unshare_expr (object
), purpose
, NULL_TREE
);
3770 if (TREE_CODE (value
) == CONSTRUCTOR
3771 && TREE_CODE (TREE_TYPE (value
)) != VECTOR_TYPE
)
3772 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3776 tree init
= build2 (INIT_EXPR
, TREE_TYPE (cref
), cref
, value
);
3777 gimplify_and_add (init
, pre_p
);
3783 /* Return the appropriate RHS predicate for this LHS. */
3786 rhs_predicate_for (tree lhs
)
3788 if (is_gimple_reg (lhs
))
3789 return is_gimple_reg_rhs_or_call
;
3791 return is_gimple_mem_rhs_or_call
;
3794 /* Gimplify a C99 compound literal expression. This just means adding
3795 the DECL_EXPR before the current statement and using its anonymous
3798 static enum gimplify_status
3799 gimplify_compound_literal_expr (tree
*expr_p
, gimple_seq
*pre_p
,
3800 bool (*gimple_test_f
) (tree
),
3801 fallback_t fallback
)
3803 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p
);
3804 tree decl
= DECL_EXPR_DECL (decl_s
);
3805 tree init
= DECL_INITIAL (decl
);
3806 /* Mark the decl as addressable if the compound literal
3807 expression is addressable now, otherwise it is marked too late
3808 after we gimplify the initialization expression. */
3809 if (TREE_ADDRESSABLE (*expr_p
))
3810 TREE_ADDRESSABLE (decl
) = 1;
3811 /* Otherwise, if we don't need an lvalue and have a literal directly
3812 substitute it. Check if it matches the gimple predicate, as
3813 otherwise we'd generate a new temporary, and we can as well just
3814 use the decl we already have. */
3815 else if (!TREE_ADDRESSABLE (decl
)
3817 && (fallback
& fb_lvalue
) == 0
3818 && gimple_test_f (init
))
3824 /* Preliminarily mark non-addressed complex variables as eligible
3825 for promotion to gimple registers. We'll transform their uses
3827 if ((TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
3828 || TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
)
3829 && !TREE_THIS_VOLATILE (decl
)
3830 && !needs_to_live_in_memory (decl
))
3831 DECL_GIMPLE_REG_P (decl
) = 1;
3833 /* If the decl is not addressable, then it is being used in some
3834 expression or on the right hand side of a statement, and it can
3835 be put into a readonly data section. */
3836 if (!TREE_ADDRESSABLE (decl
) && (fallback
& fb_lvalue
) == 0)
3837 TREE_READONLY (decl
) = 1;
3839 /* This decl isn't mentioned in the enclosing block, so add it to the
3840 list of temps. FIXME it seems a bit of a kludge to say that
3841 anonymous artificial vars aren't pushed, but everything else is. */
3842 if (DECL_NAME (decl
) == NULL_TREE
&& !DECL_SEEN_IN_BIND_EXPR_P (decl
))
3843 gimple_add_tmp_var (decl
);
3845 gimplify_and_add (decl_s
, pre_p
);
3850 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3851 return a new CONSTRUCTOR if something changed. */
3854 optimize_compound_literals_in_ctor (tree orig_ctor
)
3856 tree ctor
= orig_ctor
;
3857 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
3858 unsigned int idx
, num
= vec_safe_length (elts
);
3860 for (idx
= 0; idx
< num
; idx
++)
3862 tree value
= (*elts
)[idx
].value
;
3863 tree newval
= value
;
3864 if (TREE_CODE (value
) == CONSTRUCTOR
)
3865 newval
= optimize_compound_literals_in_ctor (value
);
3866 else if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
3868 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (value
);
3869 tree decl
= DECL_EXPR_DECL (decl_s
);
3870 tree init
= DECL_INITIAL (decl
);
3872 if (!TREE_ADDRESSABLE (value
)
3873 && !TREE_ADDRESSABLE (decl
)
3875 && TREE_CODE (init
) == CONSTRUCTOR
)
3876 newval
= optimize_compound_literals_in_ctor (init
);
3878 if (newval
== value
)
3881 if (ctor
== orig_ctor
)
3883 ctor
= copy_node (orig_ctor
);
3884 CONSTRUCTOR_ELTS (ctor
) = vec_safe_copy (elts
);
3885 elts
= CONSTRUCTOR_ELTS (ctor
);
3887 (*elts
)[idx
].value
= newval
;
3892 /* A subroutine of gimplify_modify_expr. Break out elements of a
3893 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3895 Note that we still need to clear any elements that don't have explicit
3896 initializers, so if not all elements are initialized we keep the
3897 original MODIFY_EXPR, we just remove all of the constructor elements.
3899 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3900 GS_ERROR if we would have to create a temporary when gimplifying
3901 this constructor. Otherwise, return GS_OK.
3903 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3905 static enum gimplify_status
3906 gimplify_init_constructor (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3907 bool want_value
, bool notify_temp_creation
)
3909 tree object
, ctor
, type
;
3910 enum gimplify_status ret
;
3911 vec
<constructor_elt
, va_gc
> *elts
;
3913 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == CONSTRUCTOR
);
3915 if (!notify_temp_creation
)
3917 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
3918 is_gimple_lvalue
, fb_lvalue
);
3919 if (ret
== GS_ERROR
)
3923 object
= TREE_OPERAND (*expr_p
, 0);
3924 ctor
= TREE_OPERAND (*expr_p
, 1) =
3925 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p
, 1));
3926 type
= TREE_TYPE (ctor
);
3927 elts
= CONSTRUCTOR_ELTS (ctor
);
3930 switch (TREE_CODE (type
))
3934 case QUAL_UNION_TYPE
:
3937 struct gimplify_init_ctor_preeval_data preeval_data
;
3938 HOST_WIDE_INT num_ctor_elements
, num_nonzero_elements
;
3939 bool cleared
, complete_p
, valid_const_initializer
;
3941 /* Aggregate types must lower constructors to initialization of
3942 individual elements. The exception is that a CONSTRUCTOR node
3943 with no elements indicates zero-initialization of the whole. */
3944 if (vec_safe_is_empty (elts
))
3946 if (notify_temp_creation
)
3951 /* Fetch information about the constructor to direct later processing.
3952 We might want to make static versions of it in various cases, and
3953 can only do so if it known to be a valid constant initializer. */
3954 valid_const_initializer
3955 = categorize_ctor_elements (ctor
, &num_nonzero_elements
,
3956 &num_ctor_elements
, &complete_p
);
3958 /* If a const aggregate variable is being initialized, then it
3959 should never be a lose to promote the variable to be static. */
3960 if (valid_const_initializer
3961 && num_nonzero_elements
> 1
3962 && TREE_READONLY (object
)
3963 && TREE_CODE (object
) == VAR_DECL
3964 && (flag_merge_constants
>= 2 || !TREE_ADDRESSABLE (object
)))
3966 if (notify_temp_creation
)
3968 DECL_INITIAL (object
) = ctor
;
3969 TREE_STATIC (object
) = 1;
3970 if (!DECL_NAME (object
))
3971 DECL_NAME (object
) = create_tmp_var_name ("C");
3972 walk_tree (&DECL_INITIAL (object
), force_labels_r
, NULL
, NULL
);
3974 /* ??? C++ doesn't automatically append a .<number> to the
3975 assembler name, and even when it does, it looks at FE private
3976 data structures to figure out what that number should be,
3977 which are not set for this variable. I suppose this is
3978 important for local statics for inline functions, which aren't
3979 "local" in the object file sense. So in order to get a unique
3980 TU-local symbol, we must invoke the lhd version now. */
3981 lhd_set_decl_assembler_name (object
);
3983 *expr_p
= NULL_TREE
;
3987 /* If there are "lots" of initialized elements, even discounting
3988 those that are not address constants (and thus *must* be
3989 computed at runtime), then partition the constructor into
3990 constant and non-constant parts. Block copy the constant
3991 parts in, then generate code for the non-constant parts. */
3992 /* TODO. There's code in cp/typeck.c to do this. */
3994 if (int_size_in_bytes (TREE_TYPE (ctor
)) < 0)
3995 /* store_constructor will ignore the clearing of variable-sized
3996 objects. Initializers for such objects must explicitly set
3997 every field that needs to be set. */
3999 else if (!complete_p
)
4000 /* If the constructor isn't complete, clear the whole object
4003 ??? This ought not to be needed. For any element not present
4004 in the initializer, we should simply set them to zero. Except
4005 we'd need to *find* the elements that are not present, and that
4006 requires trickery to avoid quadratic compile-time behavior in
4007 large cases or excessive memory use in small cases. */
4009 else if (num_ctor_elements
- num_nonzero_elements
4010 > CLEAR_RATIO (optimize_function_for_speed_p (cfun
))
4011 && num_nonzero_elements
< num_ctor_elements
/ 4)
4012 /* If there are "lots" of zeros, it's more efficient to clear
4013 the memory and then set the nonzero elements. */
4018 /* If there are "lots" of initialized elements, and all of them
4019 are valid address constants, then the entire initializer can
4020 be dropped to memory, and then memcpy'd out. Don't do this
4021 for sparse arrays, though, as it's more efficient to follow
4022 the standard CONSTRUCTOR behavior of memset followed by
4023 individual element initialization. Also don't do this for small
4024 all-zero initializers (which aren't big enough to merit
4025 clearing), and don't try to make bitwise copies of
4026 TREE_ADDRESSABLE types. */
4027 if (valid_const_initializer
4028 && !(cleared
|| num_nonzero_elements
== 0)
4029 && !TREE_ADDRESSABLE (type
))
4031 HOST_WIDE_INT size
= int_size_in_bytes (type
);
4034 /* ??? We can still get unbounded array types, at least
4035 from the C++ front end. This seems wrong, but attempt
4036 to work around it for now. */
4039 size
= int_size_in_bytes (TREE_TYPE (object
));
4041 TREE_TYPE (ctor
) = type
= TREE_TYPE (object
);
4044 /* Find the maximum alignment we can assume for the object. */
4045 /* ??? Make use of DECL_OFFSET_ALIGN. */
4046 if (DECL_P (object
))
4047 align
= DECL_ALIGN (object
);
4049 align
= TYPE_ALIGN (type
);
4051 /* Do a block move either if the size is so small as to make
4052 each individual move a sub-unit move on average, or if it
4053 is so large as to make individual moves inefficient. */
4055 && num_nonzero_elements
> 1
4056 && (size
< num_nonzero_elements
4057 || !can_move_by_pieces (size
, align
)))
4059 if (notify_temp_creation
)
4062 walk_tree (&ctor
, force_labels_r
, NULL
, NULL
);
4063 ctor
= tree_output_constant_def (ctor
);
4064 if (!useless_type_conversion_p (type
, TREE_TYPE (ctor
)))
4065 ctor
= build1 (VIEW_CONVERT_EXPR
, type
, ctor
);
4066 TREE_OPERAND (*expr_p
, 1) = ctor
;
4068 /* This is no longer an assignment of a CONSTRUCTOR, but
4069 we still may have processing to do on the LHS. So
4070 pretend we didn't do anything here to let that happen. */
4071 return GS_UNHANDLED
;
4075 /* If the target is volatile, we have non-zero elements and more than
4076 one field to assign, initialize the target from a temporary. */
4077 if (TREE_THIS_VOLATILE (object
)
4078 && !TREE_ADDRESSABLE (type
)
4079 && num_nonzero_elements
> 0
4080 && vec_safe_length (elts
) > 1)
4082 tree temp
= create_tmp_var (TYPE_MAIN_VARIANT (type
), NULL
);
4083 TREE_OPERAND (*expr_p
, 0) = temp
;
4084 *expr_p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*expr_p
),
4086 build2 (MODIFY_EXPR
, void_type_node
,
4091 if (notify_temp_creation
)
4094 /* If there are nonzero elements and if needed, pre-evaluate to capture
4095 elements overlapping with the lhs into temporaries. We must do this
4096 before clearing to fetch the values before they are zeroed-out. */
4097 if (num_nonzero_elements
> 0 && TREE_CODE (*expr_p
) != INIT_EXPR
)
4099 preeval_data
.lhs_base_decl
= get_base_address (object
);
4100 if (!DECL_P (preeval_data
.lhs_base_decl
))
4101 preeval_data
.lhs_base_decl
= NULL
;
4102 preeval_data
.lhs_alias_set
= get_alias_set (object
);
4104 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p
, 1),
4105 pre_p
, post_p
, &preeval_data
);
4110 /* Zap the CONSTRUCTOR element list, which simplifies this case.
4111 Note that we still have to gimplify, in order to handle the
4112 case of variable sized types. Avoid shared tree structures. */
4113 CONSTRUCTOR_ELTS (ctor
) = NULL
;
4114 TREE_SIDE_EFFECTS (ctor
) = 0;
4115 object
= unshare_expr (object
);
4116 gimplify_stmt (expr_p
, pre_p
);
4119 /* If we have not block cleared the object, or if there are nonzero
4120 elements in the constructor, add assignments to the individual
4121 scalar fields of the object. */
4122 if (!cleared
|| num_nonzero_elements
> 0)
4123 gimplify_init_ctor_eval (object
, elts
, pre_p
, cleared
);
4125 *expr_p
= NULL_TREE
;
4133 if (notify_temp_creation
)
4136 /* Extract the real and imaginary parts out of the ctor. */
4137 gcc_assert (elts
->length () == 2);
4138 r
= (*elts
)[0].value
;
4139 i
= (*elts
)[1].value
;
4140 if (r
== NULL
|| i
== NULL
)
4142 tree zero
= build_zero_cst (TREE_TYPE (type
));
4149 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
4150 represent creation of a complex value. */
4151 if (TREE_CONSTANT (r
) && TREE_CONSTANT (i
))
4153 ctor
= build_complex (type
, r
, i
);
4154 TREE_OPERAND (*expr_p
, 1) = ctor
;
4158 ctor
= build2 (COMPLEX_EXPR
, type
, r
, i
);
4159 TREE_OPERAND (*expr_p
, 1) = ctor
;
4160 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1),
4163 rhs_predicate_for (TREE_OPERAND (*expr_p
, 0)),
4171 unsigned HOST_WIDE_INT ix
;
4172 constructor_elt
*ce
;
4174 if (notify_temp_creation
)
4177 /* Go ahead and simplify constant constructors to VECTOR_CST. */
4178 if (TREE_CONSTANT (ctor
))
4180 bool constant_p
= true;
4183 /* Even when ctor is constant, it might contain non-*_CST
4184 elements, such as addresses or trapping values like
4185 1.0/0.0 - 1.0/0.0. Such expressions don't belong
4186 in VECTOR_CST nodes. */
4187 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
4188 if (!CONSTANT_CLASS_P (value
))
4196 TREE_OPERAND (*expr_p
, 1) = build_vector_from_ctor (type
, elts
);
4200 /* Don't reduce an initializer constant even if we can't
4201 make a VECTOR_CST. It won't do anything for us, and it'll
4202 prevent us from representing it as a single constant. */
4203 if (initializer_constant_valid_p (ctor
, type
))
4206 TREE_CONSTANT (ctor
) = 0;
4209 /* Vector types use CONSTRUCTOR all the way through gimple
4210 compilation as a general initializer. */
4211 FOR_EACH_VEC_SAFE_ELT (elts
, ix
, ce
)
4213 enum gimplify_status tret
;
4214 tret
= gimplify_expr (&ce
->value
, pre_p
, post_p
, is_gimple_val
,
4216 if (tret
== GS_ERROR
)
4219 if (!is_gimple_reg (TREE_OPERAND (*expr_p
, 0)))
4220 TREE_OPERAND (*expr_p
, 1) = get_formal_tmp_var (ctor
, pre_p
);
4225 /* So how did we get a CONSTRUCTOR for a scalar type? */
4229 if (ret
== GS_ERROR
)
4231 else if (want_value
)
4238 /* If we have gimplified both sides of the initializer but have
4239 not emitted an assignment, do so now. */
4242 tree lhs
= TREE_OPERAND (*expr_p
, 0);
4243 tree rhs
= TREE_OPERAND (*expr_p
, 1);
4244 gimple init
= gimple_build_assign (lhs
, rhs
);
4245 gimplify_seq_add_stmt (pre_p
, init
);
4253 /* Given a pointer value OP0, return a simplified version of an
4254 indirection through OP0, or NULL_TREE if no simplification is
4255 possible. Note that the resulting type may be different from
4256 the type pointed to in the sense that it is still compatible
4257 from the langhooks point of view. */
4260 gimple_fold_indirect_ref (tree t
)
4262 tree ptype
= TREE_TYPE (t
), type
= TREE_TYPE (ptype
);
4267 subtype
= TREE_TYPE (sub
);
4268 if (!POINTER_TYPE_P (subtype
))
4271 if (TREE_CODE (sub
) == ADDR_EXPR
)
4273 tree op
= TREE_OPERAND (sub
, 0);
4274 tree optype
= TREE_TYPE (op
);
4276 if (useless_type_conversion_p (type
, optype
))
4279 /* *(foo *)&fooarray => fooarray[0] */
4280 if (TREE_CODE (optype
) == ARRAY_TYPE
4281 && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype
))) == INTEGER_CST
4282 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4284 tree type_domain
= TYPE_DOMAIN (optype
);
4285 tree min_val
= size_zero_node
;
4286 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
4287 min_val
= TYPE_MIN_VALUE (type_domain
);
4288 if (TREE_CODE (min_val
) == INTEGER_CST
)
4289 return build4 (ARRAY_REF
, type
, op
, min_val
, NULL_TREE
, NULL_TREE
);
4291 /* *(foo *)&complexfoo => __real__ complexfoo */
4292 else if (TREE_CODE (optype
) == COMPLEX_TYPE
4293 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4294 return fold_build1 (REALPART_EXPR
, type
, op
);
4295 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
4296 else if (TREE_CODE (optype
) == VECTOR_TYPE
4297 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4299 tree part_width
= TYPE_SIZE (type
);
4300 tree index
= bitsize_int (0);
4301 return fold_build3 (BIT_FIELD_REF
, type
, op
, part_width
, index
);
4305 /* *(p + CST) -> ... */
4306 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
4307 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
4309 tree addr
= TREE_OPERAND (sub
, 0);
4310 tree off
= TREE_OPERAND (sub
, 1);
4314 addrtype
= TREE_TYPE (addr
);
4316 /* ((foo*)&vectorfoo)[1] -> BIT_FIELD_REF<vectorfoo,...> */
4317 if (TREE_CODE (addr
) == ADDR_EXPR
4318 && TREE_CODE (TREE_TYPE (addrtype
)) == VECTOR_TYPE
4319 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
)))
4320 && host_integerp (off
, 1))
4322 unsigned HOST_WIDE_INT offset
= tree_low_cst (off
, 1);
4323 tree part_width
= TYPE_SIZE (type
);
4324 unsigned HOST_WIDE_INT part_widthi
4325 = tree_low_cst (part_width
, 0) / BITS_PER_UNIT
;
4326 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
4327 tree index
= bitsize_int (indexi
);
4328 if (offset
/ part_widthi
4329 <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype
)))
4330 return fold_build3 (BIT_FIELD_REF
, type
, TREE_OPERAND (addr
, 0),
4334 /* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
4335 if (TREE_CODE (addr
) == ADDR_EXPR
4336 && TREE_CODE (TREE_TYPE (addrtype
)) == COMPLEX_TYPE
4337 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
))))
4339 tree size
= TYPE_SIZE_UNIT (type
);
4340 if (tree_int_cst_equal (size
, off
))
4341 return fold_build1 (IMAGPART_EXPR
, type
, TREE_OPERAND (addr
, 0));
4344 /* *(p + CST) -> MEM_REF <p, CST>. */
4345 if (TREE_CODE (addr
) != ADDR_EXPR
4346 || DECL_P (TREE_OPERAND (addr
, 0)))
4347 return fold_build2 (MEM_REF
, type
,
4349 build_int_cst_wide (ptype
,
4350 TREE_INT_CST_LOW (off
),
4351 TREE_INT_CST_HIGH (off
)));
4354 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
4355 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
4356 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (subtype
)))) == INTEGER_CST
4357 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (subtype
))))
4360 tree min_val
= size_zero_node
;
4362 sub
= gimple_fold_indirect_ref (sub
);
4364 sub
= build1 (INDIRECT_REF
, TREE_TYPE (subtype
), osub
);
4365 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
4366 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
4367 min_val
= TYPE_MIN_VALUE (type_domain
);
4368 if (TREE_CODE (min_val
) == INTEGER_CST
)
4369 return build4 (ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
, NULL_TREE
);
4375 /* Given a pointer value OP0, return a simplified version of an
4376 indirection through OP0, or NULL_TREE if no simplification is
4377 possible. This may only be applied to a rhs of an expression.
4378 Note that the resulting type may be different from the type pointed
4379 to in the sense that it is still compatible from the langhooks
4383 gimple_fold_indirect_ref_rhs (tree t
)
4385 return gimple_fold_indirect_ref (t
);
4388 /* Subroutine of gimplify_modify_expr to do simplifications of
4389 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4390 something changes. */
4392 static enum gimplify_status
4393 gimplify_modify_expr_rhs (tree
*expr_p
, tree
*from_p
, tree
*to_p
,
4394 gimple_seq
*pre_p
, gimple_seq
*post_p
,
4397 enum gimplify_status ret
= GS_UNHANDLED
;
4403 switch (TREE_CODE (*from_p
))
4406 /* If we're assigning from a read-only variable initialized with
4407 a constructor, do the direct assignment from the constructor,
4408 but only if neither source nor target are volatile since this
4409 latter assignment might end up being done on a per-field basis. */
4410 if (DECL_INITIAL (*from_p
)
4411 && TREE_READONLY (*from_p
)
4412 && !TREE_THIS_VOLATILE (*from_p
)
4413 && !TREE_THIS_VOLATILE (*to_p
)
4414 && TREE_CODE (DECL_INITIAL (*from_p
)) == CONSTRUCTOR
)
4416 tree old_from
= *from_p
;
4417 enum gimplify_status subret
;
4419 /* Move the constructor into the RHS. */
4420 *from_p
= unshare_expr (DECL_INITIAL (*from_p
));
4422 /* Let's see if gimplify_init_constructor will need to put
4424 subret
= gimplify_init_constructor (expr_p
, NULL
, NULL
,
4426 if (subret
== GS_ERROR
)
4428 /* If so, revert the change. */
4440 /* If we have code like
4444 where the type of "x" is a (possibly cv-qualified variant
4445 of "A"), treat the entire expression as identical to "x".
4446 This kind of code arises in C++ when an object is bound
4447 to a const reference, and if "x" is a TARGET_EXPR we want
4448 to take advantage of the optimization below. */
4449 bool volatile_p
= TREE_THIS_VOLATILE (*from_p
);
4450 tree t
= gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p
, 0));
4453 if (TREE_THIS_VOLATILE (t
) != volatile_p
)
4455 if (TREE_CODE_CLASS (TREE_CODE (t
)) == tcc_declaration
)
4456 t
= build_simple_mem_ref_loc (EXPR_LOCATION (*from_p
),
4457 build_fold_addr_expr (t
));
4458 if (REFERENCE_CLASS_P (t
))
4459 TREE_THIS_VOLATILE (t
) = volatile_p
;
4470 /* If we are initializing something from a TARGET_EXPR, strip the
4471 TARGET_EXPR and initialize it directly, if possible. This can't
4472 be done if the initializer is void, since that implies that the
4473 temporary is set in some non-trivial way.
4475 ??? What about code that pulls out the temp and uses it
4476 elsewhere? I think that such code never uses the TARGET_EXPR as
4477 an initializer. If I'm wrong, we'll die because the temp won't
4478 have any RTL. In that case, I guess we'll need to replace
4479 references somehow. */
4480 tree init
= TARGET_EXPR_INITIAL (*from_p
);
4483 && !VOID_TYPE_P (TREE_TYPE (init
)))
4493 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4495 gimplify_compound_expr (from_p
, pre_p
, true);
4501 /* If we already made some changes, let the front end have a
4502 crack at this before we break it down. */
4503 if (ret
!= GS_UNHANDLED
)
4505 /* If we're initializing from a CONSTRUCTOR, break this into
4506 individual MODIFY_EXPRs. */
4507 return gimplify_init_constructor (expr_p
, pre_p
, post_p
, want_value
,
4511 /* If we're assigning to a non-register type, push the assignment
4512 down into the branches. This is mandatory for ADDRESSABLE types,
4513 since we cannot generate temporaries for such, but it saves a
4514 copy in other cases as well. */
4515 if (!is_gimple_reg_type (TREE_TYPE (*from_p
)))
4517 /* This code should mirror the code in gimplify_cond_expr. */
4518 enum tree_code code
= TREE_CODE (*expr_p
);
4519 tree cond
= *from_p
;
4520 tree result
= *to_p
;
4522 ret
= gimplify_expr (&result
, pre_p
, post_p
,
4523 is_gimple_lvalue
, fb_lvalue
);
4524 if (ret
!= GS_ERROR
)
4527 if (TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
)
4528 TREE_OPERAND (cond
, 1)
4529 = build2 (code
, void_type_node
, result
,
4530 TREE_OPERAND (cond
, 1));
4531 if (TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
4532 TREE_OPERAND (cond
, 2)
4533 = build2 (code
, void_type_node
, unshare_expr (result
),
4534 TREE_OPERAND (cond
, 2));
4536 TREE_TYPE (cond
) = void_type_node
;
4537 recalculate_side_effects (cond
);
4541 gimplify_and_add (cond
, pre_p
);
4542 *expr_p
= unshare_expr (result
);
4551 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4552 return slot so that we don't generate a temporary. */
4553 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p
)
4554 && aggregate_value_p (*from_p
, *from_p
))
4558 if (!(rhs_predicate_for (*to_p
))(*from_p
))
4559 /* If we need a temporary, *to_p isn't accurate. */
4561 /* It's OK to use the return slot directly unless it's an NRV. */
4562 else if (TREE_CODE (*to_p
) == RESULT_DECL
4563 && DECL_NAME (*to_p
) == NULL_TREE
4564 && needs_to_live_in_memory (*to_p
))
4566 else if (is_gimple_reg_type (TREE_TYPE (*to_p
))
4567 || (DECL_P (*to_p
) && DECL_REGISTER (*to_p
)))
4568 /* Don't force regs into memory. */
4570 else if (TREE_CODE (*expr_p
) == INIT_EXPR
)
4571 /* It's OK to use the target directly if it's being
4574 else if (variably_modified_type_p (TREE_TYPE (*to_p
), NULL_TREE
))
4575 /* Always use the target and thus RSO for variable-sized types.
4576 GIMPLE cannot deal with a variable-sized assignment
4577 embedded in a call statement. */
4579 else if (TREE_CODE (*to_p
) != SSA_NAME
4580 && (!is_gimple_variable (*to_p
)
4581 || needs_to_live_in_memory (*to_p
)))
4582 /* Don't use the original target if it's already addressable;
4583 if its address escapes, and the called function uses the
4584 NRV optimization, a conforming program could see *to_p
4585 change before the called function returns; see c++/19317.
4586 When optimizing, the return_slot pass marks more functions
4587 as safe after we have escape info. */
4594 CALL_EXPR_RETURN_SLOT_OPT (*from_p
) = 1;
4595 mark_addressable (*to_p
);
4600 case WITH_SIZE_EXPR
:
4601 /* Likewise for calls that return an aggregate of non-constant size,
4602 since we would not be able to generate a temporary at all. */
4603 if (TREE_CODE (TREE_OPERAND (*from_p
, 0)) == CALL_EXPR
)
4605 *from_p
= TREE_OPERAND (*from_p
, 0);
4606 /* We don't change ret in this case because the
4607 WITH_SIZE_EXPR might have been added in
4608 gimplify_modify_expr, so returning GS_OK would lead to an
4614 /* If we're initializing from a container, push the initialization
4616 case CLEANUP_POINT_EXPR
:
4618 case STATEMENT_LIST
:
4620 tree wrap
= *from_p
;
4623 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_min_lval
,
4625 if (ret
!= GS_ERROR
)
4628 t
= voidify_wrapper_expr (wrap
, *expr_p
);
4629 gcc_assert (t
== *expr_p
);
4633 gimplify_and_add (wrap
, pre_p
);
4634 *expr_p
= unshare_expr (*to_p
);
4641 case COMPOUND_LITERAL_EXPR
:
4643 tree complit
= TREE_OPERAND (*expr_p
, 1);
4644 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (complit
);
4645 tree decl
= DECL_EXPR_DECL (decl_s
);
4646 tree init
= DECL_INITIAL (decl
);
4648 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4649 into struct T x = { 0, 1, 2 } if the address of the
4650 compound literal has never been taken. */
4651 if (!TREE_ADDRESSABLE (complit
)
4652 && !TREE_ADDRESSABLE (decl
)
4655 *expr_p
= copy_node (*expr_p
);
4656 TREE_OPERAND (*expr_p
, 1) = init
;
4671 /* Return true if T looks like a valid GIMPLE statement. */
4674 is_gimple_stmt (tree t
)
4676 const enum tree_code code
= TREE_CODE (t
);
4681 /* The only valid NOP_EXPR is the empty statement. */
4682 return IS_EMPTY_STMT (t
);
4686 /* These are only valid if they're void. */
4687 return TREE_TYPE (t
) == NULL
|| VOID_TYPE_P (TREE_TYPE (t
));
4693 case CASE_LABEL_EXPR
:
4694 case TRY_CATCH_EXPR
:
4695 case TRY_FINALLY_EXPR
:
4696 case EH_FILTER_EXPR
:
4699 case STATEMENT_LIST
:
4709 /* These are always void. */
4715 /* These are valid regardless of their type. */
4724 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4725 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4726 DECL_GIMPLE_REG_P set.
4728 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4729 other, unmodified part of the complex object just before the total store.
4730 As a consequence, if the object is still uninitialized, an undefined value
4731 will be loaded into a register, which may result in a spurious exception
4732 if the register is floating-point and the value happens to be a signaling
4733 NaN for example. Then the fully-fledged complex operations lowering pass
4734 followed by a DCE pass are necessary in order to fix things up. */
4736 static enum gimplify_status
4737 gimplify_modify_expr_complex_part (tree
*expr_p
, gimple_seq
*pre_p
,
4740 enum tree_code code
, ocode
;
4741 tree lhs
, rhs
, new_rhs
, other
, realpart
, imagpart
;
4743 lhs
= TREE_OPERAND (*expr_p
, 0);
4744 rhs
= TREE_OPERAND (*expr_p
, 1);
4745 code
= TREE_CODE (lhs
);
4746 lhs
= TREE_OPERAND (lhs
, 0);
4748 ocode
= code
== REALPART_EXPR
? IMAGPART_EXPR
: REALPART_EXPR
;
4749 other
= build1 (ocode
, TREE_TYPE (rhs
), lhs
);
4750 TREE_NO_WARNING (other
) = 1;
4751 other
= get_formal_tmp_var (other
, pre_p
);
4753 realpart
= code
== REALPART_EXPR
? rhs
: other
;
4754 imagpart
= code
== REALPART_EXPR
? other
: rhs
;
4756 if (TREE_CONSTANT (realpart
) && TREE_CONSTANT (imagpart
))
4757 new_rhs
= build_complex (TREE_TYPE (lhs
), realpart
, imagpart
);
4759 new_rhs
= build2 (COMPLEX_EXPR
, TREE_TYPE (lhs
), realpart
, imagpart
);
4761 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (lhs
, new_rhs
));
4762 *expr_p
= (want_value
) ? rhs
: NULL_TREE
;
4767 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4773 PRE_P points to the list where side effects that must happen before
4774 *EXPR_P should be stored.
4776 POST_P points to the list where side effects that must happen after
4777 *EXPR_P should be stored.
4779 WANT_VALUE is nonzero iff we want to use the value of this expression
4780 in another expression. */
4782 static enum gimplify_status
4783 gimplify_modify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4786 tree
*from_p
= &TREE_OPERAND (*expr_p
, 1);
4787 tree
*to_p
= &TREE_OPERAND (*expr_p
, 0);
4788 enum gimplify_status ret
= GS_UNHANDLED
;
4790 location_t loc
= EXPR_LOCATION (*expr_p
);
4791 gimple_stmt_iterator gsi
;
4793 gcc_assert (TREE_CODE (*expr_p
) == MODIFY_EXPR
4794 || TREE_CODE (*expr_p
) == INIT_EXPR
);
4796 /* Trying to simplify a clobber using normal logic doesn't work,
4797 so handle it here. */
4798 if (TREE_CLOBBER_P (*from_p
))
4800 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4801 if (ret
== GS_ERROR
)
4803 gcc_assert (!want_value
4804 && (TREE_CODE (*to_p
) == VAR_DECL
4805 || TREE_CODE (*to_p
) == MEM_REF
));
4806 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (*to_p
, *from_p
));
4811 /* Insert pointer conversions required by the middle-end that are not
4812 required by the frontend. This fixes middle-end type checking for
4813 for example gcc.dg/redecl-6.c. */
4814 if (POINTER_TYPE_P (TREE_TYPE (*to_p
)))
4816 STRIP_USELESS_TYPE_CONVERSION (*from_p
);
4817 if (!useless_type_conversion_p (TREE_TYPE (*to_p
), TREE_TYPE (*from_p
)))
4818 *from_p
= fold_convert_loc (loc
, TREE_TYPE (*to_p
), *from_p
);
4821 /* See if any simplifications can be done based on what the RHS is. */
4822 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4824 if (ret
!= GS_UNHANDLED
)
4827 /* For zero sized types only gimplify the left hand side and right hand
4828 side as statements and throw away the assignment. Do this after
4829 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4831 if (zero_sized_type (TREE_TYPE (*from_p
)) && !want_value
)
4833 gimplify_stmt (from_p
, pre_p
);
4834 gimplify_stmt (to_p
, pre_p
);
4835 *expr_p
= NULL_TREE
;
4839 /* If the value being copied is of variable width, compute the length
4840 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4841 before gimplifying any of the operands so that we can resolve any
4842 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4843 the size of the expression to be copied, not of the destination, so
4844 that is what we must do here. */
4845 maybe_with_size_expr (from_p
);
4847 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4848 if (ret
== GS_ERROR
)
4851 /* As a special case, we have to temporarily allow for assignments
4852 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4853 a toplevel statement, when gimplifying the GENERIC expression
4854 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4855 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4857 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4858 prevent gimplify_expr from trying to create a new temporary for
4859 foo's LHS, we tell it that it should only gimplify until it
4860 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4861 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4862 and all we need to do here is set 'a' to be its LHS. */
4863 ret
= gimplify_expr (from_p
, pre_p
, post_p
, rhs_predicate_for (*to_p
),
4865 if (ret
== GS_ERROR
)
4868 /* Now see if the above changed *from_p to something we handle specially. */
4869 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4871 if (ret
!= GS_UNHANDLED
)
4874 /* If we've got a variable sized assignment between two lvalues (i.e. does
4875 not involve a call), then we can make things a bit more straightforward
4876 by converting the assignment to memcpy or memset. */
4877 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
4879 tree from
= TREE_OPERAND (*from_p
, 0);
4880 tree size
= TREE_OPERAND (*from_p
, 1);
4882 if (TREE_CODE (from
) == CONSTRUCTOR
)
4883 return gimplify_modify_expr_to_memset (expr_p
, size
, want_value
, pre_p
);
4885 if (is_gimple_addressable (from
))
4888 return gimplify_modify_expr_to_memcpy (expr_p
, size
, want_value
,
4893 /* Transform partial stores to non-addressable complex variables into
4894 total stores. This allows us to use real instead of virtual operands
4895 for these variables, which improves optimization. */
4896 if ((TREE_CODE (*to_p
) == REALPART_EXPR
4897 || TREE_CODE (*to_p
) == IMAGPART_EXPR
)
4898 && is_gimple_reg (TREE_OPERAND (*to_p
, 0)))
4899 return gimplify_modify_expr_complex_part (expr_p
, pre_p
, want_value
);
4901 /* Try to alleviate the effects of the gimplification creating artificial
4902 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
4903 if (!gimplify_ctxp
->into_ssa
4904 && TREE_CODE (*from_p
) == VAR_DECL
4905 && DECL_IGNORED_P (*from_p
)
4907 && !DECL_IGNORED_P (*to_p
))
4909 if (!DECL_NAME (*from_p
) && DECL_NAME (*to_p
))
4911 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p
)));
4912 DECL_HAS_DEBUG_EXPR_P (*from_p
) = 1;
4913 SET_DECL_DEBUG_EXPR (*from_p
, *to_p
);
4916 if (want_value
&& TREE_THIS_VOLATILE (*to_p
))
4917 *from_p
= get_initialized_tmp_var (*from_p
, pre_p
, post_p
);
4919 if (TREE_CODE (*from_p
) == CALL_EXPR
)
4921 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4922 instead of a GIMPLE_ASSIGN. */
4923 tree fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*from_p
));
4924 CALL_EXPR_FN (*from_p
) = TREE_OPERAND (CALL_EXPR_FN (*from_p
), 0);
4925 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p
));
4926 assign
= gimple_build_call_from_tree (*from_p
);
4927 gimple_call_set_fntype (assign
, TREE_TYPE (fnptrtype
));
4928 notice_special_calls (assign
);
4929 if (!gimple_call_noreturn_p (assign
))
4930 gimple_call_set_lhs (assign
, *to_p
);
4934 assign
= gimple_build_assign (*to_p
, *from_p
);
4935 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
4938 if (gimplify_ctxp
->into_ssa
&& is_gimple_reg (*to_p
))
4940 /* We should have got an SSA name from the start. */
4941 gcc_assert (TREE_CODE (*to_p
) == SSA_NAME
);
4944 gimplify_seq_add_stmt (pre_p
, assign
);
4945 gsi
= gsi_last (*pre_p
);
4950 *expr_p
= TREE_THIS_VOLATILE (*to_p
) ? *from_p
: unshare_expr (*to_p
);
4959 /* Gimplify a comparison between two variable-sized objects. Do this
4960 with a call to BUILT_IN_MEMCMP. */
4962 static enum gimplify_status
4963 gimplify_variable_sized_compare (tree
*expr_p
)
4965 location_t loc
= EXPR_LOCATION (*expr_p
);
4966 tree op0
= TREE_OPERAND (*expr_p
, 0);
4967 tree op1
= TREE_OPERAND (*expr_p
, 1);
4968 tree t
, arg
, dest
, src
, expr
;
4970 arg
= TYPE_SIZE_UNIT (TREE_TYPE (op0
));
4971 arg
= unshare_expr (arg
);
4972 arg
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg
, op0
);
4973 src
= build_fold_addr_expr_loc (loc
, op1
);
4974 dest
= build_fold_addr_expr_loc (loc
, op0
);
4975 t
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
4976 t
= build_call_expr_loc (loc
, t
, 3, dest
, src
, arg
);
4979 = build2 (TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), t
, integer_zero_node
);
4980 SET_EXPR_LOCATION (expr
, loc
);
4986 /* Gimplify a comparison between two aggregate objects of integral scalar
4987 mode as a comparison between the bitwise equivalent scalar values. */
4989 static enum gimplify_status
4990 gimplify_scalar_mode_aggregate_compare (tree
*expr_p
)
4992 location_t loc
= EXPR_LOCATION (*expr_p
);
4993 tree op0
= TREE_OPERAND (*expr_p
, 0);
4994 tree op1
= TREE_OPERAND (*expr_p
, 1);
4996 tree type
= TREE_TYPE (op0
);
4997 tree scalar_type
= lang_hooks
.types
.type_for_mode (TYPE_MODE (type
), 1);
4999 op0
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op0
);
5000 op1
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op1
);
5003 = fold_build2_loc (loc
, TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), op0
, op1
);
5008 /* Gimplify an expression sequence. This function gimplifies each
5009 expression and rewrites the original expression with the last
5010 expression of the sequence in GIMPLE form.
5012 PRE_P points to the list where the side effects for all the
5013 expressions in the sequence will be emitted.
5015 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
5017 static enum gimplify_status
5018 gimplify_compound_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
5024 tree
*sub_p
= &TREE_OPERAND (t
, 0);
5026 if (TREE_CODE (*sub_p
) == COMPOUND_EXPR
)
5027 gimplify_compound_expr (sub_p
, pre_p
, false);
5029 gimplify_stmt (sub_p
, pre_p
);
5031 t
= TREE_OPERAND (t
, 1);
5033 while (TREE_CODE (t
) == COMPOUND_EXPR
);
5040 gimplify_stmt (expr_p
, pre_p
);
5045 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
5046 gimplify. After gimplification, EXPR_P will point to a new temporary
5047 that holds the original value of the SAVE_EXPR node.
5049 PRE_P points to the list where side effects that must happen before
5050 *EXPR_P should be stored. */
5052 static enum gimplify_status
5053 gimplify_save_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5055 enum gimplify_status ret
= GS_ALL_DONE
;
5058 gcc_assert (TREE_CODE (*expr_p
) == SAVE_EXPR
);
5059 val
= TREE_OPERAND (*expr_p
, 0);
5061 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
5062 if (!SAVE_EXPR_RESOLVED_P (*expr_p
))
5064 /* The operand may be a void-valued expression such as SAVE_EXPRs
5065 generated by the Java frontend for class initialization. It is
5066 being executed only for its side-effects. */
5067 if (TREE_TYPE (val
) == void_type_node
)
5069 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
5070 is_gimple_stmt
, fb_none
);
5074 val
= get_initialized_tmp_var (val
, pre_p
, post_p
);
5076 TREE_OPERAND (*expr_p
, 0) = val
;
5077 SAVE_EXPR_RESOLVED_P (*expr_p
) = 1;
5085 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
5092 PRE_P points to the list where side effects that must happen before
5093 *EXPR_P should be stored.
5095 POST_P points to the list where side effects that must happen after
5096 *EXPR_P should be stored. */
5098 static enum gimplify_status
5099 gimplify_addr_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5101 tree expr
= *expr_p
;
5102 tree op0
= TREE_OPERAND (expr
, 0);
5103 enum gimplify_status ret
;
5104 location_t loc
= EXPR_LOCATION (*expr_p
);
5106 switch (TREE_CODE (op0
))
5110 /* Check if we are dealing with an expression of the form '&*ptr'.
5111 While the front end folds away '&*ptr' into 'ptr', these
5112 expressions may be generated internally by the compiler (e.g.,
5113 builtins like __builtin_va_end). */
5114 /* Caution: the silent array decomposition semantics we allow for
5115 ADDR_EXPR means we can't always discard the pair. */
5116 /* Gimplification of the ADDR_EXPR operand may drop
5117 cv-qualification conversions, so make sure we add them if
5120 tree op00
= TREE_OPERAND (op0
, 0);
5121 tree t_expr
= TREE_TYPE (expr
);
5122 tree t_op00
= TREE_TYPE (op00
);
5124 if (!useless_type_conversion_p (t_expr
, t_op00
))
5125 op00
= fold_convert_loc (loc
, TREE_TYPE (expr
), op00
);
5131 case VIEW_CONVERT_EXPR
:
5132 /* Take the address of our operand and then convert it to the type of
5135 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
5136 all clear. The impact of this transformation is even less clear. */
5138 /* If the operand is a useless conversion, look through it. Doing so
5139 guarantees that the ADDR_EXPR and its operand will remain of the
5141 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0
, 0)))
5142 op0
= TREE_OPERAND (op0
, 0);
5144 *expr_p
= fold_convert_loc (loc
, TREE_TYPE (expr
),
5145 build_fold_addr_expr_loc (loc
,
5146 TREE_OPERAND (op0
, 0)));
5151 /* We use fb_either here because the C frontend sometimes takes
5152 the address of a call that returns a struct; see
5153 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
5154 the implied temporary explicit. */
5156 /* Make the operand addressable. */
5157 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, post_p
,
5158 is_gimple_addressable
, fb_either
);
5159 if (ret
== GS_ERROR
)
5162 /* Then mark it. Beware that it may not be possible to do so directly
5163 if a temporary has been created by the gimplification. */
5164 prepare_gimple_addressable (&TREE_OPERAND (expr
, 0), pre_p
);
5166 op0
= TREE_OPERAND (expr
, 0);
5168 /* For various reasons, the gimplification of the expression
5169 may have made a new INDIRECT_REF. */
5170 if (TREE_CODE (op0
) == INDIRECT_REF
)
5171 goto do_indirect_ref
;
5173 mark_addressable (TREE_OPERAND (expr
, 0));
5175 /* The FEs may end up building ADDR_EXPRs early on a decl with
5176 an incomplete type. Re-build ADDR_EXPRs in canonical form
5178 if (!types_compatible_p (TREE_TYPE (op0
), TREE_TYPE (TREE_TYPE (expr
))))
5179 *expr_p
= build_fold_addr_expr (op0
);
5181 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
5182 recompute_tree_invariant_for_addr_expr (*expr_p
);
5184 /* If we re-built the ADDR_EXPR add a conversion to the original type
5186 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
5187 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
5195 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
5196 value; output operands should be a gimple lvalue. */
5198 static enum gimplify_status
5199 gimplify_asm_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5203 const char **oconstraints
;
5206 const char *constraint
;
5207 bool allows_mem
, allows_reg
, is_inout
;
5208 enum gimplify_status ret
, tret
;
5210 vec
<tree
, va_gc
> *inputs
;
5211 vec
<tree
, va_gc
> *outputs
;
5212 vec
<tree
, va_gc
> *clobbers
;
5213 vec
<tree
, va_gc
> *labels
;
5217 noutputs
= list_length (ASM_OUTPUTS (expr
));
5218 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
5226 link_next
= NULL_TREE
;
5227 for (i
= 0, link
= ASM_OUTPUTS (expr
); link
; ++i
, link
= link_next
)
5230 size_t constraint_len
;
5232 link_next
= TREE_CHAIN (link
);
5236 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5237 constraint_len
= strlen (constraint
);
5238 if (constraint_len
== 0)
5241 ok
= parse_output_constraint (&constraint
, i
, 0, 0,
5242 &allows_mem
, &allows_reg
, &is_inout
);
5249 if (!allows_reg
&& allows_mem
)
5250 mark_addressable (TREE_VALUE (link
));
5252 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5253 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
5254 fb_lvalue
| fb_mayfail
);
5255 if (tret
== GS_ERROR
)
5257 error ("invalid lvalue in asm output %d", i
);
5261 vec_safe_push (outputs
, link
);
5262 TREE_CHAIN (link
) = NULL_TREE
;
5266 /* An input/output operand. To give the optimizers more
5267 flexibility, split it into separate input and output
5272 /* Turn the in/out constraint into an output constraint. */
5273 char *p
= xstrdup (constraint
);
5275 TREE_VALUE (TREE_PURPOSE (link
)) = build_string (constraint_len
, p
);
5277 /* And add a matching input constraint. */
5280 sprintf (buf
, "%d", i
);
5282 /* If there are multiple alternatives in the constraint,
5283 handle each of them individually. Those that allow register
5284 will be replaced with operand number, the others will stay
5286 if (strchr (p
, ',') != NULL
)
5288 size_t len
= 0, buflen
= strlen (buf
);
5289 char *beg
, *end
, *str
, *dst
;
5293 end
= strchr (beg
, ',');
5295 end
= strchr (beg
, '\0');
5296 if ((size_t) (end
- beg
) < buflen
)
5299 len
+= end
- beg
+ 1;
5306 str
= (char *) alloca (len
);
5307 for (beg
= p
+ 1, dst
= str
;;)
5310 bool mem_p
, reg_p
, inout_p
;
5312 end
= strchr (beg
, ',');
5317 parse_output_constraint (&tem
, i
, 0, 0,
5318 &mem_p
, ®_p
, &inout_p
);
5323 memcpy (dst
, buf
, buflen
);
5332 memcpy (dst
, beg
, len
);
5341 input
= build_string (dst
- str
, str
);
5344 input
= build_string (strlen (buf
), buf
);
5347 input
= build_string (constraint_len
- 1, constraint
+ 1);
5351 input
= build_tree_list (build_tree_list (NULL_TREE
, input
),
5352 unshare_expr (TREE_VALUE (link
)));
5353 ASM_INPUTS (expr
) = chainon (ASM_INPUTS (expr
), input
);
5357 link_next
= NULL_TREE
;
5358 for (link
= ASM_INPUTS (expr
); link
; ++i
, link
= link_next
)
5360 link_next
= TREE_CHAIN (link
);
5361 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5362 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
5363 oconstraints
, &allows_mem
, &allows_reg
);
5365 /* If we can't make copies, we can only accept memory. */
5366 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link
))))
5372 error ("impossible constraint in %<asm%>");
5373 error ("non-memory input %d must stay in memory", i
);
5378 /* If the operand is a memory input, it should be an lvalue. */
5379 if (!allows_reg
&& allows_mem
)
5381 tree inputv
= TREE_VALUE (link
);
5382 STRIP_NOPS (inputv
);
5383 if (TREE_CODE (inputv
) == PREDECREMENT_EXPR
5384 || TREE_CODE (inputv
) == PREINCREMENT_EXPR
5385 || TREE_CODE (inputv
) == POSTDECREMENT_EXPR
5386 || TREE_CODE (inputv
) == POSTINCREMENT_EXPR
)
5387 TREE_VALUE (link
) = error_mark_node
;
5388 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5389 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
5390 mark_addressable (TREE_VALUE (link
));
5391 if (tret
== GS_ERROR
)
5393 if (EXPR_HAS_LOCATION (TREE_VALUE (link
)))
5394 input_location
= EXPR_LOCATION (TREE_VALUE (link
));
5395 error ("memory input %d is not directly addressable", i
);
5401 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5402 is_gimple_asm_val
, fb_rvalue
);
5403 if (tret
== GS_ERROR
)
5407 TREE_CHAIN (link
) = NULL_TREE
;
5408 vec_safe_push (inputs
, link
);
5411 for (link
= ASM_CLOBBERS (expr
); link
; ++i
, link
= TREE_CHAIN (link
))
5412 vec_safe_push (clobbers
, link
);
5414 for (link
= ASM_LABELS (expr
); link
; ++i
, link
= TREE_CHAIN (link
))
5415 vec_safe_push (labels
, link
);
5417 /* Do not add ASMs with errors to the gimple IL stream. */
5418 if (ret
!= GS_ERROR
)
5420 stmt
= gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr
)),
5421 inputs
, outputs
, clobbers
, labels
);
5423 gimple_asm_set_volatile (stmt
, ASM_VOLATILE_P (expr
));
5424 gimple_asm_set_input (stmt
, ASM_INPUT_P (expr
));
5426 gimplify_seq_add_stmt (pre_p
, stmt
);
5432 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
5433 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
5434 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
5435 return to this function.
5437 FIXME should we complexify the prequeue handling instead? Or use flags
5438 for all the cleanups and let the optimizer tighten them up? The current
5439 code seems pretty fragile; it will break on a cleanup within any
5440 non-conditional nesting. But any such nesting would be broken, anyway;
5441 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
5442 and continues out of it. We can do that at the RTL level, though, so
5443 having an optimizer to tighten up try/finally regions would be a Good
5446 static enum gimplify_status
5447 gimplify_cleanup_point_expr (tree
*expr_p
, gimple_seq
*pre_p
)
5449 gimple_stmt_iterator iter
;
5450 gimple_seq body_sequence
= NULL
;
5452 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
5454 /* We only care about the number of conditions between the innermost
5455 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5456 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5457 int old_conds
= gimplify_ctxp
->conditions
;
5458 gimple_seq old_cleanups
= gimplify_ctxp
->conditional_cleanups
;
5459 bool old_in_cleanup_point_expr
= gimplify_ctxp
->in_cleanup_point_expr
;
5460 gimplify_ctxp
->conditions
= 0;
5461 gimplify_ctxp
->conditional_cleanups
= NULL
;
5462 gimplify_ctxp
->in_cleanup_point_expr
= true;
5464 gimplify_stmt (&TREE_OPERAND (*expr_p
, 0), &body_sequence
);
5466 gimplify_ctxp
->conditions
= old_conds
;
5467 gimplify_ctxp
->conditional_cleanups
= old_cleanups
;
5468 gimplify_ctxp
->in_cleanup_point_expr
= old_in_cleanup_point_expr
;
5470 for (iter
= gsi_start (body_sequence
); !gsi_end_p (iter
); )
5472 gimple wce
= gsi_stmt (iter
);
5474 if (gimple_code (wce
) == GIMPLE_WITH_CLEANUP_EXPR
)
5476 if (gsi_one_before_end_p (iter
))
5478 /* Note that gsi_insert_seq_before and gsi_remove do not
5479 scan operands, unlike some other sequence mutators. */
5480 if (!gimple_wce_cleanup_eh_only (wce
))
5481 gsi_insert_seq_before_without_update (&iter
,
5482 gimple_wce_cleanup (wce
),
5484 gsi_remove (&iter
, true);
5491 enum gimple_try_flags kind
;
5493 if (gimple_wce_cleanup_eh_only (wce
))
5494 kind
= GIMPLE_TRY_CATCH
;
5496 kind
= GIMPLE_TRY_FINALLY
;
5497 seq
= gsi_split_seq_after (iter
);
5499 gtry
= gimple_build_try (seq
, gimple_wce_cleanup (wce
), kind
);
5500 /* Do not use gsi_replace here, as it may scan operands.
5501 We want to do a simple structural modification only. */
5502 gsi_set_stmt (&iter
, gtry
);
5503 iter
= gsi_start (gtry
->gimple_try
.eval
);
5510 gimplify_seq_add_seq (pre_p
, body_sequence
);
5523 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5524 is the cleanup action required. EH_ONLY is true if the cleanup should
5525 only be executed if an exception is thrown, not on normal exit. */
5528 gimple_push_cleanup (tree var
, tree cleanup
, bool eh_only
, gimple_seq
*pre_p
)
5531 gimple_seq cleanup_stmts
= NULL
;
5533 /* Errors can result in improperly nested cleanups. Which results in
5534 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5538 if (gimple_conditional_context ())
5540 /* If we're in a conditional context, this is more complex. We only
5541 want to run the cleanup if we actually ran the initialization that
5542 necessitates it, but we want to run it after the end of the
5543 conditional context. So we wrap the try/finally around the
5544 condition and use a flag to determine whether or not to actually
5545 run the destructor. Thus
5549 becomes (approximately)
5553 if (test) { A::A(temp); flag = 1; val = f(temp); }
5556 if (flag) A::~A(temp);
5560 tree flag
= create_tmp_var (boolean_type_node
, "cleanup");
5561 gimple ffalse
= gimple_build_assign (flag
, boolean_false_node
);
5562 gimple ftrue
= gimple_build_assign (flag
, boolean_true_node
);
5564 cleanup
= build3 (COND_EXPR
, void_type_node
, flag
, cleanup
, NULL
);
5565 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5566 wce
= gimple_build_wce (cleanup_stmts
);
5568 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, ffalse
);
5569 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
5570 gimplify_seq_add_stmt (pre_p
, ftrue
);
5572 /* Because of this manipulation, and the EH edges that jump
5573 threading cannot redirect, the temporary (VAR) will appear
5574 to be used uninitialized. Don't warn. */
5575 TREE_NO_WARNING (var
) = 1;
5579 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5580 wce
= gimple_build_wce (cleanup_stmts
);
5581 gimple_wce_set_cleanup_eh_only (wce
, eh_only
);
5582 gimplify_seq_add_stmt (pre_p
, wce
);
5586 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5588 static enum gimplify_status
5589 gimplify_target_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5591 tree targ
= *expr_p
;
5592 tree temp
= TARGET_EXPR_SLOT (targ
);
5593 tree init
= TARGET_EXPR_INITIAL (targ
);
5594 enum gimplify_status ret
;
5598 tree cleanup
= NULL_TREE
;
5600 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5601 to the temps list. Handle also variable length TARGET_EXPRs. */
5602 if (TREE_CODE (DECL_SIZE (temp
)) != INTEGER_CST
)
5604 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp
)))
5605 gimplify_type_sizes (TREE_TYPE (temp
), pre_p
);
5606 gimplify_vla_decl (temp
, pre_p
);
5609 gimple_add_tmp_var (temp
);
5611 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5612 expression is supposed to initialize the slot. */
5613 if (VOID_TYPE_P (TREE_TYPE (init
)))
5614 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5617 tree init_expr
= build2 (INIT_EXPR
, void_type_node
, temp
, init
);
5619 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5621 ggc_free (init_expr
);
5623 if (ret
== GS_ERROR
)
5625 /* PR c++/28266 Make sure this is expanded only once. */
5626 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5630 gimplify_and_add (init
, pre_p
);
5632 /* If needed, push the cleanup for the temp. */
5633 if (TARGET_EXPR_CLEANUP (targ
))
5635 if (CLEANUP_EH_ONLY (targ
))
5636 gimple_push_cleanup (temp
, TARGET_EXPR_CLEANUP (targ
),
5637 CLEANUP_EH_ONLY (targ
), pre_p
);
5639 cleanup
= TARGET_EXPR_CLEANUP (targ
);
5642 /* Add a clobber for the temporary going out of scope, like
5643 gimplify_bind_expr. */
5644 if (gimplify_ctxp
->in_cleanup_point_expr
5645 && needs_to_live_in_memory (temp
)
5646 && flag_stack_reuse
== SR_ALL
)
5648 tree clobber
= build_constructor (TREE_TYPE (temp
),
5650 TREE_THIS_VOLATILE (clobber
) = true;
5651 clobber
= build2 (MODIFY_EXPR
, TREE_TYPE (temp
), temp
, clobber
);
5653 cleanup
= build2 (COMPOUND_EXPR
, void_type_node
, cleanup
,
5660 gimple_push_cleanup (temp
, cleanup
, false, pre_p
);
5662 /* Only expand this once. */
5663 TREE_OPERAND (targ
, 3) = init
;
5664 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5667 /* We should have expanded this before. */
5668 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp
));
5674 /* Gimplification of expression trees. */
5676 /* Gimplify an expression which appears at statement context. The
5677 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5678 NULL, a new sequence is allocated.
5680 Return true if we actually added a statement to the queue. */
5683 gimplify_stmt (tree
*stmt_p
, gimple_seq
*seq_p
)
5685 gimple_seq_node last
;
5687 last
= gimple_seq_last (*seq_p
);
5688 gimplify_expr (stmt_p
, seq_p
, NULL
, is_gimple_stmt
, fb_none
);
5689 return last
!= gimple_seq_last (*seq_p
);
5692 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5693 to CTX. If entries already exist, force them to be some flavor of private.
5694 If there is no enclosing parallel, do nothing. */
5697 omp_firstprivatize_variable (struct gimplify_omp_ctx
*ctx
, tree decl
)
5701 if (decl
== NULL
|| !DECL_P (decl
))
5706 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5709 if (n
->value
& GOVD_SHARED
)
5710 n
->value
= GOVD_FIRSTPRIVATE
| (n
->value
& GOVD_SEEN
);
5714 else if (ctx
->region_type
!= ORT_WORKSHARE
)
5715 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
5717 ctx
= ctx
->outer_context
;
5722 /* Similarly for each of the type sizes of TYPE. */
5725 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx
*ctx
, tree type
)
5727 if (type
== NULL
|| type
== error_mark_node
)
5729 type
= TYPE_MAIN_VARIANT (type
);
5731 if (pointer_set_insert (ctx
->privatized_types
, type
))
5734 switch (TREE_CODE (type
))
5740 case FIXED_POINT_TYPE
:
5741 omp_firstprivatize_variable (ctx
, TYPE_MIN_VALUE (type
));
5742 omp_firstprivatize_variable (ctx
, TYPE_MAX_VALUE (type
));
5746 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5747 omp_firstprivatize_type_sizes (ctx
, TYPE_DOMAIN (type
));
5752 case QUAL_UNION_TYPE
:
5755 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
5756 if (TREE_CODE (field
) == FIELD_DECL
)
5758 omp_firstprivatize_variable (ctx
, DECL_FIELD_OFFSET (field
));
5759 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (field
));
5765 case REFERENCE_TYPE
:
5766 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5773 omp_firstprivatize_variable (ctx
, TYPE_SIZE (type
));
5774 omp_firstprivatize_variable (ctx
, TYPE_SIZE_UNIT (type
));
5775 lang_hooks
.types
.omp_firstprivatize_type_sizes (ctx
, type
);
5778 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
5781 omp_add_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned int flags
)
5784 unsigned int nflags
;
5787 if (error_operand_p (decl
))
5790 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5791 there are constructors involved somewhere. */
5792 if (TREE_ADDRESSABLE (TREE_TYPE (decl
))
5793 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
5796 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5799 /* We shouldn't be re-adding the decl with the same data
5801 gcc_assert ((n
->value
& GOVD_DATA_SHARE_CLASS
& flags
) == 0);
5802 /* The only combination of data sharing classes we should see is
5803 FIRSTPRIVATE and LASTPRIVATE. */
5804 nflags
= n
->value
| flags
;
5805 gcc_assert ((nflags
& GOVD_DATA_SHARE_CLASS
)
5806 == (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
));
5811 /* When adding a variable-sized variable, we have to handle all sorts
5812 of additional bits of data: the pointer replacement variable, and
5813 the parameters of the type. */
5814 if (DECL_SIZE (decl
) && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5816 /* Add the pointer replacement variable as PRIVATE if the variable
5817 replacement is private, else FIRSTPRIVATE since we'll need the
5818 address of the original variable either for SHARED, or for the
5819 copy into or out of the context. */
5820 if (!(flags
& GOVD_LOCAL
))
5822 nflags
= flags
& GOVD_PRIVATE
? GOVD_PRIVATE
: GOVD_FIRSTPRIVATE
;
5823 nflags
|= flags
& GOVD_SEEN
;
5824 t
= DECL_VALUE_EXPR (decl
);
5825 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5826 t
= TREE_OPERAND (t
, 0);
5827 gcc_assert (DECL_P (t
));
5828 omp_add_variable (ctx
, t
, nflags
);
5831 /* Add all of the variable and type parameters (which should have
5832 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5833 omp_firstprivatize_variable (ctx
, DECL_SIZE_UNIT (decl
));
5834 omp_firstprivatize_variable (ctx
, DECL_SIZE (decl
));
5835 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5837 /* The variable-sized variable itself is never SHARED, only some form
5838 of PRIVATE. The sharing would take place via the pointer variable
5839 which we remapped above. */
5840 if (flags
& GOVD_SHARED
)
5841 flags
= GOVD_PRIVATE
| GOVD_DEBUG_PRIVATE
5842 | (flags
& (GOVD_SEEN
| GOVD_EXPLICIT
));
5844 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5845 alloca statement we generate for the variable, so make sure it
5846 is available. This isn't automatically needed for the SHARED
5847 case, since we won't be allocating local storage then.
5848 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5849 in this case omp_notice_variable will be called later
5850 on when it is gimplified. */
5851 else if (! (flags
& GOVD_LOCAL
)
5852 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl
))))
5853 omp_notice_variable (ctx
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)), true);
5855 else if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
5857 gcc_assert ((flags
& GOVD_LOCAL
) == 0);
5858 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5860 /* Similar to the direct variable sized case above, we'll need the
5861 size of references being privatized. */
5862 if ((flags
& GOVD_SHARED
) == 0)
5864 t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
5865 if (TREE_CODE (t
) != INTEGER_CST
)
5866 omp_notice_variable (ctx
, t
, true);
5870 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, flags
);
5873 /* Notice a threadprivate variable DECL used in OpenMP context CTX.
5874 This just prints out diagnostics about threadprivate variable uses
5875 in untied tasks. If DECL2 is non-NULL, prevent this warning
5876 on that variable. */
5879 omp_notice_threadprivate_variable (struct gimplify_omp_ctx
*ctx
, tree decl
,
5884 if (ctx
->region_type
!= ORT_UNTIED_TASK
)
5886 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5889 error ("threadprivate variable %qE used in untied task",
5891 error_at (ctx
->location
, "enclosing task");
5892 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, 0);
5895 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl2
, 0);
5899 /* Record the fact that DECL was used within the OpenMP context CTX.
5900 IN_CODE is true when real code uses DECL, and false when we should
5901 merely emit default(none) errors. Return true if DECL is going to
5902 be remapped and thus DECL shouldn't be gimplified into its
5903 DECL_VALUE_EXPR (if any). */
5906 omp_notice_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, bool in_code
)
5909 unsigned flags
= in_code
? GOVD_SEEN
: 0;
5910 bool ret
= false, shared
;
5912 if (error_operand_p (decl
))
5915 /* Threadprivate variables are predetermined. */
5916 if (is_global_var (decl
))
5918 if (DECL_THREAD_LOCAL_P (decl
))
5919 return omp_notice_threadprivate_variable (ctx
, decl
, NULL_TREE
);
5921 if (DECL_HAS_VALUE_EXPR_P (decl
))
5923 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
5925 if (value
&& DECL_P (value
) && DECL_THREAD_LOCAL_P (value
))
5926 return omp_notice_threadprivate_variable (ctx
, decl
, value
);
5930 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5933 enum omp_clause_default_kind default_kind
, kind
;
5934 struct gimplify_omp_ctx
*octx
;
5936 if (ctx
->region_type
== ORT_WORKSHARE
)
5939 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
5940 remapped firstprivate instead of shared. To some extent this is
5941 addressed in omp_firstprivatize_type_sizes, but not effectively. */
5942 default_kind
= ctx
->default_kind
;
5943 kind
= lang_hooks
.decls
.omp_predetermined_sharing (decl
);
5944 if (kind
!= OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
5945 default_kind
= kind
;
5947 switch (default_kind
)
5949 case OMP_CLAUSE_DEFAULT_NONE
:
5950 error ("%qE not specified in enclosing parallel",
5951 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5952 if ((ctx
->region_type
& ORT_TASK
) != 0)
5953 error_at (ctx
->location
, "enclosing task");
5955 error_at (ctx
->location
, "enclosing parallel");
5957 case OMP_CLAUSE_DEFAULT_SHARED
:
5958 flags
|= GOVD_SHARED
;
5960 case OMP_CLAUSE_DEFAULT_PRIVATE
:
5961 flags
|= GOVD_PRIVATE
;
5963 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
5964 flags
|= GOVD_FIRSTPRIVATE
;
5966 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
5967 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
5968 gcc_assert ((ctx
->region_type
& ORT_TASK
) != 0);
5969 if (ctx
->outer_context
)
5970 omp_notice_variable (ctx
->outer_context
, decl
, in_code
);
5971 for (octx
= ctx
->outer_context
; octx
; octx
= octx
->outer_context
)
5975 n2
= splay_tree_lookup (octx
->variables
, (splay_tree_key
) decl
);
5976 if (n2
&& (n2
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
)
5978 flags
|= GOVD_FIRSTPRIVATE
;
5981 if ((octx
->region_type
& ORT_PARALLEL
) != 0)
5984 if (flags
& GOVD_FIRSTPRIVATE
)
5987 && (TREE_CODE (decl
) == PARM_DECL
5988 || (!is_global_var (decl
)
5989 && DECL_CONTEXT (decl
) == current_function_decl
)))
5991 flags
|= GOVD_FIRSTPRIVATE
;
5994 flags
|= GOVD_SHARED
;
6000 if ((flags
& GOVD_PRIVATE
)
6001 && lang_hooks
.decls
.omp_private_outer_ref (decl
))
6002 flags
|= GOVD_PRIVATE_OUTER_REF
;
6004 omp_add_variable (ctx
, decl
, flags
);
6006 shared
= (flags
& GOVD_SHARED
) != 0;
6007 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
6011 if ((n
->value
& (GOVD_SEEN
| GOVD_LOCAL
)) == 0
6012 && (flags
& (GOVD_SEEN
| GOVD_LOCAL
)) == GOVD_SEEN
6014 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6017 tree t
= DECL_VALUE_EXPR (decl
);
6018 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
6019 t
= TREE_OPERAND (t
, 0);
6020 gcc_assert (DECL_P (t
));
6021 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
6022 n2
->value
|= GOVD_SEEN
;
6025 shared
= ((flags
| n
->value
) & GOVD_SHARED
) != 0;
6026 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
6028 /* If nothing changed, there's nothing left to do. */
6029 if ((n
->value
& flags
) == flags
)
6035 /* If the variable is private in the current context, then we don't
6036 need to propagate anything to an outer context. */
6037 if ((flags
& GOVD_PRIVATE
) && !(flags
& GOVD_PRIVATE_OUTER_REF
))
6039 if (ctx
->outer_context
6040 && omp_notice_variable (ctx
->outer_context
, decl
, in_code
))
6045 /* Verify that DECL is private within CTX. If there's specific information
6046 to the contrary in the innermost scope, generate an error. */
6049 omp_is_private (struct gimplify_omp_ctx
*ctx
, tree decl
)
6053 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
6056 if (n
->value
& GOVD_SHARED
)
6058 if (ctx
== gimplify_omp_ctxp
)
6060 error ("iteration variable %qE should be private",
6062 n
->value
= GOVD_PRIVATE
;
6068 else if ((n
->value
& GOVD_EXPLICIT
) != 0
6069 && (ctx
== gimplify_omp_ctxp
6070 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6071 && gimplify_omp_ctxp
->outer_context
== ctx
)))
6073 if ((n
->value
& GOVD_FIRSTPRIVATE
) != 0)
6074 error ("iteration variable %qE should not be firstprivate",
6076 else if ((n
->value
& GOVD_REDUCTION
) != 0)
6077 error ("iteration variable %qE should not be reduction",
6080 return (ctx
== gimplify_omp_ctxp
6081 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6082 && gimplify_omp_ctxp
->outer_context
== ctx
));
6085 if (ctx
->region_type
!= ORT_WORKSHARE
)
6087 else if (ctx
->outer_context
)
6088 return omp_is_private (ctx
->outer_context
, decl
);
6092 /* Return true if DECL is private within a parallel region
6093 that binds to the current construct's context or in parallel
6094 region's REDUCTION clause. */
6097 omp_check_private (struct gimplify_omp_ctx
*ctx
, tree decl
)
6103 ctx
= ctx
->outer_context
;
6105 return !(is_global_var (decl
)
6106 /* References might be private, but might be shared too. */
6107 || lang_hooks
.decls
.omp_privatize_by_reference (decl
));
6109 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6111 return (n
->value
& GOVD_SHARED
) == 0;
6113 while (ctx
->region_type
== ORT_WORKSHARE
);
6117 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
6118 and previous omp contexts. */
6121 gimplify_scan_omp_clauses (tree
*list_p
, gimple_seq
*pre_p
,
6122 enum omp_region_type region_type
)
6124 struct gimplify_omp_ctx
*ctx
, *outer_ctx
;
6125 struct gimplify_ctx gctx
;
6128 ctx
= new_omp_context (region_type
);
6129 outer_ctx
= ctx
->outer_context
;
6131 while ((c
= *list_p
) != NULL
)
6133 bool remove
= false;
6134 bool notice_outer
= true;
6135 const char *check_non_private
= NULL
;
6139 switch (OMP_CLAUSE_CODE (c
))
6141 case OMP_CLAUSE_PRIVATE
:
6142 flags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
6143 if (lang_hooks
.decls
.omp_private_outer_ref (OMP_CLAUSE_DECL (c
)))
6145 flags
|= GOVD_PRIVATE_OUTER_REF
;
6146 OMP_CLAUSE_PRIVATE_OUTER_REF (c
) = 1;
6149 notice_outer
= false;
6151 case OMP_CLAUSE_SHARED
:
6152 flags
= GOVD_SHARED
| GOVD_EXPLICIT
;
6154 case OMP_CLAUSE_FIRSTPRIVATE
:
6155 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
6156 check_non_private
= "firstprivate";
6158 case OMP_CLAUSE_LASTPRIVATE
:
6159 flags
= GOVD_LASTPRIVATE
| GOVD_SEEN
| GOVD_EXPLICIT
;
6160 check_non_private
= "lastprivate";
6162 case OMP_CLAUSE_REDUCTION
:
6163 flags
= GOVD_REDUCTION
| GOVD_SEEN
| GOVD_EXPLICIT
;
6164 check_non_private
= "reduction";
6168 decl
= OMP_CLAUSE_DECL (c
);
6169 if (error_operand_p (decl
))
6174 omp_add_variable (ctx
, decl
, flags
);
6175 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
6176 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
6178 omp_add_variable (ctx
, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
),
6179 GOVD_LOCAL
| GOVD_SEEN
);
6180 gimplify_omp_ctxp
= ctx
;
6181 push_gimplify_context (&gctx
);
6183 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
6184 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
6186 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c
),
6187 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
6188 pop_gimplify_context
6189 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
)));
6190 push_gimplify_context (&gctx
);
6191 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c
),
6192 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
6193 pop_gimplify_context
6194 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
)));
6195 OMP_CLAUSE_REDUCTION_INIT (c
) = NULL_TREE
;
6196 OMP_CLAUSE_REDUCTION_MERGE (c
) = NULL_TREE
;
6198 gimplify_omp_ctxp
= outer_ctx
;
6200 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6201 && OMP_CLAUSE_LASTPRIVATE_STMT (c
))
6203 gimplify_omp_ctxp
= ctx
;
6204 push_gimplify_context (&gctx
);
6205 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c
)) != BIND_EXPR
)
6207 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
6209 TREE_SIDE_EFFECTS (bind
) = 1;
6210 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LASTPRIVATE_STMT (c
);
6211 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = bind
;
6213 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c
),
6214 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6215 pop_gimplify_context
6216 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
)));
6217 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = NULL_TREE
;
6219 gimplify_omp_ctxp
= outer_ctx
;
6225 case OMP_CLAUSE_COPYIN
:
6226 case OMP_CLAUSE_COPYPRIVATE
:
6227 decl
= OMP_CLAUSE_DECL (c
);
6228 if (error_operand_p (decl
))
6235 omp_notice_variable (outer_ctx
, decl
, true);
6236 if (check_non_private
6237 && region_type
== ORT_WORKSHARE
6238 && omp_check_private (ctx
, decl
))
6240 error ("%s variable %qE is private in outer context",
6241 check_non_private
, DECL_NAME (decl
));
6246 case OMP_CLAUSE_FINAL
:
6248 OMP_CLAUSE_OPERAND (c
, 0)
6249 = gimple_boolify (OMP_CLAUSE_OPERAND (c
, 0));
6252 case OMP_CLAUSE_SCHEDULE
:
6253 case OMP_CLAUSE_NUM_THREADS
:
6254 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
6255 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6259 case OMP_CLAUSE_NOWAIT
:
6260 case OMP_CLAUSE_ORDERED
:
6261 case OMP_CLAUSE_UNTIED
:
6262 case OMP_CLAUSE_COLLAPSE
:
6263 case OMP_CLAUSE_MERGEABLE
:
6266 case OMP_CLAUSE_DEFAULT
:
6267 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
6275 *list_p
= OMP_CLAUSE_CHAIN (c
);
6277 list_p
= &OMP_CLAUSE_CHAIN (c
);
6280 gimplify_omp_ctxp
= ctx
;
6283 /* For all variables that were not actually used within the context,
6284 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
6287 gimplify_adjust_omp_clauses_1 (splay_tree_node n
, void *data
)
6289 tree
*list_p
= (tree
*) data
;
6290 tree decl
= (tree
) n
->key
;
6291 unsigned flags
= n
->value
;
6292 enum omp_clause_code code
;
6296 if (flags
& (GOVD_EXPLICIT
| GOVD_LOCAL
))
6298 if ((flags
& GOVD_SEEN
) == 0)
6300 if (flags
& GOVD_DEBUG_PRIVATE
)
6302 gcc_assert ((flags
& GOVD_DATA_SHARE_CLASS
) == GOVD_PRIVATE
);
6303 private_debug
= true;
6307 = lang_hooks
.decls
.omp_private_debug_clause (decl
,
6308 !!(flags
& GOVD_SHARED
));
6310 code
= OMP_CLAUSE_PRIVATE
;
6311 else if (flags
& GOVD_SHARED
)
6313 if (is_global_var (decl
))
6315 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
6319 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6320 if (on
&& (on
->value
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
6321 | GOVD_PRIVATE
| GOVD_REDUCTION
)) != 0)
6323 ctx
= ctx
->outer_context
;
6328 code
= OMP_CLAUSE_SHARED
;
6330 else if (flags
& GOVD_PRIVATE
)
6331 code
= OMP_CLAUSE_PRIVATE
;
6332 else if (flags
& GOVD_FIRSTPRIVATE
)
6333 code
= OMP_CLAUSE_FIRSTPRIVATE
;
6337 clause
= build_omp_clause (input_location
, code
);
6338 OMP_CLAUSE_DECL (clause
) = decl
;
6339 OMP_CLAUSE_CHAIN (clause
) = *list_p
;
6341 OMP_CLAUSE_PRIVATE_DEBUG (clause
) = 1;
6342 else if (code
== OMP_CLAUSE_PRIVATE
&& (flags
& GOVD_PRIVATE_OUTER_REF
))
6343 OMP_CLAUSE_PRIVATE_OUTER_REF (clause
) = 1;
6345 lang_hooks
.decls
.omp_finish_clause (clause
);
6351 gimplify_adjust_omp_clauses (tree
*list_p
)
6353 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6356 while ((c
= *list_p
) != NULL
)
6359 bool remove
= false;
6361 switch (OMP_CLAUSE_CODE (c
))
6363 case OMP_CLAUSE_PRIVATE
:
6364 case OMP_CLAUSE_SHARED
:
6365 case OMP_CLAUSE_FIRSTPRIVATE
:
6366 decl
= OMP_CLAUSE_DECL (c
);
6367 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6368 remove
= !(n
->value
& GOVD_SEEN
);
6371 bool shared
= OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
;
6372 if ((n
->value
& GOVD_DEBUG_PRIVATE
)
6373 || lang_hooks
.decls
.omp_private_debug_clause (decl
, shared
))
6375 gcc_assert ((n
->value
& GOVD_DEBUG_PRIVATE
) == 0
6376 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
6378 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_PRIVATE
);
6379 OMP_CLAUSE_PRIVATE_DEBUG (c
) = 1;
6384 case OMP_CLAUSE_LASTPRIVATE
:
6385 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
6386 accurately reflect the presence of a FIRSTPRIVATE clause. */
6387 decl
= OMP_CLAUSE_DECL (c
);
6388 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6389 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
6390 = (n
->value
& GOVD_FIRSTPRIVATE
) != 0;
6393 case OMP_CLAUSE_REDUCTION
:
6394 case OMP_CLAUSE_COPYIN
:
6395 case OMP_CLAUSE_COPYPRIVATE
:
6397 case OMP_CLAUSE_NUM_THREADS
:
6398 case OMP_CLAUSE_SCHEDULE
:
6399 case OMP_CLAUSE_NOWAIT
:
6400 case OMP_CLAUSE_ORDERED
:
6401 case OMP_CLAUSE_DEFAULT
:
6402 case OMP_CLAUSE_UNTIED
:
6403 case OMP_CLAUSE_COLLAPSE
:
6404 case OMP_CLAUSE_FINAL
:
6405 case OMP_CLAUSE_MERGEABLE
:
6413 *list_p
= OMP_CLAUSE_CHAIN (c
);
6415 list_p
= &OMP_CLAUSE_CHAIN (c
);
6418 /* Add in any implicit data sharing. */
6419 splay_tree_foreach (ctx
->variables
, gimplify_adjust_omp_clauses_1
, list_p
);
6421 gimplify_omp_ctxp
= ctx
->outer_context
;
6422 delete_omp_context (ctx
);
6425 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
6426 gimplification of the body, as well as scanning the body for used
6427 variables. We need to do this scan now, because variable-sized
6428 decls will be decomposed during gimplification. */
6431 gimplify_omp_parallel (tree
*expr_p
, gimple_seq
*pre_p
)
6433 tree expr
= *expr_p
;
6435 gimple_seq body
= NULL
;
6436 struct gimplify_ctx gctx
;
6438 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
), pre_p
,
6439 OMP_PARALLEL_COMBINED (expr
)
6440 ? ORT_COMBINED_PARALLEL
6443 push_gimplify_context (&gctx
);
6445 g
= gimplify_and_return_first (OMP_PARALLEL_BODY (expr
), &body
);
6446 if (gimple_code (g
) == GIMPLE_BIND
)
6447 pop_gimplify_context (g
);
6449 pop_gimplify_context (NULL
);
6451 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
));
6453 g
= gimple_build_omp_parallel (body
,
6454 OMP_PARALLEL_CLAUSES (expr
),
6455 NULL_TREE
, NULL_TREE
);
6456 if (OMP_PARALLEL_COMBINED (expr
))
6457 gimple_omp_set_subcode (g
, GF_OMP_PARALLEL_COMBINED
);
6458 gimplify_seq_add_stmt (pre_p
, g
);
6459 *expr_p
= NULL_TREE
;
6462 /* Gimplify the contents of an OMP_TASK statement. This involves
6463 gimplification of the body, as well as scanning the body for used
6464 variables. We need to do this scan now, because variable-sized
6465 decls will be decomposed during gimplification. */
6468 gimplify_omp_task (tree
*expr_p
, gimple_seq
*pre_p
)
6470 tree expr
= *expr_p
;
6472 gimple_seq body
= NULL
;
6473 struct gimplify_ctx gctx
;
6475 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr
), pre_p
,
6476 find_omp_clause (OMP_TASK_CLAUSES (expr
),
6478 ? ORT_UNTIED_TASK
: ORT_TASK
);
6480 push_gimplify_context (&gctx
);
6482 g
= gimplify_and_return_first (OMP_TASK_BODY (expr
), &body
);
6483 if (gimple_code (g
) == GIMPLE_BIND
)
6484 pop_gimplify_context (g
);
6486 pop_gimplify_context (NULL
);
6488 gimplify_adjust_omp_clauses (&OMP_TASK_CLAUSES (expr
));
6490 g
= gimple_build_omp_task (body
,
6491 OMP_TASK_CLAUSES (expr
),
6492 NULL_TREE
, NULL_TREE
,
6493 NULL_TREE
, NULL_TREE
, NULL_TREE
);
6494 gimplify_seq_add_stmt (pre_p
, g
);
6495 *expr_p
= NULL_TREE
;
6498 /* Gimplify the gross structure of an OMP_FOR statement. */
6500 static enum gimplify_status
6501 gimplify_omp_for (tree
*expr_p
, gimple_seq
*pre_p
)
6503 tree for_stmt
, decl
, var
, t
;
6504 enum gimplify_status ret
= GS_ALL_DONE
;
6505 enum gimplify_status tret
;
6507 gimple_seq for_body
, for_pre_body
;
6512 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
), pre_p
,
6515 /* Handle OMP_FOR_INIT. */
6516 for_pre_body
= NULL
;
6517 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
6518 OMP_FOR_PRE_BODY (for_stmt
) = NULL_TREE
;
6521 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6522 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt
)));
6523 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6524 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt
)));
6525 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6527 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6528 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6529 decl
= TREE_OPERAND (t
, 0);
6530 gcc_assert (DECL_P (decl
));
6531 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl
))
6532 || POINTER_TYPE_P (TREE_TYPE (decl
)));
6534 /* Make sure the iteration variable is private. */
6535 if (omp_is_private (gimplify_omp_ctxp
, decl
))
6536 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
6538 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_PRIVATE
| GOVD_SEEN
);
6540 /* If DECL is not a gimple register, create a temporary variable to act
6541 as an iteration counter. This is valid, since DECL cannot be
6542 modified in the body of the loop. */
6543 if (!is_gimple_reg (decl
))
6545 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
6546 TREE_OPERAND (t
, 0) = var
;
6548 gimplify_seq_add_stmt (&for_body
, gimple_build_assign (decl
, var
));
6550 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
6555 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6556 is_gimple_val
, fb_rvalue
);
6557 ret
= MIN (ret
, tret
);
6558 if (ret
== GS_ERROR
)
6561 /* Handle OMP_FOR_COND. */
6562 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
6563 gcc_assert (COMPARISON_CLASS_P (t
));
6564 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6566 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6567 is_gimple_val
, fb_rvalue
);
6568 ret
= MIN (ret
, tret
);
6570 /* Handle OMP_FOR_INCR. */
6571 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6572 switch (TREE_CODE (t
))
6574 case PREINCREMENT_EXPR
:
6575 case POSTINCREMENT_EXPR
:
6576 t
= build_int_cst (TREE_TYPE (decl
), 1);
6577 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6578 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6579 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6582 case PREDECREMENT_EXPR
:
6583 case POSTDECREMENT_EXPR
:
6584 t
= build_int_cst (TREE_TYPE (decl
), -1);
6585 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6586 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6587 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6591 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6592 TREE_OPERAND (t
, 0) = var
;
6594 t
= TREE_OPERAND (t
, 1);
6595 switch (TREE_CODE (t
))
6598 if (TREE_OPERAND (t
, 1) == decl
)
6600 TREE_OPERAND (t
, 1) = TREE_OPERAND (t
, 0);
6601 TREE_OPERAND (t
, 0) = var
;
6607 case POINTER_PLUS_EXPR
:
6608 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6609 TREE_OPERAND (t
, 0) = var
;
6615 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6616 is_gimple_val
, fb_rvalue
);
6617 ret
= MIN (ret
, tret
);
6624 if (var
!= decl
|| TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1)
6627 for (c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
6628 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6629 && OMP_CLAUSE_DECL (c
) == decl
6630 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) == NULL
)
6632 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6633 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6634 gcc_assert (TREE_OPERAND (t
, 0) == var
);
6635 t
= TREE_OPERAND (t
, 1);
6636 gcc_assert (TREE_CODE (t
) == PLUS_EXPR
6637 || TREE_CODE (t
) == MINUS_EXPR
6638 || TREE_CODE (t
) == POINTER_PLUS_EXPR
);
6639 gcc_assert (TREE_OPERAND (t
, 0) == var
);
6640 t
= build2 (TREE_CODE (t
), TREE_TYPE (decl
), decl
,
6641 TREE_OPERAND (t
, 1));
6642 gimplify_assign (decl
, t
,
6643 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6648 gimplify_and_add (OMP_FOR_BODY (for_stmt
), &for_body
);
6650 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
));
6652 gfor
= gimple_build_omp_for (for_body
, OMP_FOR_CLAUSES (for_stmt
),
6653 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)),
6656 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6658 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6659 gimple_omp_for_set_index (gfor
, i
, TREE_OPERAND (t
, 0));
6660 gimple_omp_for_set_initial (gfor
, i
, TREE_OPERAND (t
, 1));
6661 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
6662 gimple_omp_for_set_cond (gfor
, i
, TREE_CODE (t
));
6663 gimple_omp_for_set_final (gfor
, i
, TREE_OPERAND (t
, 1));
6664 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6665 gimple_omp_for_set_incr (gfor
, i
, TREE_OPERAND (t
, 1));
6668 gimplify_seq_add_stmt (pre_p
, gfor
);
6669 return ret
== GS_ALL_DONE
? GS_ALL_DONE
: GS_ERROR
;
6672 /* Gimplify the gross structure of other OpenMP worksharing constructs.
6673 In particular, OMP_SECTIONS and OMP_SINGLE. */
6676 gimplify_omp_workshare (tree
*expr_p
, gimple_seq
*pre_p
)
6678 tree expr
= *expr_p
;
6680 gimple_seq body
= NULL
;
6682 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr
), pre_p
, ORT_WORKSHARE
);
6683 gimplify_and_add (OMP_BODY (expr
), &body
);
6684 gimplify_adjust_omp_clauses (&OMP_CLAUSES (expr
));
6686 if (TREE_CODE (expr
) == OMP_SECTIONS
)
6687 stmt
= gimple_build_omp_sections (body
, OMP_CLAUSES (expr
));
6688 else if (TREE_CODE (expr
) == OMP_SINGLE
)
6689 stmt
= gimple_build_omp_single (body
, OMP_CLAUSES (expr
));
6693 gimplify_seq_add_stmt (pre_p
, stmt
);
6696 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
6697 stabilized the lhs of the atomic operation as *ADDR. Return true if
6698 EXPR is this stabilized form. */
6701 goa_lhs_expr_p (tree expr
, tree addr
)
6703 /* Also include casts to other type variants. The C front end is fond
6704 of adding these for e.g. volatile variables. This is like
6705 STRIP_TYPE_NOPS but includes the main variant lookup. */
6706 STRIP_USELESS_TYPE_CONVERSION (expr
);
6708 if (TREE_CODE (expr
) == INDIRECT_REF
)
6710 expr
= TREE_OPERAND (expr
, 0);
6712 && (CONVERT_EXPR_P (expr
)
6713 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
6714 && TREE_CODE (expr
) == TREE_CODE (addr
)
6715 && types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (addr
)))
6717 expr
= TREE_OPERAND (expr
, 0);
6718 addr
= TREE_OPERAND (addr
, 0);
6722 return (TREE_CODE (addr
) == ADDR_EXPR
6723 && TREE_CODE (expr
) == ADDR_EXPR
6724 && TREE_OPERAND (addr
, 0) == TREE_OPERAND (expr
, 0));
6726 if (TREE_CODE (addr
) == ADDR_EXPR
&& expr
== TREE_OPERAND (addr
, 0))
6731 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
6732 expression does not involve the lhs, evaluate it into a temporary.
6733 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
6734 or -1 if an error was encountered. */
6737 goa_stabilize_expr (tree
*expr_p
, gimple_seq
*pre_p
, tree lhs_addr
,
6740 tree expr
= *expr_p
;
6743 if (goa_lhs_expr_p (expr
, lhs_addr
))
6748 if (is_gimple_val (expr
))
6752 switch (TREE_CODE_CLASS (TREE_CODE (expr
)))
6755 case tcc_comparison
:
6756 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
, lhs_addr
,
6759 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
, lhs_addr
,
6762 case tcc_expression
:
6763 switch (TREE_CODE (expr
))
6765 case TRUTH_ANDIF_EXPR
:
6766 case TRUTH_ORIF_EXPR
:
6767 case TRUTH_AND_EXPR
:
6769 case TRUTH_XOR_EXPR
:
6770 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
,
6772 case TRUTH_NOT_EXPR
:
6773 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
6777 /* Break out any preevaluations from cp_build_modify_expr. */
6778 for (; TREE_CODE (expr
) == COMPOUND_EXPR
;
6779 expr
= TREE_OPERAND (expr
, 1))
6780 gimplify_stmt (&TREE_OPERAND (expr
, 0), pre_p
);
6782 return goa_stabilize_expr (expr_p
, pre_p
, lhs_addr
, lhs_var
);
6793 enum gimplify_status gs
;
6794 gs
= gimplify_expr (expr_p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
6795 if (gs
!= GS_ALL_DONE
)
6802 /* Gimplify an OMP_ATOMIC statement. */
6804 static enum gimplify_status
6805 gimplify_omp_atomic (tree
*expr_p
, gimple_seq
*pre_p
)
6807 tree addr
= TREE_OPERAND (*expr_p
, 0);
6808 tree rhs
= TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
6809 ? NULL
: TREE_OPERAND (*expr_p
, 1);
6810 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
6812 gimple loadstmt
, storestmt
;
6814 tmp_load
= create_tmp_reg (type
, NULL
);
6815 if (rhs
&& goa_stabilize_expr (&rhs
, pre_p
, addr
, tmp_load
) < 0)
6818 if (gimplify_expr (&addr
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
6822 loadstmt
= gimple_build_omp_atomic_load (tmp_load
, addr
);
6823 gimplify_seq_add_stmt (pre_p
, loadstmt
);
6824 if (rhs
&& gimplify_expr (&rhs
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
6828 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
)
6830 storestmt
= gimple_build_omp_atomic_store (rhs
);
6831 gimplify_seq_add_stmt (pre_p
, storestmt
);
6832 switch (TREE_CODE (*expr_p
))
6834 case OMP_ATOMIC_READ
:
6835 case OMP_ATOMIC_CAPTURE_OLD
:
6837 gimple_omp_atomic_set_need_value (loadstmt
);
6839 case OMP_ATOMIC_CAPTURE_NEW
:
6841 gimple_omp_atomic_set_need_value (storestmt
);
6851 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
6852 body, and adding some EH bits. */
6854 static enum gimplify_status
6855 gimplify_transaction (tree
*expr_p
, gimple_seq
*pre_p
)
6857 tree expr
= *expr_p
, temp
, tbody
= TRANSACTION_EXPR_BODY (expr
);
6859 gimple_seq body
= NULL
;
6860 struct gimplify_ctx gctx
;
6863 /* Wrap the transaction body in a BIND_EXPR so we have a context
6864 where to put decls for OpenMP. */
6865 if (TREE_CODE (tbody
) != BIND_EXPR
)
6867 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, tbody
, NULL
);
6868 TREE_SIDE_EFFECTS (bind
) = 1;
6869 SET_EXPR_LOCATION (bind
, EXPR_LOCATION (tbody
));
6870 TRANSACTION_EXPR_BODY (expr
) = bind
;
6873 push_gimplify_context (&gctx
);
6874 temp
= voidify_wrapper_expr (*expr_p
, NULL
);
6876 g
= gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr
), &body
);
6877 pop_gimplify_context (g
);
6879 g
= gimple_build_transaction (body
, NULL
);
6880 if (TRANSACTION_EXPR_OUTER (expr
))
6881 subcode
= GTMA_IS_OUTER
;
6882 else if (TRANSACTION_EXPR_RELAXED (expr
))
6883 subcode
= GTMA_IS_RELAXED
;
6884 gimple_transaction_set_subcode (g
, subcode
);
6886 gimplify_seq_add_stmt (pre_p
, g
);
6894 *expr_p
= NULL_TREE
;
6898 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
6899 expression produces a value to be used as an operand inside a GIMPLE
6900 statement, the value will be stored back in *EXPR_P. This value will
6901 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
6902 an SSA_NAME. The corresponding sequence of GIMPLE statements is
6903 emitted in PRE_P and POST_P.
6905 Additionally, this process may overwrite parts of the input
6906 expression during gimplification. Ideally, it should be
6907 possible to do non-destructive gimplification.
6909 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
6910 the expression needs to evaluate to a value to be used as
6911 an operand in a GIMPLE statement, this value will be stored in
6912 *EXPR_P on exit. This happens when the caller specifies one
6913 of fb_lvalue or fb_rvalue fallback flags.
6915 PRE_P will contain the sequence of GIMPLE statements corresponding
6916 to the evaluation of EXPR and all the side-effects that must
6917 be executed before the main expression. On exit, the last
6918 statement of PRE_P is the core statement being gimplified. For
6919 instance, when gimplifying 'if (++a)' the last statement in
6920 PRE_P will be 'if (t.1)' where t.1 is the result of
6921 pre-incrementing 'a'.
6923 POST_P will contain the sequence of GIMPLE statements corresponding
6924 to the evaluation of all the side-effects that must be executed
6925 after the main expression. If this is NULL, the post
6926 side-effects are stored at the end of PRE_P.
6928 The reason why the output is split in two is to handle post
6929 side-effects explicitly. In some cases, an expression may have
6930 inner and outer post side-effects which need to be emitted in
6931 an order different from the one given by the recursive
6932 traversal. For instance, for the expression (*p--)++ the post
6933 side-effects of '--' must actually occur *after* the post
6934 side-effects of '++'. However, gimplification will first visit
6935 the inner expression, so if a separate POST sequence was not
6936 used, the resulting sequence would be:
6943 However, the post-decrement operation in line #2 must not be
6944 evaluated until after the store to *p at line #4, so the
6945 correct sequence should be:
6952 So, by specifying a separate post queue, it is possible
6953 to emit the post side-effects in the correct order.
6954 If POST_P is NULL, an internal queue will be used. Before
6955 returning to the caller, the sequence POST_P is appended to
6956 the main output sequence PRE_P.
6958 GIMPLE_TEST_F points to a function that takes a tree T and
6959 returns nonzero if T is in the GIMPLE form requested by the
6960 caller. The GIMPLE predicates are in gimple.c.
6962 FALLBACK tells the function what sort of a temporary we want if
6963 gimplification cannot produce an expression that complies with
6966 fb_none means that no temporary should be generated
6967 fb_rvalue means that an rvalue is OK to generate
6968 fb_lvalue means that an lvalue is OK to generate
6969 fb_either means that either is OK, but an lvalue is preferable.
6970 fb_mayfail means that gimplification may fail (in which case
6971 GS_ERROR will be returned)
6973 The return value is either GS_ERROR or GS_ALL_DONE, since this
6974 function iterates until EXPR is completely gimplified or an error
6977 enum gimplify_status
6978 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
6979 bool (*gimple_test_f
) (tree
), fallback_t fallback
)
6982 gimple_seq internal_pre
= NULL
;
6983 gimple_seq internal_post
= NULL
;
6986 location_t saved_location
;
6987 enum gimplify_status ret
;
6988 gimple_stmt_iterator pre_last_gsi
, post_last_gsi
;
6990 save_expr
= *expr_p
;
6991 if (save_expr
== NULL_TREE
)
6994 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
6995 is_statement
= gimple_test_f
== is_gimple_stmt
;
6999 /* Consistency checks. */
7000 if (gimple_test_f
== is_gimple_reg
)
7001 gcc_assert (fallback
& (fb_rvalue
| fb_lvalue
));
7002 else if (gimple_test_f
== is_gimple_val
7003 || gimple_test_f
== is_gimple_call_addr
7004 || gimple_test_f
== is_gimple_condexpr
7005 || gimple_test_f
== is_gimple_mem_rhs
7006 || gimple_test_f
== is_gimple_mem_rhs_or_call
7007 || gimple_test_f
== is_gimple_reg_rhs
7008 || gimple_test_f
== is_gimple_reg_rhs_or_call
7009 || gimple_test_f
== is_gimple_asm_val
7010 || gimple_test_f
== is_gimple_mem_ref_addr
)
7011 gcc_assert (fallback
& fb_rvalue
);
7012 else if (gimple_test_f
== is_gimple_min_lval
7013 || gimple_test_f
== is_gimple_lvalue
)
7014 gcc_assert (fallback
& fb_lvalue
);
7015 else if (gimple_test_f
== is_gimple_addressable
)
7016 gcc_assert (fallback
& fb_either
);
7017 else if (gimple_test_f
== is_gimple_stmt
)
7018 gcc_assert (fallback
== fb_none
);
7021 /* We should have recognized the GIMPLE_TEST_F predicate to
7022 know what kind of fallback to use in case a temporary is
7023 needed to hold the value or address of *EXPR_P. */
7027 /* We used to check the predicate here and return immediately if it
7028 succeeds. This is wrong; the design is for gimplification to be
7029 idempotent, and for the predicates to only test for valid forms, not
7030 whether they are fully simplified. */
7032 pre_p
= &internal_pre
;
7035 post_p
= &internal_post
;
7037 /* Remember the last statements added to PRE_P and POST_P. Every
7038 new statement added by the gimplification helpers needs to be
7039 annotated with location information. To centralize the
7040 responsibility, we remember the last statement that had been
7041 added to both queues before gimplifying *EXPR_P. If
7042 gimplification produces new statements in PRE_P and POST_P, those
7043 statements will be annotated with the same location information
7045 pre_last_gsi
= gsi_last (*pre_p
);
7046 post_last_gsi
= gsi_last (*post_p
);
7048 saved_location
= input_location
;
7049 if (save_expr
!= error_mark_node
7050 && EXPR_HAS_LOCATION (*expr_p
))
7051 input_location
= EXPR_LOCATION (*expr_p
);
7053 /* Loop over the specific gimplifiers until the toplevel node
7054 remains the same. */
7057 /* Strip away as many useless type conversions as possible
7059 STRIP_USELESS_TYPE_CONVERSION (*expr_p
);
7061 /* Remember the expr. */
7062 save_expr
= *expr_p
;
7064 /* Die, die, die, my darling. */
7065 if (save_expr
== error_mark_node
7066 || (TREE_TYPE (save_expr
)
7067 && TREE_TYPE (save_expr
) == error_mark_node
))
7073 /* Do any language-specific gimplification. */
7074 ret
= ((enum gimplify_status
)
7075 lang_hooks
.gimplify_expr (expr_p
, pre_p
, post_p
));
7078 if (*expr_p
== NULL_TREE
)
7080 if (*expr_p
!= save_expr
)
7083 else if (ret
!= GS_UNHANDLED
)
7086 /* Make sure that all the cases set 'ret' appropriately. */
7088 switch (TREE_CODE (*expr_p
))
7090 /* First deal with the special cases. */
7092 case POSTINCREMENT_EXPR
:
7093 case POSTDECREMENT_EXPR
:
7094 case PREINCREMENT_EXPR
:
7095 case PREDECREMENT_EXPR
:
7096 ret
= gimplify_self_mod_expr (expr_p
, pre_p
, post_p
,
7097 fallback
!= fb_none
,
7098 TREE_TYPE (*expr_p
));
7102 case ARRAY_RANGE_REF
:
7106 case VIEW_CONVERT_EXPR
:
7107 ret
= gimplify_compound_lval (expr_p
, pre_p
, post_p
,
7108 fallback
? fallback
: fb_rvalue
);
7112 ret
= gimplify_cond_expr (expr_p
, pre_p
, fallback
);
7114 /* C99 code may assign to an array in a structure value of a
7115 conditional expression, and this has undefined behavior
7116 only on execution, so create a temporary if an lvalue is
7118 if (fallback
== fb_lvalue
)
7120 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7121 mark_addressable (*expr_p
);
7127 ret
= gimplify_call_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7129 /* C99 code may assign to an array in a structure returned
7130 from a function, and this has undefined behavior only on
7131 execution, so create a temporary if an lvalue is
7133 if (fallback
== fb_lvalue
)
7135 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7136 mark_addressable (*expr_p
);
7145 ret
= gimplify_compound_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7148 case COMPOUND_LITERAL_EXPR
:
7149 ret
= gimplify_compound_literal_expr (expr_p
, pre_p
,
7150 gimple_test_f
, fallback
);
7155 ret
= gimplify_modify_expr (expr_p
, pre_p
, post_p
,
7156 fallback
!= fb_none
);
7159 case TRUTH_ANDIF_EXPR
:
7160 case TRUTH_ORIF_EXPR
:
7162 /* Preserve the original type of the expression and the
7163 source location of the outer expression. */
7164 tree org_type
= TREE_TYPE (*expr_p
);
7165 *expr_p
= gimple_boolify (*expr_p
);
7166 *expr_p
= build3_loc (input_location
, COND_EXPR
,
7170 org_type
, boolean_true_node
),
7173 org_type
, boolean_false_node
));
7178 case TRUTH_NOT_EXPR
:
7180 tree type
= TREE_TYPE (*expr_p
);
7181 /* The parsers are careful to generate TRUTH_NOT_EXPR
7182 only with operands that are always zero or one.
7183 We do not fold here but handle the only interesting case
7184 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
7185 *expr_p
= gimple_boolify (*expr_p
);
7186 if (TYPE_PRECISION (TREE_TYPE (*expr_p
)) == 1)
7187 *expr_p
= build1_loc (input_location
, BIT_NOT_EXPR
,
7188 TREE_TYPE (*expr_p
),
7189 TREE_OPERAND (*expr_p
, 0));
7191 *expr_p
= build2_loc (input_location
, BIT_XOR_EXPR
,
7192 TREE_TYPE (*expr_p
),
7193 TREE_OPERAND (*expr_p
, 0),
7194 build_int_cst (TREE_TYPE (*expr_p
), 1));
7195 if (!useless_type_conversion_p (type
, TREE_TYPE (*expr_p
)))
7196 *expr_p
= fold_convert_loc (input_location
, type
, *expr_p
);
7202 ret
= gimplify_addr_expr (expr_p
, pre_p
, post_p
);
7206 ret
= gimplify_va_arg_expr (expr_p
, pre_p
, post_p
);
7210 if (IS_EMPTY_STMT (*expr_p
))
7216 if (VOID_TYPE_P (TREE_TYPE (*expr_p
))
7217 || fallback
== fb_none
)
7219 /* Just strip a conversion to void (or in void context) and
7221 *expr_p
= TREE_OPERAND (*expr_p
, 0);
7226 ret
= gimplify_conversion (expr_p
);
7227 if (ret
== GS_ERROR
)
7229 if (*expr_p
!= save_expr
)
7233 case FIX_TRUNC_EXPR
:
7234 /* unary_expr: ... | '(' cast ')' val | ... */
7235 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7236 is_gimple_val
, fb_rvalue
);
7237 recalculate_side_effects (*expr_p
);
7242 bool volatilep
= TREE_THIS_VOLATILE (*expr_p
);
7243 bool notrap
= TREE_THIS_NOTRAP (*expr_p
);
7244 tree saved_ptr_type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 0));
7246 *expr_p
= fold_indirect_ref_loc (input_location
, *expr_p
);
7247 if (*expr_p
!= save_expr
)
7253 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7254 is_gimple_reg
, fb_rvalue
);
7255 if (ret
== GS_ERROR
)
7258 recalculate_side_effects (*expr_p
);
7259 *expr_p
= fold_build2_loc (input_location
, MEM_REF
,
7260 TREE_TYPE (*expr_p
),
7261 TREE_OPERAND (*expr_p
, 0),
7262 build_int_cst (saved_ptr_type
, 0));
7263 TREE_THIS_VOLATILE (*expr_p
) = volatilep
;
7264 TREE_THIS_NOTRAP (*expr_p
) = notrap
;
7269 /* We arrive here through the various re-gimplifcation paths. */
7271 /* First try re-folding the whole thing. */
7272 tmp
= fold_binary (MEM_REF
, TREE_TYPE (*expr_p
),
7273 TREE_OPERAND (*expr_p
, 0),
7274 TREE_OPERAND (*expr_p
, 1));
7278 recalculate_side_effects (*expr_p
);
7282 /* Avoid re-gimplifying the address operand if it is already
7283 in suitable form. Re-gimplifying would mark the address
7284 operand addressable. Always gimplify when not in SSA form
7285 as we still may have to gimplify decls with value-exprs. */
7286 if (!gimplify_ctxp
|| !gimplify_ctxp
->into_ssa
7287 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p
, 0)))
7289 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7290 is_gimple_mem_ref_addr
, fb_rvalue
);
7291 if (ret
== GS_ERROR
)
7294 recalculate_side_effects (*expr_p
);
7298 /* Constants need not be gimplified. */
7309 /* If we require an lvalue, such as for ADDR_EXPR, retain the
7310 CONST_DECL node. Otherwise the decl is replaceable by its
7312 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
7313 if (fallback
& fb_lvalue
)
7317 *expr_p
= DECL_INITIAL (*expr_p
);
7323 ret
= gimplify_decl_expr (expr_p
, pre_p
);
7327 ret
= gimplify_bind_expr (expr_p
, pre_p
);
7331 ret
= gimplify_loop_expr (expr_p
, pre_p
);
7335 ret
= gimplify_switch_expr (expr_p
, pre_p
);
7339 ret
= gimplify_exit_expr (expr_p
);
7343 /* If the target is not LABEL, then it is a computed jump
7344 and the target needs to be gimplified. */
7345 if (TREE_CODE (GOTO_DESTINATION (*expr_p
)) != LABEL_DECL
)
7347 ret
= gimplify_expr (&GOTO_DESTINATION (*expr_p
), pre_p
,
7348 NULL
, is_gimple_val
, fb_rvalue
);
7349 if (ret
== GS_ERROR
)
7352 gimplify_seq_add_stmt (pre_p
,
7353 gimple_build_goto (GOTO_DESTINATION (*expr_p
)));
7358 gimplify_seq_add_stmt (pre_p
,
7359 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p
),
7360 PREDICT_EXPR_OUTCOME (*expr_p
)));
7366 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p
))
7367 == current_function_decl
);
7368 gimplify_seq_add_stmt (pre_p
,
7369 gimple_build_label (LABEL_EXPR_LABEL (*expr_p
)));
7372 case CASE_LABEL_EXPR
:
7373 ret
= gimplify_case_label_expr (expr_p
, pre_p
);
7377 ret
= gimplify_return_expr (*expr_p
, pre_p
);
7381 /* Don't reduce this in place; let gimplify_init_constructor work its
7382 magic. Buf if we're just elaborating this for side effects, just
7383 gimplify any element that has side-effects. */
7384 if (fallback
== fb_none
)
7386 unsigned HOST_WIDE_INT ix
;
7388 tree temp
= NULL_TREE
;
7389 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p
), ix
, val
)
7390 if (TREE_SIDE_EFFECTS (val
))
7391 append_to_statement_list (val
, &temp
);
7394 ret
= temp
? GS_OK
: GS_ALL_DONE
;
7396 /* C99 code may assign to an array in a constructed
7397 structure or union, and this has undefined behavior only
7398 on execution, so create a temporary if an lvalue is
7400 else if (fallback
== fb_lvalue
)
7402 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7403 mark_addressable (*expr_p
);
7410 /* The following are special cases that are not handled by the
7411 original GIMPLE grammar. */
7413 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
7416 ret
= gimplify_save_expr (expr_p
, pre_p
, post_p
);
7420 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7421 post_p
, is_gimple_lvalue
, fb_either
);
7422 recalculate_side_effects (*expr_p
);
7425 case TARGET_MEM_REF
:
7427 enum gimplify_status r0
= GS_ALL_DONE
, r1
= GS_ALL_DONE
;
7429 if (TMR_BASE (*expr_p
))
7430 r0
= gimplify_expr (&TMR_BASE (*expr_p
), pre_p
,
7431 post_p
, is_gimple_mem_ref_addr
, fb_either
);
7432 if (TMR_INDEX (*expr_p
))
7433 r1
= gimplify_expr (&TMR_INDEX (*expr_p
), pre_p
,
7434 post_p
, is_gimple_val
, fb_rvalue
);
7435 if (TMR_INDEX2 (*expr_p
))
7436 r1
= gimplify_expr (&TMR_INDEX2 (*expr_p
), pre_p
,
7437 post_p
, is_gimple_val
, fb_rvalue
);
7438 /* TMR_STEP and TMR_OFFSET are always integer constants. */
7443 case NON_LVALUE_EXPR
:
7444 /* This should have been stripped above. */
7448 ret
= gimplify_asm_expr (expr_p
, pre_p
, post_p
);
7451 case TRY_FINALLY_EXPR
:
7452 case TRY_CATCH_EXPR
:
7454 gimple_seq eval
, cleanup
;
7457 /* Calls to destructors are generated automatically in FINALLY/CATCH
7458 block. They should have location as UNKNOWN_LOCATION. However,
7459 gimplify_call_expr will reset these call stmts to input_location
7460 if it finds stmt's location is unknown. To prevent resetting for
7461 destructors, we set the input_location to unknown.
7462 Note that this only affects the destructor calls in FINALLY/CATCH
7463 block, and will automatically reset to its original value by the
7464 end of gimplify_expr. */
7465 input_location
= UNKNOWN_LOCATION
;
7466 eval
= cleanup
= NULL
;
7467 gimplify_and_add (TREE_OPERAND (*expr_p
, 0), &eval
);
7468 gimplify_and_add (TREE_OPERAND (*expr_p
, 1), &cleanup
);
7469 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
7470 if (gimple_seq_empty_p (cleanup
))
7472 gimple_seq_add_seq (pre_p
, eval
);
7476 try_
= gimple_build_try (eval
, cleanup
,
7477 TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
7478 ? GIMPLE_TRY_FINALLY
7479 : GIMPLE_TRY_CATCH
);
7480 if (LOCATION_LOCUS (saved_location
) != UNKNOWN_LOCATION
)
7481 gimple_set_location (try_
, saved_location
);
7483 gimple_set_location (try_
, EXPR_LOCATION (save_expr
));
7484 if (TREE_CODE (*expr_p
) == TRY_CATCH_EXPR
)
7485 gimple_try_set_catch_is_cleanup (try_
,
7486 TRY_CATCH_IS_CLEANUP (*expr_p
));
7487 gimplify_seq_add_stmt (pre_p
, try_
);
7492 case CLEANUP_POINT_EXPR
:
7493 ret
= gimplify_cleanup_point_expr (expr_p
, pre_p
);
7497 ret
= gimplify_target_expr (expr_p
, pre_p
, post_p
);
7503 gimple_seq handler
= NULL
;
7504 gimplify_and_add (CATCH_BODY (*expr_p
), &handler
);
7505 c
= gimple_build_catch (CATCH_TYPES (*expr_p
), handler
);
7506 gimplify_seq_add_stmt (pre_p
, c
);
7511 case EH_FILTER_EXPR
:
7514 gimple_seq failure
= NULL
;
7516 gimplify_and_add (EH_FILTER_FAILURE (*expr_p
), &failure
);
7517 ehf
= gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p
), failure
);
7518 gimple_set_no_warning (ehf
, TREE_NO_WARNING (*expr_p
));
7519 gimplify_seq_add_stmt (pre_p
, ehf
);
7526 enum gimplify_status r0
, r1
;
7527 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
,
7528 post_p
, is_gimple_val
, fb_rvalue
);
7529 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
,
7530 post_p
, is_gimple_val
, fb_rvalue
);
7531 TREE_SIDE_EFFECTS (*expr_p
) = 0;
7537 /* We get here when taking the address of a label. We mark
7538 the label as "forced"; meaning it can never be removed and
7539 it is a potential target for any computed goto. */
7540 FORCED_LABEL (*expr_p
) = 1;
7544 case STATEMENT_LIST
:
7545 ret
= gimplify_statement_list (expr_p
, pre_p
);
7548 case WITH_SIZE_EXPR
:
7550 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7551 post_p
== &internal_post
? NULL
: post_p
,
7552 gimple_test_f
, fallback
);
7553 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
7554 is_gimple_val
, fb_rvalue
);
7561 ret
= gimplify_var_or_parm_decl (expr_p
);
7565 /* When within an OpenMP context, notice uses of variables. */
7566 if (gimplify_omp_ctxp
)
7567 omp_notice_variable (gimplify_omp_ctxp
, *expr_p
, true);
7572 /* Allow callbacks into the gimplifier during optimization. */
7577 gimplify_omp_parallel (expr_p
, pre_p
);
7582 gimplify_omp_task (expr_p
, pre_p
);
7587 ret
= gimplify_omp_for (expr_p
, pre_p
);
7592 gimplify_omp_workshare (expr_p
, pre_p
);
7601 gimple_seq body
= NULL
;
7604 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
7605 switch (TREE_CODE (*expr_p
))
7608 g
= gimple_build_omp_section (body
);
7611 g
= gimple_build_omp_master (body
);
7614 g
= gimple_build_omp_ordered (body
);
7617 g
= gimple_build_omp_critical (body
,
7618 OMP_CRITICAL_NAME (*expr_p
));
7623 gimplify_seq_add_stmt (pre_p
, g
);
7629 case OMP_ATOMIC_READ
:
7630 case OMP_ATOMIC_CAPTURE_OLD
:
7631 case OMP_ATOMIC_CAPTURE_NEW
:
7632 ret
= gimplify_omp_atomic (expr_p
, pre_p
);
7635 case TRANSACTION_EXPR
:
7636 ret
= gimplify_transaction (expr_p
, pre_p
);
7639 case TRUTH_AND_EXPR
:
7641 case TRUTH_XOR_EXPR
:
7643 tree orig_type
= TREE_TYPE (*expr_p
);
7644 tree new_type
, xop0
, xop1
;
7645 *expr_p
= gimple_boolify (*expr_p
);
7646 new_type
= TREE_TYPE (*expr_p
);
7647 if (!useless_type_conversion_p (orig_type
, new_type
))
7649 *expr_p
= fold_convert_loc (input_location
, orig_type
, *expr_p
);
7654 /* Boolified binary truth expressions are semantically equivalent
7655 to bitwise binary expressions. Canonicalize them to the
7657 switch (TREE_CODE (*expr_p
))
7659 case TRUTH_AND_EXPR
:
7660 TREE_SET_CODE (*expr_p
, BIT_AND_EXPR
);
7663 TREE_SET_CODE (*expr_p
, BIT_IOR_EXPR
);
7665 case TRUTH_XOR_EXPR
:
7666 TREE_SET_CODE (*expr_p
, BIT_XOR_EXPR
);
7671 /* Now make sure that operands have compatible type to
7672 expression's new_type. */
7673 xop0
= TREE_OPERAND (*expr_p
, 0);
7674 xop1
= TREE_OPERAND (*expr_p
, 1);
7675 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop0
)))
7676 TREE_OPERAND (*expr_p
, 0) = fold_convert_loc (input_location
,
7679 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop1
)))
7680 TREE_OPERAND (*expr_p
, 1) = fold_convert_loc (input_location
,
7683 /* Continue classified as tcc_binary. */
7690 /* Classified as tcc_expression. */
7693 case POINTER_PLUS_EXPR
:
7695 enum gimplify_status r0
, r1
;
7696 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7697 post_p
, is_gimple_val
, fb_rvalue
);
7698 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7699 post_p
, is_gimple_val
, fb_rvalue
);
7700 recalculate_side_effects (*expr_p
);
7702 /* Convert &X + CST to invariant &MEM[&X, CST]. Do this
7703 after gimplifying operands - this is similar to how
7704 it would be folding all gimplified stmts on creation
7705 to have them canonicalized, which is what we eventually
7706 should do anyway. */
7707 if (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == INTEGER_CST
7708 && is_gimple_min_invariant (TREE_OPERAND (*expr_p
, 0)))
7710 *expr_p
= build_fold_addr_expr_with_type_loc
7712 fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (*expr_p
)),
7713 TREE_OPERAND (*expr_p
, 0),
7714 fold_convert (ptr_type_node
,
7715 TREE_OPERAND (*expr_p
, 1))),
7716 TREE_TYPE (*expr_p
));
7717 ret
= MIN (ret
, GS_OK
);
7723 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p
)))
7725 case tcc_comparison
:
7726 /* Handle comparison of objects of non scalar mode aggregates
7727 with a call to memcmp. It would be nice to only have to do
7728 this for variable-sized objects, but then we'd have to allow
7729 the same nest of reference nodes we allow for MODIFY_EXPR and
7732 Compare scalar mode aggregates as scalar mode values. Using
7733 memcmp for them would be very inefficient at best, and is
7734 plain wrong if bitfields are involved. */
7736 tree type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 1));
7738 /* Vector comparisons need no boolification. */
7739 if (TREE_CODE (type
) == VECTOR_TYPE
)
7741 else if (!AGGREGATE_TYPE_P (type
))
7743 tree org_type
= TREE_TYPE (*expr_p
);
7744 *expr_p
= gimple_boolify (*expr_p
);
7745 if (!useless_type_conversion_p (org_type
,
7746 TREE_TYPE (*expr_p
)))
7748 *expr_p
= fold_convert_loc (input_location
,
7755 else if (TYPE_MODE (type
) != BLKmode
)
7756 ret
= gimplify_scalar_mode_aggregate_compare (expr_p
);
7758 ret
= gimplify_variable_sized_compare (expr_p
);
7763 /* If *EXPR_P does not need to be special-cased, handle it
7764 according to its class. */
7766 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7767 post_p
, is_gimple_val
, fb_rvalue
);
7773 enum gimplify_status r0
, r1
;
7775 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7776 post_p
, is_gimple_val
, fb_rvalue
);
7777 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7778 post_p
, is_gimple_val
, fb_rvalue
);
7786 enum gimplify_status r0
, r1
, r2
;
7788 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7789 post_p
, is_gimple_val
, fb_rvalue
);
7790 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7791 post_p
, is_gimple_val
, fb_rvalue
);
7792 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
7793 post_p
, is_gimple_val
, fb_rvalue
);
7795 ret
= MIN (MIN (r0
, r1
), r2
);
7799 case tcc_declaration
:
7802 goto dont_recalculate
;
7808 recalculate_side_effects (*expr_p
);
7814 gcc_assert (*expr_p
|| ret
!= GS_OK
);
7816 while (ret
== GS_OK
);
7818 /* If we encountered an error_mark somewhere nested inside, either
7819 stub out the statement or propagate the error back out. */
7820 if (ret
== GS_ERROR
)
7827 /* This was only valid as a return value from the langhook, which
7828 we handled. Make sure it doesn't escape from any other context. */
7829 gcc_assert (ret
!= GS_UNHANDLED
);
7831 if (fallback
== fb_none
&& *expr_p
&& !is_gimple_stmt (*expr_p
))
7833 /* We aren't looking for a value, and we don't have a valid
7834 statement. If it doesn't have side-effects, throw it away. */
7835 if (!TREE_SIDE_EFFECTS (*expr_p
))
7837 else if (!TREE_THIS_VOLATILE (*expr_p
))
7839 /* This is probably a _REF that contains something nested that
7840 has side effects. Recurse through the operands to find it. */
7841 enum tree_code code
= TREE_CODE (*expr_p
);
7848 case VIEW_CONVERT_EXPR
:
7849 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7850 gimple_test_f
, fallback
);
7854 case ARRAY_RANGE_REF
:
7855 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7856 gimple_test_f
, fallback
);
7857 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
7858 gimple_test_f
, fallback
);
7862 /* Anything else with side-effects must be converted to
7863 a valid statement before we get here. */
7869 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p
))
7870 && TYPE_MODE (TREE_TYPE (*expr_p
)) != BLKmode
)
7872 /* Historically, the compiler has treated a bare reference
7873 to a non-BLKmode volatile lvalue as forcing a load. */
7874 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p
));
7876 /* Normally, we do not want to create a temporary for a
7877 TREE_ADDRESSABLE type because such a type should not be
7878 copied by bitwise-assignment. However, we make an
7879 exception here, as all we are doing here is ensuring that
7880 we read the bytes that make up the type. We use
7881 create_tmp_var_raw because create_tmp_var will abort when
7882 given a TREE_ADDRESSABLE type. */
7883 tree tmp
= create_tmp_var_raw (type
, "vol");
7884 gimple_add_tmp_var (tmp
);
7885 gimplify_assign (tmp
, *expr_p
, pre_p
);
7889 /* We can't do anything useful with a volatile reference to
7890 an incomplete type, so just throw it away. Likewise for
7891 a BLKmode type, since any implicit inner load should
7892 already have been turned into an explicit one by the
7893 gimplification process. */
7897 /* If we are gimplifying at the statement level, we're done. Tack
7898 everything together and return. */
7899 if (fallback
== fb_none
|| is_statement
)
7901 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
7902 it out for GC to reclaim it. */
7903 *expr_p
= NULL_TREE
;
7905 if (!gimple_seq_empty_p (internal_pre
)
7906 || !gimple_seq_empty_p (internal_post
))
7908 gimplify_seq_add_seq (&internal_pre
, internal_post
);
7909 gimplify_seq_add_seq (pre_p
, internal_pre
);
7912 /* The result of gimplifying *EXPR_P is going to be the last few
7913 statements in *PRE_P and *POST_P. Add location information
7914 to all the statements that were added by the gimplification
7916 if (!gimple_seq_empty_p (*pre_p
))
7917 annotate_all_with_location_after (*pre_p
, pre_last_gsi
, input_location
);
7919 if (!gimple_seq_empty_p (*post_p
))
7920 annotate_all_with_location_after (*post_p
, post_last_gsi
,
7926 #ifdef ENABLE_GIMPLE_CHECKING
7929 enum tree_code code
= TREE_CODE (*expr_p
);
7930 /* These expressions should already be in gimple IR form. */
7931 gcc_assert (code
!= MODIFY_EXPR
7933 && code
!= BIND_EXPR
7934 && code
!= CATCH_EXPR
7935 && (code
!= COND_EXPR
|| gimplify_ctxp
->allow_rhs_cond_expr
)
7936 && code
!= EH_FILTER_EXPR
7937 && code
!= GOTO_EXPR
7938 && code
!= LABEL_EXPR
7939 && code
!= LOOP_EXPR
7940 && code
!= SWITCH_EXPR
7941 && code
!= TRY_FINALLY_EXPR
7942 && code
!= OMP_CRITICAL
7944 && code
!= OMP_MASTER
7945 && code
!= OMP_ORDERED
7946 && code
!= OMP_PARALLEL
7947 && code
!= OMP_SECTIONS
7948 && code
!= OMP_SECTION
7949 && code
!= OMP_SINGLE
);
7953 /* Otherwise we're gimplifying a subexpression, so the resulting
7954 value is interesting. If it's a valid operand that matches
7955 GIMPLE_TEST_F, we're done. Unless we are handling some
7956 post-effects internally; if that's the case, we need to copy into
7957 a temporary before adding the post-effects to POST_P. */
7958 if (gimple_seq_empty_p (internal_post
) && (*gimple_test_f
) (*expr_p
))
7961 /* Otherwise, we need to create a new temporary for the gimplified
7964 /* We can't return an lvalue if we have an internal postqueue. The
7965 object the lvalue refers to would (probably) be modified by the
7966 postqueue; we need to copy the value out first, which means an
7968 if ((fallback
& fb_lvalue
)
7969 && gimple_seq_empty_p (internal_post
)
7970 && is_gimple_addressable (*expr_p
))
7972 /* An lvalue will do. Take the address of the expression, store it
7973 in a temporary, and replace the expression with an INDIRECT_REF of
7975 tmp
= build_fold_addr_expr_loc (input_location
, *expr_p
);
7976 gimplify_expr (&tmp
, pre_p
, post_p
, is_gimple_reg
, fb_rvalue
);
7977 *expr_p
= build_simple_mem_ref (tmp
);
7979 else if ((fallback
& fb_rvalue
) && is_gimple_reg_rhs_or_call (*expr_p
))
7981 /* An rvalue will do. Assign the gimplified expression into a
7982 new temporary TMP and replace the original expression with
7983 TMP. First, make sure that the expression has a type so that
7984 it can be assigned into a temporary. */
7985 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p
)));
7986 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
7990 #ifdef ENABLE_GIMPLE_CHECKING
7991 if (!(fallback
& fb_mayfail
))
7993 fprintf (stderr
, "gimplification failed:\n");
7994 print_generic_expr (stderr
, *expr_p
, 0);
7995 debug_tree (*expr_p
);
7996 internal_error ("gimplification failed");
7999 gcc_assert (fallback
& fb_mayfail
);
8001 /* If this is an asm statement, and the user asked for the
8002 impossible, don't die. Fail and let gimplify_asm_expr
8008 /* Make sure the temporary matches our predicate. */
8009 gcc_assert ((*gimple_test_f
) (*expr_p
));
8011 if (!gimple_seq_empty_p (internal_post
))
8013 annotate_all_with_location (internal_post
, input_location
);
8014 gimplify_seq_add_seq (pre_p
, internal_post
);
8018 input_location
= saved_location
;
8022 /* Look through TYPE for variable-sized objects and gimplify each such
8023 size that we find. Add to LIST_P any statements generated. */
8026 gimplify_type_sizes (tree type
, gimple_seq
*list_p
)
8030 if (type
== NULL
|| type
== error_mark_node
)
8033 /* We first do the main variant, then copy into any other variants. */
8034 type
= TYPE_MAIN_VARIANT (type
);
8036 /* Avoid infinite recursion. */
8037 if (TYPE_SIZES_GIMPLIFIED (type
))
8040 TYPE_SIZES_GIMPLIFIED (type
) = 1;
8042 switch (TREE_CODE (type
))
8048 case FIXED_POINT_TYPE
:
8049 gimplify_one_sizepos (&TYPE_MIN_VALUE (type
), list_p
);
8050 gimplify_one_sizepos (&TYPE_MAX_VALUE (type
), list_p
);
8052 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8054 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (type
);
8055 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (type
);
8060 /* These types may not have declarations, so handle them here. */
8061 gimplify_type_sizes (TREE_TYPE (type
), list_p
);
8062 gimplify_type_sizes (TYPE_DOMAIN (type
), list_p
);
8063 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
8064 with assigned stack slots, for -O1+ -g they should be tracked
8066 if (!(TYPE_NAME (type
)
8067 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
8068 && DECL_IGNORED_P (TYPE_NAME (type
)))
8069 && TYPE_DOMAIN (type
)
8070 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type
)))
8072 t
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
8073 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8074 DECL_IGNORED_P (t
) = 0;
8075 t
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
8076 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8077 DECL_IGNORED_P (t
) = 0;
8083 case QUAL_UNION_TYPE
:
8084 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
8085 if (TREE_CODE (field
) == FIELD_DECL
)
8087 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field
), list_p
);
8088 gimplify_one_sizepos (&DECL_SIZE (field
), list_p
);
8089 gimplify_one_sizepos (&DECL_SIZE_UNIT (field
), list_p
);
8090 gimplify_type_sizes (TREE_TYPE (field
), list_p
);
8095 case REFERENCE_TYPE
:
8096 /* We used to recurse on the pointed-to type here, which turned out to
8097 be incorrect because its definition might refer to variables not
8098 yet initialized at this point if a forward declaration is involved.
8100 It was actually useful for anonymous pointed-to types to ensure
8101 that the sizes evaluation dominates every possible later use of the
8102 values. Restricting to such types here would be safe since there
8103 is no possible forward declaration around, but would introduce an
8104 undesirable middle-end semantic to anonymity. We then defer to
8105 front-ends the responsibility of ensuring that the sizes are
8106 evaluated both early and late enough, e.g. by attaching artificial
8107 type declarations to the tree. */
8114 gimplify_one_sizepos (&TYPE_SIZE (type
), list_p
);
8115 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type
), list_p
);
8117 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8119 TYPE_SIZE (t
) = TYPE_SIZE (type
);
8120 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (type
);
8121 TYPE_SIZES_GIMPLIFIED (t
) = 1;
8125 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
8126 a size or position, has had all of its SAVE_EXPRs evaluated.
8127 We add any required statements to *STMT_P. */
8130 gimplify_one_sizepos (tree
*expr_p
, gimple_seq
*stmt_p
)
8132 tree expr
= *expr_p
;
8134 /* We don't do anything if the value isn't there, is constant, or contains
8135 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
8136 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
8137 will want to replace it with a new variable, but that will cause problems
8138 if this type is from outside the function. It's OK to have that here. */
8139 if (is_gimple_sizepos (expr
))
8142 *expr_p
= unshare_expr (expr
);
8144 gimplify_expr (expr_p
, stmt_p
, NULL
, is_gimple_val
, fb_rvalue
);
8147 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
8148 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
8149 is true, also gimplify the parameters. */
8152 gimplify_body (tree fndecl
, bool do_parms
)
8154 location_t saved_location
= input_location
;
8155 gimple_seq parm_stmts
, seq
;
8157 struct gimplify_ctx gctx
;
8158 struct cgraph_node
*cgn
;
8160 timevar_push (TV_TREE_GIMPLIFY
);
8162 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
8164 default_rtl_profile ();
8166 gcc_assert (gimplify_ctxp
== NULL
);
8167 push_gimplify_context (&gctx
);
8169 /* Unshare most shared trees in the body and in that of any nested functions.
8170 It would seem we don't have to do this for nested functions because
8171 they are supposed to be output and then the outer function gimplified
8172 first, but the g++ front end doesn't always do it that way. */
8173 unshare_body (fndecl
);
8174 unvisit_body (fndecl
);
8176 cgn
= cgraph_get_node (fndecl
);
8177 if (cgn
&& cgn
->origin
)
8178 nonlocal_vlas
= pointer_set_create ();
8180 /* Make sure input_location isn't set to something weird. */
8181 input_location
= DECL_SOURCE_LOCATION (fndecl
);
8183 /* Resolve callee-copies. This has to be done before processing
8184 the body so that DECL_VALUE_EXPR gets processed correctly. */
8185 parm_stmts
= do_parms
? gimplify_parameters () : NULL
;
8187 /* Gimplify the function's body. */
8189 gimplify_stmt (&DECL_SAVED_TREE (fndecl
), &seq
);
8190 outer_bind
= gimple_seq_first_stmt (seq
);
8193 outer_bind
= gimple_build_nop ();
8194 gimplify_seq_add_stmt (&seq
, outer_bind
);
8197 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
8198 not the case, wrap everything in a GIMPLE_BIND to make it so. */
8199 if (gimple_code (outer_bind
) == GIMPLE_BIND
8200 && gimple_seq_first (seq
) == gimple_seq_last (seq
))
8203 outer_bind
= gimple_build_bind (NULL_TREE
, seq
, NULL
);
8205 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
8207 /* If we had callee-copies statements, insert them at the beginning
8208 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
8209 if (!gimple_seq_empty_p (parm_stmts
))
8213 gimplify_seq_add_seq (&parm_stmts
, gimple_bind_body (outer_bind
));
8214 gimple_bind_set_body (outer_bind
, parm_stmts
);
8216 for (parm
= DECL_ARGUMENTS (current_function_decl
);
8217 parm
; parm
= DECL_CHAIN (parm
))
8218 if (DECL_HAS_VALUE_EXPR_P (parm
))
8220 DECL_HAS_VALUE_EXPR_P (parm
) = 0;
8221 DECL_IGNORED_P (parm
) = 0;
8227 pointer_set_destroy (nonlocal_vlas
);
8228 nonlocal_vlas
= NULL
;
8231 pop_gimplify_context (outer_bind
);
8232 gcc_assert (gimplify_ctxp
== NULL
);
8234 #ifdef ENABLE_CHECKING
8236 verify_gimple_in_seq (gimple_bind_body (outer_bind
));
8239 timevar_pop (TV_TREE_GIMPLIFY
);
8240 input_location
= saved_location
;
8245 typedef char *char_p
; /* For DEF_VEC_P. */
8247 /* Return whether we should exclude FNDECL from instrumentation. */
8250 flag_instrument_functions_exclude_p (tree fndecl
)
8254 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_functions
;
8255 if (v
&& v
->length () > 0)
8261 name
= lang_hooks
.decl_printable_name (fndecl
, 0);
8262 FOR_EACH_VEC_ELT (*v
, i
, s
)
8263 if (strstr (name
, s
) != NULL
)
8267 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_files
;
8268 if (v
&& v
->length () > 0)
8274 name
= DECL_SOURCE_FILE (fndecl
);
8275 FOR_EACH_VEC_ELT (*v
, i
, s
)
8276 if (strstr (name
, s
) != NULL
)
8283 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
8284 node for the function we want to gimplify.
8286 Return the sequence of GIMPLE statements corresponding to the body
8290 gimplify_function_tree (tree fndecl
)
8296 gcc_assert (!gimple_body (fndecl
));
8298 if (DECL_STRUCT_FUNCTION (fndecl
))
8299 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
8301 push_struct_function (fndecl
);
8303 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
8305 /* Preliminarily mark non-addressed complex variables as eligible
8306 for promotion to gimple registers. We'll transform their uses
8308 if ((TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
8309 || TREE_CODE (TREE_TYPE (parm
)) == VECTOR_TYPE
)
8310 && !TREE_THIS_VOLATILE (parm
)
8311 && !needs_to_live_in_memory (parm
))
8312 DECL_GIMPLE_REG_P (parm
) = 1;
8315 ret
= DECL_RESULT (fndecl
);
8316 if ((TREE_CODE (TREE_TYPE (ret
)) == COMPLEX_TYPE
8317 || TREE_CODE (TREE_TYPE (ret
)) == VECTOR_TYPE
)
8318 && !needs_to_live_in_memory (ret
))
8319 DECL_GIMPLE_REG_P (ret
) = 1;
8321 bind
= gimplify_body (fndecl
, true);
8323 /* The tree body of the function is no longer needed, replace it
8324 with the new GIMPLE body. */
8326 gimple_seq_add_stmt (&seq
, bind
);
8327 gimple_set_body (fndecl
, seq
);
8329 /* If we're instrumenting function entry/exit, then prepend the call to
8330 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
8331 catch the exit hook. */
8332 /* ??? Add some way to ignore exceptions for this TFE. */
8333 if (flag_instrument_function_entry_exit
8334 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
)
8335 && !flag_instrument_functions_exclude_p (fndecl
))
8340 gimple_seq cleanup
= NULL
, body
= NULL
;
8344 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
8345 call
= gimple_build_call (x
, 1, integer_zero_node
);
8346 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
8347 gimple_call_set_lhs (call
, tmp_var
);
8348 gimplify_seq_add_stmt (&cleanup
, call
);
8349 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT
);
8350 call
= gimple_build_call (x
, 2,
8351 build_fold_addr_expr (current_function_decl
),
8353 gimplify_seq_add_stmt (&cleanup
, call
);
8354 tf
= gimple_build_try (seq
, cleanup
, GIMPLE_TRY_FINALLY
);
8356 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
8357 call
= gimple_build_call (x
, 1, integer_zero_node
);
8358 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
8359 gimple_call_set_lhs (call
, tmp_var
);
8360 gimplify_seq_add_stmt (&body
, call
);
8361 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER
);
8362 call
= gimple_build_call (x
, 2,
8363 build_fold_addr_expr (current_function_decl
),
8365 gimplify_seq_add_stmt (&body
, call
);
8366 gimplify_seq_add_stmt (&body
, tf
);
8367 new_bind
= gimple_build_bind (NULL
, body
, gimple_bind_block (bind
));
8368 /* Clear the block for BIND, since it is no longer directly inside
8369 the function, but within a try block. */
8370 gimple_bind_set_block (bind
, NULL
);
8372 /* Replace the current function body with the body
8373 wrapped in the try/finally TF. */
8375 gimple_seq_add_stmt (&seq
, new_bind
);
8376 gimple_set_body (fndecl
, seq
);
8379 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
8380 cfun
->curr_properties
= PROP_gimple_any
;
8385 /* Some transformations like inlining may invalidate the GIMPLE form
8386 for operands. This function traverses all the operands in STMT and
8387 gimplifies anything that is not a valid gimple operand. Any new
8388 GIMPLE statements are inserted before *GSI_P. */
8391 gimple_regimplify_operands (gimple stmt
, gimple_stmt_iterator
*gsi_p
)
8395 gimple_seq pre
= NULL
;
8396 gimple post_stmt
= NULL
;
8397 struct gimplify_ctx gctx
;
8399 push_gimplify_context (&gctx
);
8400 gimplify_ctxp
->into_ssa
= gimple_in_ssa_p (cfun
);
8402 switch (gimple_code (stmt
))
8405 gimplify_expr (gimple_cond_lhs_ptr (stmt
), &pre
, NULL
,
8406 is_gimple_val
, fb_rvalue
);
8407 gimplify_expr (gimple_cond_rhs_ptr (stmt
), &pre
, NULL
,
8408 is_gimple_val
, fb_rvalue
);
8411 gimplify_expr (gimple_switch_index_ptr (stmt
), &pre
, NULL
,
8412 is_gimple_val
, fb_rvalue
);
8414 case GIMPLE_OMP_ATOMIC_LOAD
:
8415 gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt
), &pre
, NULL
,
8416 is_gimple_val
, fb_rvalue
);
8420 size_t i
, noutputs
= gimple_asm_noutputs (stmt
);
8421 const char *constraint
, **oconstraints
;
8422 bool allows_mem
, allows_reg
, is_inout
;
8425 = (const char **) alloca ((noutputs
) * sizeof (const char *));
8426 for (i
= 0; i
< noutputs
; i
++)
8428 tree op
= gimple_asm_output_op (stmt
, i
);
8429 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op
)));
8430 oconstraints
[i
] = constraint
;
8431 parse_output_constraint (&constraint
, i
, 0, 0, &allows_mem
,
8432 &allows_reg
, &is_inout
);
8433 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8434 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
8435 fb_lvalue
| fb_mayfail
);
8437 for (i
= 0; i
< gimple_asm_ninputs (stmt
); i
++)
8439 tree op
= gimple_asm_input_op (stmt
, i
);
8440 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op
)));
8441 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
8442 oconstraints
, &allows_mem
, &allows_reg
);
8443 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op
))) && allows_mem
)
8445 if (!allows_reg
&& allows_mem
)
8446 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8447 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
8449 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8450 is_gimple_asm_val
, fb_rvalue
);
8455 /* NOTE: We start gimplifying operands from last to first to
8456 make sure that side-effects on the RHS of calls, assignments
8457 and ASMs are executed before the LHS. The ordering is not
8458 important for other statements. */
8459 num_ops
= gimple_num_ops (stmt
);
8460 for (i
= num_ops
; i
> 0; i
--)
8462 tree op
= gimple_op (stmt
, i
- 1);
8463 if (op
== NULL_TREE
)
8465 if (i
== 1 && (is_gimple_call (stmt
) || is_gimple_assign (stmt
)))
8466 gimplify_expr (&op
, &pre
, NULL
, is_gimple_lvalue
, fb_lvalue
);
8468 && is_gimple_assign (stmt
)
8470 && get_gimple_rhs_class (gimple_expr_code (stmt
))
8471 == GIMPLE_SINGLE_RHS
)
8472 gimplify_expr (&op
, &pre
, NULL
,
8473 rhs_predicate_for (gimple_assign_lhs (stmt
)),
8475 else if (i
== 2 && is_gimple_call (stmt
))
8477 if (TREE_CODE (op
) == FUNCTION_DECL
)
8479 gimplify_expr (&op
, &pre
, NULL
, is_gimple_call_addr
, fb_rvalue
);
8482 gimplify_expr (&op
, &pre
, NULL
, is_gimple_val
, fb_rvalue
);
8483 gimple_set_op (stmt
, i
- 1, op
);
8486 lhs
= gimple_get_lhs (stmt
);
8487 /* If the LHS changed it in a way that requires a simple RHS,
8488 create temporary. */
8489 if (lhs
&& !is_gimple_reg (lhs
))
8491 bool need_temp
= false;
8493 if (is_gimple_assign (stmt
)
8495 && get_gimple_rhs_class (gimple_expr_code (stmt
))
8496 == GIMPLE_SINGLE_RHS
)
8497 gimplify_expr (gimple_assign_rhs1_ptr (stmt
), &pre
, NULL
,
8498 rhs_predicate_for (gimple_assign_lhs (stmt
)),
8500 else if (is_gimple_reg (lhs
))
8502 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
8504 if (is_gimple_call (stmt
))
8506 i
= gimple_call_flags (stmt
);
8507 if ((i
& ECF_LOOPING_CONST_OR_PURE
)
8508 || !(i
& (ECF_CONST
| ECF_PURE
)))
8511 if (stmt_can_throw_internal (stmt
))
8517 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
8519 else if (TYPE_MODE (TREE_TYPE (lhs
)) != BLKmode
)
8521 if (is_gimple_call (stmt
))
8523 tree fndecl
= gimple_call_fndecl (stmt
);
8525 if (!aggregate_value_p (TREE_TYPE (lhs
), fndecl
)
8526 && !(fndecl
&& DECL_RESULT (fndecl
)
8527 && DECL_BY_REFERENCE (DECL_RESULT (fndecl
))))
8536 tree temp
= create_tmp_reg (TREE_TYPE (lhs
), NULL
);
8537 if (gimple_in_ssa_p (cfun
))
8538 temp
= make_ssa_name (temp
, NULL
);
8539 gimple_set_lhs (stmt
, temp
);
8540 post_stmt
= gimple_build_assign (lhs
, temp
);
8541 if (TREE_CODE (lhs
) == SSA_NAME
)
8542 SSA_NAME_DEF_STMT (lhs
) = post_stmt
;
8548 if (!gimple_seq_empty_p (pre
))
8549 gsi_insert_seq_before (gsi_p
, pre
, GSI_SAME_STMT
);
8551 gsi_insert_after (gsi_p
, post_stmt
, GSI_NEW_STMT
);
8553 pop_gimplify_context (NULL
);
8556 /* Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
8557 the predicate that will hold for the result. If VAR is not NULL, make the
8558 base variable of the final destination be VAR if suitable. */
8561 force_gimple_operand_1 (tree expr
, gimple_seq
*stmts
,
8562 gimple_predicate gimple_test_f
, tree var
)
8564 enum gimplify_status ret
;
8565 struct gimplify_ctx gctx
;
8566 location_t saved_location
;
8570 /* gimple_test_f might be more strict than is_gimple_val, make
8571 sure we pass both. Just checking gimple_test_f doesn't work
8572 because most gimple predicates do not work recursively. */
8573 if (is_gimple_val (expr
)
8574 && (*gimple_test_f
) (expr
))
8577 push_gimplify_context (&gctx
);
8578 gimplify_ctxp
->into_ssa
= gimple_in_ssa_p (cfun
);
8579 gimplify_ctxp
->allow_rhs_cond_expr
= true;
8580 saved_location
= input_location
;
8581 input_location
= UNKNOWN_LOCATION
;
8585 if (gimplify_ctxp
->into_ssa
8586 && is_gimple_reg (var
))
8587 var
= make_ssa_name (var
, NULL
);
8588 expr
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, expr
);
8591 if (TREE_CODE (expr
) != MODIFY_EXPR
8592 && TREE_TYPE (expr
) == void_type_node
)
8594 gimplify_and_add (expr
, stmts
);
8599 ret
= gimplify_expr (&expr
, stmts
, NULL
, gimple_test_f
, fb_rvalue
);
8600 gcc_assert (ret
!= GS_ERROR
);
8603 input_location
= saved_location
;
8604 pop_gimplify_context (NULL
);
8609 /* Expand EXPR to list of gimple statements STMTS. If SIMPLE is true,
8610 force the result to be either ssa_name or an invariant, otherwise
8611 just force it to be a rhs expression. If VAR is not NULL, make the
8612 base variable of the final destination be VAR if suitable. */
8615 force_gimple_operand (tree expr
, gimple_seq
*stmts
, bool simple
, tree var
)
8617 return force_gimple_operand_1 (expr
, stmts
,
8618 simple
? is_gimple_val
: is_gimple_reg_rhs
,
8622 /* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
8623 and VAR. If some statements are produced, emits them at GSI.
8624 If BEFORE is true. the statements are appended before GSI, otherwise
8625 they are appended after it. M specifies the way GSI moves after
8626 insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values). */
8629 force_gimple_operand_gsi_1 (gimple_stmt_iterator
*gsi
, tree expr
,
8630 gimple_predicate gimple_test_f
,
8631 tree var
, bool before
,
8632 enum gsi_iterator_update m
)
8636 expr
= force_gimple_operand_1 (expr
, &stmts
, gimple_test_f
, var
);
8638 if (!gimple_seq_empty_p (stmts
))
8641 gsi_insert_seq_before (gsi
, stmts
, m
);
8643 gsi_insert_seq_after (gsi
, stmts
, m
);
8649 /* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
8650 If SIMPLE is true, force the result to be either ssa_name or an invariant,
8651 otherwise just force it to be a rhs expression. If some statements are
8652 produced, emits them at GSI. If BEFORE is true, the statements are
8653 appended before GSI, otherwise they are appended after it. M specifies
8654 the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
8655 are the usual values). */
8658 force_gimple_operand_gsi (gimple_stmt_iterator
*gsi
, tree expr
,
8659 bool simple_p
, tree var
, bool before
,
8660 enum gsi_iterator_update m
)
8662 return force_gimple_operand_gsi_1 (gsi
, expr
,
8664 ? is_gimple_val
: is_gimple_reg_rhs
,
8669 #include "gt-gimplify.h"