1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
4 2012 Free Software Foundation, Inc.
5 Major work done by Sebastian Pop <s.pop@laposte.net>,
6 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
26 #include "coretypes.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
32 #include "tree-pretty-print.h"
33 #include "langhooks.h"
34 #include "tree-flow.h"
41 #include "diagnostic-core.h"
43 #include "pointer-set.h"
44 #include "splay-tree.h"
48 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
49 #include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
51 enum gimplify_omp_var_data
57 GOVD_FIRSTPRIVATE
= 16,
58 GOVD_LASTPRIVATE
= 32,
61 GOVD_DEBUG_PRIVATE
= 256,
62 GOVD_PRIVATE_OUTER_REF
= 512,
63 GOVD_DATA_SHARE_CLASS
= (GOVD_SHARED
| GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
64 | GOVD_LASTPRIVATE
| GOVD_REDUCTION
| GOVD_LOCAL
)
72 ORT_COMBINED_PARALLEL
= 3,
77 struct gimplify_omp_ctx
79 struct gimplify_omp_ctx
*outer_context
;
81 struct pointer_set_t
*privatized_types
;
83 enum omp_clause_default_kind default_kind
;
84 enum omp_region_type region_type
;
87 static struct gimplify_ctx
*gimplify_ctxp
;
88 static struct gimplify_omp_ctx
*gimplify_omp_ctxp
;
91 /* Formal (expression) temporary table handling: multiple occurrences of
92 the same scalar expression are evaluated into the same temporary. */
94 typedef struct gimple_temp_hash_elt
97 tree temp
; /* Value */
100 /* Forward declaration. */
101 static enum gimplify_status
gimplify_compound_expr (tree
*, gimple_seq
*, bool);
103 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
104 form and we don't do any syntax checking. */
107 mark_addressable (tree x
)
109 while (handled_component_p (x
))
110 x
= TREE_OPERAND (x
, 0);
111 if (TREE_CODE (x
) == MEM_REF
112 && TREE_CODE (TREE_OPERAND (x
, 0)) == ADDR_EXPR
)
113 x
= TREE_OPERAND (TREE_OPERAND (x
, 0), 0);
114 if (TREE_CODE (x
) != VAR_DECL
115 && TREE_CODE (x
) != PARM_DECL
116 && TREE_CODE (x
) != RESULT_DECL
)
118 TREE_ADDRESSABLE (x
) = 1;
120 /* Also mark the artificial SSA_NAME that points to the partition of X. */
121 if (TREE_CODE (x
) == VAR_DECL
122 && !DECL_EXTERNAL (x
)
124 && cfun
->gimple_df
!= NULL
125 && cfun
->gimple_df
->decls_to_pointers
!= NULL
)
128 = pointer_map_contains (cfun
->gimple_df
->decls_to_pointers
, x
);
130 TREE_ADDRESSABLE (*(tree
*)namep
) = 1;
134 /* Return a hash value for a formal temporary table entry. */
137 gimple_tree_hash (const void *p
)
139 tree t
= ((const elt_t
*) p
)->val
;
140 return iterative_hash_expr (t
, 0);
143 /* Compare two formal temporary table entries. */
146 gimple_tree_eq (const void *p1
, const void *p2
)
148 tree t1
= ((const elt_t
*) p1
)->val
;
149 tree t2
= ((const elt_t
*) p2
)->val
;
150 enum tree_code code
= TREE_CODE (t1
);
152 if (TREE_CODE (t2
) != code
153 || TREE_TYPE (t1
) != TREE_TYPE (t2
))
156 if (!operand_equal_p (t1
, t2
, 0))
159 #ifdef ENABLE_CHECKING
160 /* Only allow them to compare equal if they also hash equal; otherwise
161 results are nondeterminate, and we fail bootstrap comparison. */
162 gcc_assert (gimple_tree_hash (p1
) == gimple_tree_hash (p2
));
168 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
169 *SEQ_P is NULL, a new sequence is allocated. This function is
170 similar to gimple_seq_add_stmt, but does not scan the operands.
171 During gimplification, we need to manipulate statement sequences
172 before the def/use vectors have been constructed. */
175 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
177 gimple_stmt_iterator si
;
182 si
= gsi_last (*seq_p
);
183 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
186 /* Shorter alias name for the above function for use in gimplify.c
190 gimplify_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
192 gimple_seq_add_stmt_without_update (seq_p
, gs
);
195 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
196 NULL, a new sequence is allocated. This function is
197 similar to gimple_seq_add_seq, but does not scan the operands.
198 During gimplification, we need to manipulate statement sequences
199 before the def/use vectors have been constructed. */
202 gimplify_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
204 gimple_stmt_iterator si
;
209 si
= gsi_last (*dst_p
);
210 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
213 /* Set up a context for the gimplifier. */
216 push_gimplify_context (struct gimplify_ctx
*c
)
218 memset (c
, '\0', sizeof (*c
));
219 c
->prev_context
= gimplify_ctxp
;
223 /* Tear down a context for the gimplifier. If BODY is non-null, then
224 put the temporaries into the outer BIND_EXPR. Otherwise, put them
227 BODY is not a sequence, but the first tuple in a sequence. */
230 pop_gimplify_context (gimple body
)
232 struct gimplify_ctx
*c
= gimplify_ctxp
;
235 && (!c
->bind_expr_stack
.exists ()
236 || c
->bind_expr_stack
.is_empty ()));
237 c
->bind_expr_stack
.release ();
238 gimplify_ctxp
= c
->prev_context
;
241 declare_vars (c
->temps
, body
, false);
243 record_vars (c
->temps
);
246 htab_delete (c
->temp_htab
);
249 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
252 gimple_push_bind_expr (gimple gimple_bind
)
254 gimplify_ctxp
->bind_expr_stack
.reserve (8);
255 gimplify_ctxp
->bind_expr_stack
.safe_push (gimple_bind
);
258 /* Pop the first element off the stack of bindings. */
261 gimple_pop_bind_expr (void)
263 gimplify_ctxp
->bind_expr_stack
.pop ();
266 /* Return the first element of the stack of bindings. */
269 gimple_current_bind_expr (void)
271 return gimplify_ctxp
->bind_expr_stack
.last ();
274 /* Return the stack of bindings created during gimplification. */
277 gimple_bind_expr_stack (void)
279 return gimplify_ctxp
->bind_expr_stack
;
282 /* Return true iff there is a COND_EXPR between us and the innermost
283 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
286 gimple_conditional_context (void)
288 return gimplify_ctxp
->conditions
> 0;
291 /* Note that we've entered a COND_EXPR. */
294 gimple_push_condition (void)
296 #ifdef ENABLE_GIMPLE_CHECKING
297 if (gimplify_ctxp
->conditions
== 0)
298 gcc_assert (gimple_seq_empty_p (gimplify_ctxp
->conditional_cleanups
));
300 ++(gimplify_ctxp
->conditions
);
303 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
304 now, add any conditional cleanups we've seen to the prequeue. */
307 gimple_pop_condition (gimple_seq
*pre_p
)
309 int conds
= --(gimplify_ctxp
->conditions
);
311 gcc_assert (conds
>= 0);
314 gimplify_seq_add_seq (pre_p
, gimplify_ctxp
->conditional_cleanups
);
315 gimplify_ctxp
->conditional_cleanups
= NULL
;
319 /* A stable comparison routine for use with splay trees and DECLs. */
322 splay_tree_compare_decl_uid (splay_tree_key xa
, splay_tree_key xb
)
327 return DECL_UID (a
) - DECL_UID (b
);
330 /* Create a new omp construct that deals with variable remapping. */
332 static struct gimplify_omp_ctx
*
333 new_omp_context (enum omp_region_type region_type
)
335 struct gimplify_omp_ctx
*c
;
337 c
= XCNEW (struct gimplify_omp_ctx
);
338 c
->outer_context
= gimplify_omp_ctxp
;
339 c
->variables
= splay_tree_new (splay_tree_compare_decl_uid
, 0, 0);
340 c
->privatized_types
= pointer_set_create ();
341 c
->location
= input_location
;
342 c
->region_type
= region_type
;
343 if ((region_type
& ORT_TASK
) == 0)
344 c
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
346 c
->default_kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
351 /* Destroy an omp construct that deals with variable remapping. */
354 delete_omp_context (struct gimplify_omp_ctx
*c
)
356 splay_tree_delete (c
->variables
);
357 pointer_set_destroy (c
->privatized_types
);
361 static void omp_add_variable (struct gimplify_omp_ctx
*, tree
, unsigned int);
362 static bool omp_notice_variable (struct gimplify_omp_ctx
*, tree
, bool);
364 /* Both gimplify the statement T and append it to *SEQ_P. This function
365 behaves exactly as gimplify_stmt, but you don't have to pass T as a
369 gimplify_and_add (tree t
, gimple_seq
*seq_p
)
371 gimplify_stmt (&t
, seq_p
);
374 /* Gimplify statement T into sequence *SEQ_P, and return the first
375 tuple in the sequence of generated tuples for this statement.
376 Return NULL if gimplifying T produced no tuples. */
379 gimplify_and_return_first (tree t
, gimple_seq
*seq_p
)
381 gimple_stmt_iterator last
= gsi_last (*seq_p
);
383 gimplify_and_add (t
, seq_p
);
385 if (!gsi_end_p (last
))
388 return gsi_stmt (last
);
391 return gimple_seq_first_stmt (*seq_p
);
394 /* Strip off a legitimate source ending from the input string NAME of
395 length LEN. Rather than having to know the names used by all of
396 our front ends, we strip off an ending of a period followed by
397 up to five characters. (Java uses ".class".) */
400 remove_suffix (char *name
, int len
)
404 for (i
= 2; i
< 8 && len
> i
; i
++)
406 if (name
[len
- i
] == '.')
408 name
[len
- i
] = '\0';
414 /* Create a new temporary name with PREFIX. Return an identifier. */
416 static GTY(()) unsigned int tmp_var_id_num
;
419 create_tmp_var_name (const char *prefix
)
425 char *preftmp
= ASTRDUP (prefix
);
427 remove_suffix (preftmp
, strlen (preftmp
));
428 clean_symbol_name (preftmp
);
433 ASM_FORMAT_PRIVATE_NAME (tmp_name
, prefix
? prefix
: "T", tmp_var_id_num
++);
434 return get_identifier (tmp_name
);
437 /* Create a new temporary variable declaration of type TYPE.
438 Do NOT push it into the current binding. */
441 create_tmp_var_raw (tree type
, const char *prefix
)
445 /* Temps. cannot be UPC shared qualified. */
446 gcc_assert (!upc_shared_type_p (type
));
448 tmp_var
= build_decl (input_location
,
449 VAR_DECL
, prefix
? create_tmp_var_name (prefix
) : NULL
,
452 /* The variable was declared by the compiler. */
453 DECL_ARTIFICIAL (tmp_var
) = 1;
454 /* And we don't want debug info for it. */
455 DECL_IGNORED_P (tmp_var
) = 1;
457 /* Make the variable writable. */
458 TREE_READONLY (tmp_var
) = 0;
460 DECL_EXTERNAL (tmp_var
) = 0;
461 TREE_STATIC (tmp_var
) = 0;
462 TREE_USED (tmp_var
) = 1;
467 /* Create a new temporary variable declaration of type TYPE. DO push the
468 variable into the current binding. Further, assume that this is called
469 only from gimplification or optimization, at which point the creation of
470 certain types are bugs. */
473 create_tmp_var (tree type
, const char *prefix
)
477 /* We don't allow types that are addressable (meaning we can't make copies),
478 or incomplete. We also used to reject every variable size objects here,
479 but now support those for which a constant upper bound can be obtained.
480 The processing for variable sizes is performed in gimple_add_tmp_var,
481 point at which it really matters and possibly reached via paths not going
482 through this function, e.g. after direct calls to create_tmp_var_raw. */
483 gcc_assert (!TREE_ADDRESSABLE (type
) && COMPLETE_TYPE_P (type
));
485 tmp_var
= create_tmp_var_raw (type
, prefix
);
486 gimple_add_tmp_var (tmp_var
);
490 /* Create a new temporary variable declaration of type TYPE by calling
491 create_tmp_var and if TYPE is a vector or a complex number, mark the new
492 temporary as gimple register. */
495 create_tmp_reg (tree type
, const char *prefix
)
499 tmp
= create_tmp_var (type
, prefix
);
500 if (TREE_CODE (type
) == COMPLEX_TYPE
501 || TREE_CODE (type
) == VECTOR_TYPE
)
502 DECL_GIMPLE_REG_P (tmp
) = 1;
507 /* Returns true iff T is a valid RHS for an assignment to a renamed
508 user -- or front-end generated artificial -- variable. */
511 is_gimple_reg_rhs (tree t
)
513 return get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
;
516 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
517 LHS, or for a call argument. */
520 is_gimple_mem_rhs (tree t
)
522 /* If we're dealing with a renamable type, either source or dest must be
523 a renamed variable. */
524 if (is_gimple_reg_type (TREE_TYPE (t
)))
525 return is_gimple_val (t
);
527 return is_gimple_val (t
) || is_gimple_lvalue (t
);
530 /* Return true if T is a CALL_EXPR or an expression that can be
531 assigned to a temporary. Note that this predicate should only be
532 used during gimplification. See the rationale for this in
533 gimplify_modify_expr. */
536 is_gimple_reg_rhs_or_call (tree t
)
538 return (get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
539 || TREE_CODE (t
) == CALL_EXPR
);
542 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
543 this predicate should only be used during gimplification. See the
544 rationale for this in gimplify_modify_expr. */
547 is_gimple_mem_rhs_or_call (tree t
)
549 /* If we're dealing with a renamable type, either source or dest must be
550 a renamed variable. */
551 if (is_gimple_reg_type (TREE_TYPE (t
)))
552 return is_gimple_val (t
);
554 return (is_gimple_val (t
) || is_gimple_lvalue (t
)
555 || TREE_CODE (t
) == CALL_EXPR
);
558 /* Create a temporary with a name derived from VAL. Subroutine of
559 lookup_tmp_var; nobody else should call this function. */
562 create_tmp_from_val (tree val
, bool is_formal
)
564 /* Drop all qualifiers and address-space information from the value type. */
565 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (val
));
566 tree var
= create_tmp_var (type
, get_name (val
));
568 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
569 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
))
570 DECL_GIMPLE_REG_P (var
) = 1;
574 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
575 an existing expression temporary. */
578 lookup_tmp_var (tree val
, bool is_formal
)
582 /* If not optimizing, never really reuse a temporary. local-alloc
583 won't allocate any variable that is used in more than one basic
584 block, which means it will go into memory, causing much extra
585 work in reload and final and poorer code generation, outweighing
586 the extra memory allocation here. */
587 if (!optimize
|| !is_formal
|| TREE_SIDE_EFFECTS (val
))
588 ret
= create_tmp_from_val (val
, is_formal
);
595 if (gimplify_ctxp
->temp_htab
== NULL
)
596 gimplify_ctxp
->temp_htab
597 = htab_create (1000, gimple_tree_hash
, gimple_tree_eq
, free
);
598 slot
= htab_find_slot (gimplify_ctxp
->temp_htab
, (void *)&elt
, INSERT
);
601 elt_p
= XNEW (elt_t
);
603 elt_p
->temp
= ret
= create_tmp_from_val (val
, is_formal
);
604 *slot
= (void *) elt_p
;
608 elt_p
= (elt_t
*) *slot
;
616 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
619 internal_get_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
624 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
625 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
626 gimplify_expr (&val
, pre_p
, post_p
, is_gimple_reg_rhs_or_call
,
629 if (gimplify_ctxp
->into_ssa
630 && is_gimple_reg_type (TREE_TYPE (val
)))
631 t
= make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val
)), NULL
);
633 t
= lookup_tmp_var (val
, is_formal
);
635 mod
= build2 (INIT_EXPR
, TREE_TYPE (t
), t
, unshare_expr (val
));
637 SET_EXPR_LOCATION (mod
, EXPR_LOC_OR_HERE (val
));
639 /* gimplify_modify_expr might want to reduce this further. */
640 gimplify_and_add (mod
, pre_p
);
646 /* Return a formal temporary variable initialized with VAL. PRE_P is as
647 in gimplify_expr. Only use this function if:
649 1) The value of the unfactored expression represented by VAL will not
650 change between the initialization and use of the temporary, and
651 2) The temporary will not be otherwise modified.
653 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
654 and #2 means it is inappropriate for && temps.
656 For other cases, use get_initialized_tmp_var instead. */
659 get_formal_tmp_var (tree val
, gimple_seq
*pre_p
)
661 return internal_get_tmp_var (val
, pre_p
, NULL
, true);
664 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
665 are as in gimplify_expr. */
668 get_initialized_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
670 return internal_get_tmp_var (val
, pre_p
, post_p
, false);
673 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
674 generate debug info for them; otherwise don't. */
677 declare_vars (tree vars
, gimple scope
, bool debug_info
)
684 gcc_assert (gimple_code (scope
) == GIMPLE_BIND
);
686 temps
= nreverse (last
);
688 block
= gimple_bind_block (scope
);
689 gcc_assert (!block
|| TREE_CODE (block
) == BLOCK
);
690 if (!block
|| !debug_info
)
692 DECL_CHAIN (last
) = gimple_bind_vars (scope
);
693 gimple_bind_set_vars (scope
, temps
);
697 /* We need to attach the nodes both to the BIND_EXPR and to its
698 associated BLOCK for debugging purposes. The key point here
699 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
700 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
701 if (BLOCK_VARS (block
))
702 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), temps
);
705 gimple_bind_set_vars (scope
,
706 chainon (gimple_bind_vars (scope
), temps
));
707 BLOCK_VARS (block
) = temps
;
713 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
714 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
715 no such upper bound can be obtained. */
718 force_constant_size (tree var
)
720 /* The only attempt we make is by querying the maximum size of objects
721 of the variable's type. */
723 HOST_WIDE_INT max_size
;
725 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
727 max_size
= max_int_size_in_bytes (TREE_TYPE (var
));
729 gcc_assert (max_size
>= 0);
732 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var
)), max_size
);
734 = build_int_cst (TREE_TYPE (DECL_SIZE (var
)), max_size
* BITS_PER_UNIT
);
737 /* Push the temporary variable TMP into the current binding. */
740 gimple_add_tmp_var (tree tmp
)
742 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
744 /* Later processing assumes that the object size is constant, which might
745 not be true at this point. Force the use of a constant upper bound in
747 if (!host_integerp (DECL_SIZE_UNIT (tmp
), 1))
748 force_constant_size (tmp
);
750 DECL_CONTEXT (tmp
) = current_function_decl
;
751 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
755 DECL_CHAIN (tmp
) = gimplify_ctxp
->temps
;
756 gimplify_ctxp
->temps
= tmp
;
758 /* Mark temporaries local within the nearest enclosing parallel. */
759 if (gimplify_omp_ctxp
)
761 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
762 while (ctx
&& ctx
->region_type
== ORT_WORKSHARE
)
763 ctx
= ctx
->outer_context
;
765 omp_add_variable (ctx
, tmp
, GOVD_LOCAL
| GOVD_SEEN
);
774 /* This case is for nested functions. We need to expose the locals
776 body_seq
= gimple_body (current_function_decl
);
777 declare_vars (tmp
, gimple_seq_first_stmt (body_seq
), false);
781 /* Determine whether to assign a location to the statement GS. */
784 should_carry_location_p (gimple gs
)
786 /* Don't emit a line note for a label. We particularly don't want to
787 emit one for the break label, since it doesn't actually correspond
788 to the beginning of the loop/switch. */
789 if (gimple_code (gs
) == GIMPLE_LABEL
)
795 /* Return true if a location should not be emitted for this statement
796 by annotate_one_with_location. */
799 gimple_do_not_emit_location_p (gimple g
)
801 return gimple_plf (g
, GF_PLF_1
);
804 /* Mark statement G so a location will not be emitted by
805 annotate_one_with_location. */
808 gimple_set_do_not_emit_location (gimple g
)
810 /* The PLF flags are initialized to 0 when a new tuple is created,
811 so no need to initialize it anywhere. */
812 gimple_set_plf (g
, GF_PLF_1
, true);
815 /* Set the location for gimple statement GS to LOCATION. */
818 annotate_one_with_location (gimple gs
, location_t location
)
820 if (!gimple_has_location (gs
)
821 && !gimple_do_not_emit_location_p (gs
)
822 && should_carry_location_p (gs
))
823 gimple_set_location (gs
, location
);
826 /* Set LOCATION for all the statements after iterator GSI in sequence
827 SEQ. If GSI is pointing to the end of the sequence, start with the
828 first statement in SEQ. */
831 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
835 gsi
= gsi_start (seq
);
839 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
840 annotate_one_with_location (gsi_stmt (gsi
), location
);
843 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
846 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
848 gimple_stmt_iterator i
;
850 if (gimple_seq_empty_p (stmt_p
))
853 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
855 gimple gs
= gsi_stmt (i
);
856 annotate_one_with_location (gs
, location
);
860 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
861 nodes that are referenced more than once in GENERIC functions. This is
862 necessary because gimplification (translation into GIMPLE) is performed
863 by modifying tree nodes in-place, so gimplication of a shared node in a
864 first context could generate an invalid GIMPLE form in a second context.
866 This is achieved with a simple mark/copy/unmark algorithm that walks the
867 GENERIC representation top-down, marks nodes with TREE_VISITED the first
868 time it encounters them, duplicates them if they already have TREE_VISITED
869 set, and finally removes the TREE_VISITED marks it has set.
871 The algorithm works only at the function level, i.e. it generates a GENERIC
872 representation of a function with no nodes shared within the function when
873 passed a GENERIC function (except for nodes that are allowed to be shared).
875 At the global level, it is also necessary to unshare tree nodes that are
876 referenced in more than one function, for the same aforementioned reason.
877 This requires some cooperation from the front-end. There are 2 strategies:
879 1. Manual unsharing. The front-end needs to call unshare_expr on every
880 expression that might end up being shared across functions.
882 2. Deep unsharing. This is an extension of regular unsharing. Instead
883 of calling unshare_expr on expressions that might be shared across
884 functions, the front-end pre-marks them with TREE_VISITED. This will
885 ensure that they are unshared on the first reference within functions
886 when the regular unsharing algorithm runs. The counterpart is that
887 this algorithm must look deeper than for manual unsharing, which is
888 specified by LANG_HOOKS_DEEP_UNSHARING.
890 If there are only few specific cases of node sharing across functions, it is
891 probably easier for a front-end to unshare the expressions manually. On the
892 contrary, if the expressions generated at the global level are as widespread
893 as expressions generated within functions, deep unsharing is very likely the
896 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
897 These nodes model computations that must be done once. If we were to
898 unshare something like SAVE_EXPR(i++), the gimplification process would
899 create wrong code. However, if DATA is non-null, it must hold a pointer
900 set that is used to unshare the subtrees of these nodes. */
903 mostly_copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
906 enum tree_code code
= TREE_CODE (t
);
908 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
909 copy their subtrees if we can make sure to do it only once. */
910 if (code
== SAVE_EXPR
|| code
== TARGET_EXPR
|| code
== BIND_EXPR
)
912 if (data
&& !pointer_set_insert ((struct pointer_set_t
*)data
, t
))
918 /* Stop at types, decls, constants like copy_tree_r. */
919 else if (TREE_CODE_CLASS (code
) == tcc_type
920 || TREE_CODE_CLASS (code
) == tcc_declaration
921 || TREE_CODE_CLASS (code
) == tcc_constant
922 /* We can't do anything sensible with a BLOCK used as an
923 expression, but we also can't just die when we see it
924 because of non-expression uses. So we avert our eyes
925 and cross our fingers. Silly Java. */
929 /* Cope with the statement expression extension. */
930 else if (code
== STATEMENT_LIST
)
933 /* Leave the bulk of the work to copy_tree_r itself. */
935 copy_tree_r (tp
, walk_subtrees
, NULL
);
940 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
941 If *TP has been visited already, then *TP is deeply copied by calling
942 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
945 copy_if_shared_r (tree
*tp
, int *walk_subtrees
, void *data
)
948 enum tree_code code
= TREE_CODE (t
);
950 /* Skip types, decls, and constants. But we do want to look at their
951 types and the bounds of types. Mark them as visited so we properly
952 unmark their subtrees on the unmark pass. If we've already seen them,
953 don't look down further. */
954 if (TREE_CODE_CLASS (code
) == tcc_type
955 || TREE_CODE_CLASS (code
) == tcc_declaration
956 || TREE_CODE_CLASS (code
) == tcc_constant
)
958 if (TREE_VISITED (t
))
961 TREE_VISITED (t
) = 1;
964 /* If this node has been visited already, unshare it and don't look
966 else if (TREE_VISITED (t
))
968 walk_tree (tp
, mostly_copy_tree_r
, data
, NULL
);
972 /* Otherwise, mark the node as visited and keep looking. */
974 TREE_VISITED (t
) = 1;
979 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
980 copy_if_shared_r callback unmodified. */
983 copy_if_shared (tree
*tp
, void *data
)
985 walk_tree (tp
, copy_if_shared_r
, data
, NULL
);
988 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
989 any nested functions. */
992 unshare_body (tree fndecl
)
994 struct cgraph_node
*cgn
= cgraph_get_node (fndecl
);
995 /* If the language requires deep unsharing, we need a pointer set to make
996 sure we don't repeatedly unshare subtrees of unshareable nodes. */
997 struct pointer_set_t
*visited
998 = lang_hooks
.deep_unsharing
? pointer_set_create () : NULL
;
1000 copy_if_shared (&DECL_SAVED_TREE (fndecl
), visited
);
1001 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl
)), visited
);
1002 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)), visited
);
1005 pointer_set_destroy (visited
);
1008 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
1009 unshare_body (cgn
->symbol
.decl
);
1012 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
1013 Subtrees are walked until the first unvisited node is encountered. */
1016 unmark_visited_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1020 /* If this node has been visited, unmark it and keep looking. */
1021 if (TREE_VISITED (t
))
1022 TREE_VISITED (t
) = 0;
1024 /* Otherwise, don't look any deeper. */
1031 /* Unmark the visited trees rooted at *TP. */
1034 unmark_visited (tree
*tp
)
1036 walk_tree (tp
, unmark_visited_r
, NULL
, NULL
);
1039 /* Likewise, but mark all trees as not visited. */
1042 unvisit_body (tree fndecl
)
1044 struct cgraph_node
*cgn
= cgraph_get_node (fndecl
);
1046 unmark_visited (&DECL_SAVED_TREE (fndecl
));
1047 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl
)));
1048 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)));
1051 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
1052 unvisit_body (cgn
->symbol
.decl
);
1055 /* Unconditionally make an unshared copy of EXPR. This is used when using
1056 stored expressions which span multiple functions, such as BINFO_VTABLE,
1057 as the normal unsharing process can't tell that they're shared. */
1060 unshare_expr (tree expr
)
1062 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
1066 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1067 contain statements and have a value. Assign its value to a temporary
1068 and give it void_type_node. Return the temporary, or NULL_TREE if
1069 WRAPPER was already void. */
1072 voidify_wrapper_expr (tree wrapper
, tree temp
)
1074 tree type
= TREE_TYPE (wrapper
);
1075 if (type
&& !VOID_TYPE_P (type
))
1079 /* Set p to point to the body of the wrapper. Loop until we find
1080 something that isn't a wrapper. */
1081 for (p
= &wrapper
; p
&& *p
; )
1083 switch (TREE_CODE (*p
))
1086 TREE_SIDE_EFFECTS (*p
) = 1;
1087 TREE_TYPE (*p
) = void_type_node
;
1088 /* For a BIND_EXPR, the body is operand 1. */
1089 p
= &BIND_EXPR_BODY (*p
);
1092 case CLEANUP_POINT_EXPR
:
1093 case TRY_FINALLY_EXPR
:
1094 case TRY_CATCH_EXPR
:
1095 TREE_SIDE_EFFECTS (*p
) = 1;
1096 TREE_TYPE (*p
) = void_type_node
;
1097 p
= &TREE_OPERAND (*p
, 0);
1100 case STATEMENT_LIST
:
1102 tree_stmt_iterator i
= tsi_last (*p
);
1103 TREE_SIDE_EFFECTS (*p
) = 1;
1104 TREE_TYPE (*p
) = void_type_node
;
1105 p
= tsi_end_p (i
) ? NULL
: tsi_stmt_ptr (i
);
1110 /* Advance to the last statement. Set all container types to
1112 for (; TREE_CODE (*p
) == COMPOUND_EXPR
; p
= &TREE_OPERAND (*p
, 1))
1114 TREE_SIDE_EFFECTS (*p
) = 1;
1115 TREE_TYPE (*p
) = void_type_node
;
1119 case TRANSACTION_EXPR
:
1120 TREE_SIDE_EFFECTS (*p
) = 1;
1121 TREE_TYPE (*p
) = void_type_node
;
1122 p
= &TRANSACTION_EXPR_BODY (*p
);
1126 /* Assume that any tree upon which voidify_wrapper_expr is
1127 directly called is a wrapper, and that its body is op0. */
1130 TREE_SIDE_EFFECTS (*p
) = 1;
1131 TREE_TYPE (*p
) = void_type_node
;
1132 p
= &TREE_OPERAND (*p
, 0);
1140 if (p
== NULL
|| IS_EMPTY_STMT (*p
))
1144 /* The wrapper is on the RHS of an assignment that we're pushing
1146 gcc_assert (TREE_CODE (temp
) == INIT_EXPR
1147 || TREE_CODE (temp
) == MODIFY_EXPR
);
1148 TREE_OPERAND (temp
, 1) = *p
;
1153 temp
= create_tmp_var (type
, "retval");
1154 *p
= build2 (INIT_EXPR
, type
, temp
, *p
);
1163 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1164 a temporary through which they communicate. */
1167 build_stack_save_restore (gimple
*save
, gimple
*restore
)
1171 *save
= gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE
), 0);
1172 tmp_var
= create_tmp_var (ptr_type_node
, "saved_stack");
1173 gimple_call_set_lhs (*save
, tmp_var
);
1176 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE
),
1180 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1182 static enum gimplify_status
1183 gimplify_bind_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1185 tree bind_expr
= *expr_p
;
1186 bool old_save_stack
= gimplify_ctxp
->save_stack
;
1189 gimple_seq body
, cleanup
;
1192 tree temp
= voidify_wrapper_expr (bind_expr
, NULL
);
1194 /* Mark variables seen in this bind expr. */
1195 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1197 if (TREE_CODE (t
) == VAR_DECL
)
1199 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1201 /* Mark variable as local. */
1202 if (ctx
&& !DECL_EXTERNAL (t
)
1203 && (! DECL_SEEN_IN_BIND_EXPR_P (t
)
1204 || splay_tree_lookup (ctx
->variables
,
1205 (splay_tree_key
) t
) == NULL
))
1206 omp_add_variable (gimplify_omp_ctxp
, t
, GOVD_LOCAL
| GOVD_SEEN
);
1208 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
1210 if (DECL_HARD_REGISTER (t
) && !is_global_var (t
) && cfun
)
1211 cfun
->has_local_explicit_reg_vars
= true;
1214 /* Preliminarily mark non-addressed complex variables as eligible
1215 for promotion to gimple registers. We'll transform their uses
1217 if ((TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
1218 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1219 && !TREE_THIS_VOLATILE (t
)
1220 && (TREE_CODE (t
) == VAR_DECL
&& !DECL_HARD_REGISTER (t
))
1221 && !needs_to_live_in_memory (t
))
1222 DECL_GIMPLE_REG_P (t
) = 1;
1225 gimple_bind
= gimple_build_bind (BIND_EXPR_VARS (bind_expr
), NULL
,
1226 BIND_EXPR_BLOCK (bind_expr
));
1227 gimple_push_bind_expr (gimple_bind
);
1229 gimplify_ctxp
->save_stack
= false;
1231 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1233 gimplify_stmt (&BIND_EXPR_BODY (bind_expr
), &body
);
1234 gimple_bind_set_body (gimple_bind
, body
);
1238 if (gimplify_ctxp
->save_stack
)
1240 gimple stack_restore
;
1242 /* Save stack on entry and restore it on exit. Add a try_finally
1243 block to achieve this. Note that mudflap depends on the
1244 format of the emitted code: see mx_register_decls(). */
1245 build_stack_save_restore (&stack_save
, &stack_restore
);
1247 gimplify_seq_add_stmt (&cleanup
, stack_restore
);
1250 /* Add clobbers for all variables that go out of scope. */
1251 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1253 if (TREE_CODE (t
) == VAR_DECL
1254 && !is_global_var (t
)
1255 && DECL_CONTEXT (t
) == current_function_decl
1256 && !DECL_HARD_REGISTER (t
)
1257 && !TREE_THIS_VOLATILE (t
)
1258 && !DECL_HAS_VALUE_EXPR_P (t
)
1259 /* Only care for variables that have to be in memory. Others
1260 will be rewritten into SSA names, hence moved to the top-level. */
1261 && !is_gimple_reg (t
)
1262 && flag_stack_reuse
!= SR_NONE
)
1264 tree clobber
= build_constructor (TREE_TYPE (t
),
1266 TREE_THIS_VOLATILE (clobber
) = 1;
1267 gimplify_seq_add_stmt (&cleanup
, gimple_build_assign (t
, clobber
));
1274 gimple_seq new_body
;
1277 gs
= gimple_build_try (gimple_bind_body (gimple_bind
), cleanup
,
1278 GIMPLE_TRY_FINALLY
);
1281 gimplify_seq_add_stmt (&new_body
, stack_save
);
1282 gimplify_seq_add_stmt (&new_body
, gs
);
1283 gimple_bind_set_body (gimple_bind
, new_body
);
1286 gimplify_ctxp
->save_stack
= old_save_stack
;
1287 gimple_pop_bind_expr ();
1289 gimplify_seq_add_stmt (pre_p
, gimple_bind
);
1297 *expr_p
= NULL_TREE
;
1301 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1302 GIMPLE value, it is assigned to a new temporary and the statement is
1303 re-written to return the temporary.
1305 PRE_P points to the sequence where side effects that must happen before
1306 STMT should be stored. */
1308 static enum gimplify_status
1309 gimplify_return_expr (tree stmt
, gimple_seq
*pre_p
)
1312 tree ret_expr
= TREE_OPERAND (stmt
, 0);
1313 tree result_decl
, result
;
1315 if (ret_expr
== error_mark_node
)
1319 || TREE_CODE (ret_expr
) == RESULT_DECL
1320 || ret_expr
== error_mark_node
)
1322 gimple ret
= gimple_build_return (ret_expr
);
1323 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1324 gimplify_seq_add_stmt (pre_p
, ret
);
1328 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1329 result_decl
= NULL_TREE
;
1332 result_decl
= TREE_OPERAND (ret_expr
, 0);
1334 /* See through a return by reference. */
1335 if (TREE_CODE (result_decl
) == INDIRECT_REF
)
1336 result_decl
= TREE_OPERAND (result_decl
, 0);
1338 gcc_assert ((TREE_CODE (ret_expr
) == MODIFY_EXPR
1339 || TREE_CODE (ret_expr
) == INIT_EXPR
)
1340 && TREE_CODE (result_decl
) == RESULT_DECL
);
1343 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1344 Recall that aggregate_value_p is FALSE for any aggregate type that is
1345 returned in registers. If we're returning values in registers, then
1346 we don't want to extend the lifetime of the RESULT_DECL, particularly
1347 across another call. In addition, for those aggregates for which
1348 hard_function_value generates a PARALLEL, we'll die during normal
1349 expansion of structure assignments; there's special code in expand_return
1350 to handle this case that does not exist in expand_expr. */
1353 else if (aggregate_value_p (result_decl
, TREE_TYPE (current_function_decl
)))
1355 if (TREE_CODE (DECL_SIZE (result_decl
)) != INTEGER_CST
)
1357 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl
)))
1358 gimplify_type_sizes (TREE_TYPE (result_decl
), pre_p
);
1359 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1360 should be effectively allocated by the caller, i.e. all calls to
1361 this function must be subject to the Return Slot Optimization. */
1362 gimplify_one_sizepos (&DECL_SIZE (result_decl
), pre_p
);
1363 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl
), pre_p
);
1365 result
= result_decl
;
1367 else if (gimplify_ctxp
->return_temp
)
1368 result
= gimplify_ctxp
->return_temp
;
1371 result
= create_tmp_reg (TREE_TYPE (result_decl
), NULL
);
1373 /* ??? With complex control flow (usually involving abnormal edges),
1374 we can wind up warning about an uninitialized value for this. Due
1375 to how this variable is constructed and initialized, this is never
1376 true. Give up and never warn. */
1377 TREE_NO_WARNING (result
) = 1;
1379 gimplify_ctxp
->return_temp
= result
;
1382 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1383 Then gimplify the whole thing. */
1384 if (result
!= result_decl
)
1385 TREE_OPERAND (ret_expr
, 0) = result
;
1387 gimplify_and_add (TREE_OPERAND (stmt
, 0), pre_p
);
1389 ret
= gimple_build_return (result
);
1390 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1391 gimplify_seq_add_stmt (pre_p
, ret
);
1396 /* Gimplify a variable-length array DECL. */
1399 gimplify_vla_decl (tree decl
, gimple_seq
*seq_p
)
1401 /* This is a variable-sized decl. Simplify its size and mark it
1402 for deferred expansion. Note that mudflap depends on the format
1403 of the emitted code: see mx_register_decls(). */
1404 tree t
, addr
, ptr_type
;
1406 gimplify_one_sizepos (&DECL_SIZE (decl
), seq_p
);
1407 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl
), seq_p
);
1409 /* All occurrences of this decl in final gimplified code will be
1410 replaced by indirection. Setting DECL_VALUE_EXPR does two
1411 things: First, it lets the rest of the gimplifier know what
1412 replacement to use. Second, it lets the debug info know
1413 where to find the value. */
1414 ptr_type
= build_pointer_type (TREE_TYPE (decl
));
1415 addr
= create_tmp_var (ptr_type
, get_name (decl
));
1416 DECL_IGNORED_P (addr
) = 0;
1417 t
= build_fold_indirect_ref (addr
);
1418 TREE_THIS_NOTRAP (t
) = 1;
1419 SET_DECL_VALUE_EXPR (decl
, t
);
1420 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1422 t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
1423 t
= build_call_expr (t
, 2, DECL_SIZE_UNIT (decl
),
1424 size_int (DECL_ALIGN (decl
)));
1425 /* The call has been built for a variable-sized object. */
1426 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
1427 t
= fold_convert (ptr_type
, t
);
1428 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
1430 gimplify_and_add (t
, seq_p
);
1432 /* Indicate that we need to restore the stack level when the
1433 enclosing BIND_EXPR is exited. */
1434 gimplify_ctxp
->save_stack
= true;
1437 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1438 and initialization explicit. */
1440 static enum gimplify_status
1441 gimplify_decl_expr (tree
*stmt_p
, gimple_seq
*seq_p
)
1443 tree stmt
= *stmt_p
;
1444 tree decl
= DECL_EXPR_DECL (stmt
);
1446 *stmt_p
= NULL_TREE
;
1448 if (TREE_TYPE (decl
) == error_mark_node
)
1451 if ((TREE_CODE (decl
) == TYPE_DECL
1452 || TREE_CODE (decl
) == VAR_DECL
)
1453 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl
)))
1454 gimplify_type_sizes (TREE_TYPE (decl
), seq_p
);
1456 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1457 in case its size expressions contain problematic nodes like CALL_EXPR. */
1458 if (TREE_CODE (decl
) == TYPE_DECL
1459 && DECL_ORIGINAL_TYPE (decl
)
1460 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl
)))
1461 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl
), seq_p
);
1463 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1465 tree init
= DECL_INITIAL (decl
);
1467 if (TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1468 || (!TREE_STATIC (decl
)
1469 && flag_stack_check
== GENERIC_STACK_CHECK
1470 && compare_tree_int (DECL_SIZE_UNIT (decl
),
1471 STACK_CHECK_MAX_VAR_SIZE
) > 0))
1472 gimplify_vla_decl (decl
, seq_p
);
1474 /* Some front ends do not explicitly declare all anonymous
1475 artificial variables. We compensate here by declaring the
1476 variables, though it would be better if the front ends would
1477 explicitly declare them. */
1478 if (!DECL_SEEN_IN_BIND_EXPR_P (decl
)
1479 && DECL_ARTIFICIAL (decl
) && DECL_NAME (decl
) == NULL_TREE
)
1480 gimple_add_tmp_var (decl
);
1482 if (init
&& init
!= error_mark_node
)
1484 if (!TREE_STATIC (decl
))
1486 DECL_INITIAL (decl
) = NULL_TREE
;
1487 init
= build2 (INIT_EXPR
, void_type_node
, decl
, init
);
1488 gimplify_and_add (init
, seq_p
);
1492 /* We must still examine initializers for static variables
1493 as they may contain a label address. */
1494 walk_tree (&init
, force_labels_r
, NULL
, NULL
);
1501 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1502 and replacing the LOOP_EXPR with goto, but if the loop contains an
1503 EXIT_EXPR, we need to append a label for it to jump to. */
1505 static enum gimplify_status
1506 gimplify_loop_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1508 tree saved_label
= gimplify_ctxp
->exit_label
;
1509 tree start_label
= create_artificial_label (UNKNOWN_LOCATION
);
1511 gimplify_seq_add_stmt (pre_p
, gimple_build_label (start_label
));
1513 gimplify_ctxp
->exit_label
= NULL_TREE
;
1515 gimplify_and_add (LOOP_EXPR_BODY (*expr_p
), pre_p
);
1517 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (start_label
));
1519 if (gimplify_ctxp
->exit_label
)
1520 gimplify_seq_add_stmt (pre_p
,
1521 gimple_build_label (gimplify_ctxp
->exit_label
));
1523 gimplify_ctxp
->exit_label
= saved_label
;
1529 /* Gimplify a statement list onto a sequence. These may be created either
1530 by an enlightened front-end, or by shortcut_cond_expr. */
1532 static enum gimplify_status
1533 gimplify_statement_list (tree
*expr_p
, gimple_seq
*pre_p
)
1535 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
1537 tree_stmt_iterator i
= tsi_start (*expr_p
);
1539 while (!tsi_end_p (i
))
1541 gimplify_stmt (tsi_stmt_ptr (i
), pre_p
);
1554 /* Compare two case labels. Because the front end should already have
1555 made sure that case ranges do not overlap, it is enough to only compare
1556 the CASE_LOW values of each case label. */
1559 compare_case_labels (const void *p1
, const void *p2
)
1561 const_tree
const case1
= *(const_tree
const*)p1
;
1562 const_tree
const case2
= *(const_tree
const*)p2
;
1564 /* The 'default' case label always goes first. */
1565 if (!CASE_LOW (case1
))
1567 else if (!CASE_LOW (case2
))
1570 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
1573 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1576 sort_case_labels (vec
<tree
> label_vec
)
1578 label_vec
.qsort (compare_case_labels
);
1581 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
1583 LABELS is a vector that contains all case labels to look at.
1585 INDEX_TYPE is the type of the switch index expression. Case labels
1586 in LABELS are discarded if their values are not in the value range
1587 covered by INDEX_TYPE. The remaining case label values are folded
1590 If a default case exists in LABELS, it is removed from LABELS and
1591 returned in DEFAULT_CASEP. If no default case exists, but the
1592 case labels already cover the whole range of INDEX_TYPE, a default
1593 case is returned pointing to one of the existing case labels.
1594 Otherwise DEFAULT_CASEP is set to NULL_TREE.
1596 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
1597 apply and no action is taken regardless of whether a default case is
1601 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
1603 tree
*default_casep
)
1605 tree min_value
, max_value
;
1606 tree default_case
= NULL_TREE
;
1610 min_value
= TYPE_MIN_VALUE (index_type
);
1611 max_value
= TYPE_MAX_VALUE (index_type
);
1612 while (i
< labels
.length ())
1614 tree elt
= labels
[i
];
1615 tree low
= CASE_LOW (elt
);
1616 tree high
= CASE_HIGH (elt
);
1617 bool remove_element
= FALSE
;
1621 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
1622 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
1624 /* This is a non-default case label, i.e. it has a value.
1626 See if the case label is reachable within the range of
1627 the index type. Remove out-of-range case values. Turn
1628 case ranges into a canonical form (high > low strictly)
1629 and convert the case label values to the index type.
1631 NB: The type of gimple_switch_index() may be the promoted
1632 type, but the case labels retain the original type. */
1636 /* This is a case range. Discard empty ranges.
1637 If the bounds or the range are equal, turn this
1638 into a simple (one-value) case. */
1639 int cmp
= tree_int_cst_compare (high
, low
);
1641 remove_element
= TRUE
;
1648 /* If the simple case value is unreachable, ignore it. */
1649 if ((TREE_CODE (min_value
) == INTEGER_CST
1650 && tree_int_cst_compare (low
, min_value
) < 0)
1651 || (TREE_CODE (max_value
) == INTEGER_CST
1652 && tree_int_cst_compare (low
, max_value
) > 0))
1653 remove_element
= TRUE
;
1655 low
= fold_convert (index_type
, low
);
1659 /* If the entire case range is unreachable, ignore it. */
1660 if ((TREE_CODE (min_value
) == INTEGER_CST
1661 && tree_int_cst_compare (high
, min_value
) < 0)
1662 || (TREE_CODE (max_value
) == INTEGER_CST
1663 && tree_int_cst_compare (low
, max_value
) > 0))
1664 remove_element
= TRUE
;
1667 /* If the lower bound is less than the index type's
1668 minimum value, truncate the range bounds. */
1669 if (TREE_CODE (min_value
) == INTEGER_CST
1670 && tree_int_cst_compare (low
, min_value
) < 0)
1672 low
= fold_convert (index_type
, low
);
1674 /* If the upper bound is greater than the index type's
1675 maximum value, truncate the range bounds. */
1676 if (TREE_CODE (max_value
) == INTEGER_CST
1677 && tree_int_cst_compare (high
, max_value
) > 0)
1679 high
= fold_convert (index_type
, high
);
1681 /* We may have folded a case range to a one-value case. */
1682 if (tree_int_cst_equal (low
, high
))
1687 CASE_LOW (elt
) = low
;
1688 CASE_HIGH (elt
) = high
;
1692 gcc_assert (!default_case
);
1694 /* The default case must be passed separately to the
1695 gimple_build_switch routine. But if DEFAULT_CASEP
1696 is NULL, we do not remove the default case (it would
1697 be completely lost). */
1699 remove_element
= TRUE
;
1703 labels
.ordered_remove (i
);
1709 if (!labels
.is_empty ())
1710 sort_case_labels (labels
);
1712 if (default_casep
&& !default_case
)
1714 /* If the switch has no default label, add one, so that we jump
1715 around the switch body. If the labels already cover the whole
1716 range of the switch index_type, add the default label pointing
1717 to one of the existing labels. */
1719 && TYPE_MIN_VALUE (index_type
)
1720 && TYPE_MAX_VALUE (index_type
)
1721 && tree_int_cst_equal (CASE_LOW (labels
[0]),
1722 TYPE_MIN_VALUE (index_type
)))
1724 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
1726 high
= CASE_LOW (labels
[len
- 1]);
1727 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
1729 for (i
= 1; i
< len
; i
++)
1731 high
= CASE_LOW (labels
[i
]);
1732 low
= CASE_HIGH (labels
[i
- 1]);
1734 low
= CASE_LOW (labels
[i
- 1]);
1735 if ((TREE_INT_CST_LOW (low
) + 1
1736 != TREE_INT_CST_LOW (high
))
1737 || (TREE_INT_CST_HIGH (low
)
1738 + (TREE_INT_CST_LOW (high
) == 0)
1739 != TREE_INT_CST_HIGH (high
)))
1744 tree label
= CASE_LABEL (labels
[0]);
1745 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
1753 *default_casep
= default_case
;
1756 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
1759 static enum gimplify_status
1760 gimplify_switch_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1762 tree switch_expr
= *expr_p
;
1763 gimple_seq switch_body_seq
= NULL
;
1764 enum gimplify_status ret
;
1765 tree index_type
= TREE_TYPE (switch_expr
);
1766 if (index_type
== NULL_TREE
)
1767 index_type
= TREE_TYPE (SWITCH_COND (switch_expr
));
1769 ret
= gimplify_expr (&SWITCH_COND (switch_expr
), pre_p
, NULL
, is_gimple_val
,
1771 if (ret
== GS_ERROR
|| ret
== GS_UNHANDLED
)
1774 if (SWITCH_BODY (switch_expr
))
1777 vec
<tree
> saved_labels
;
1778 tree default_case
= NULL_TREE
;
1779 gimple gimple_switch
;
1781 /* If someone can be bothered to fill in the labels, they can
1782 be bothered to null out the body too. */
1783 gcc_assert (!SWITCH_LABELS (switch_expr
));
1785 /* Save old labels, get new ones from body, then restore the old
1786 labels. Save all the things from the switch body to append after. */
1787 saved_labels
= gimplify_ctxp
->case_labels
;
1788 gimplify_ctxp
->case_labels
.create (8);
1790 gimplify_stmt (&SWITCH_BODY (switch_expr
), &switch_body_seq
);
1791 labels
= gimplify_ctxp
->case_labels
;
1792 gimplify_ctxp
->case_labels
= saved_labels
;
1794 preprocess_case_label_vec_for_gimple (labels
, index_type
,
1802 = build_case_label (NULL_TREE
, NULL_TREE
,
1803 create_artificial_label (UNKNOWN_LOCATION
));
1804 new_default
= gimple_build_label (CASE_LABEL (default_case
));
1805 gimplify_seq_add_stmt (&switch_body_seq
, new_default
);
1808 gimple_switch
= gimple_build_switch (SWITCH_COND (switch_expr
),
1809 default_case
, labels
);
1810 gimplify_seq_add_stmt (pre_p
, gimple_switch
);
1811 gimplify_seq_add_seq (pre_p
, switch_body_seq
);
1815 gcc_assert (SWITCH_LABELS (switch_expr
));
1820 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
1822 static enum gimplify_status
1823 gimplify_case_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1825 struct gimplify_ctx
*ctxp
;
1826 gimple gimple_label
;
1828 /* Invalid OpenMP programs can play Duff's Device type games with
1829 #pragma omp parallel. At least in the C front end, we don't
1830 detect such invalid branches until after gimplification. */
1831 for (ctxp
= gimplify_ctxp
; ; ctxp
= ctxp
->prev_context
)
1832 if (ctxp
->case_labels
.exists ())
1835 gimple_label
= gimple_build_label (CASE_LABEL (*expr_p
));
1836 ctxp
->case_labels
.safe_push (*expr_p
);
1837 gimplify_seq_add_stmt (pre_p
, gimple_label
);
1842 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1846 build_and_jump (tree
*label_p
)
1848 if (label_p
== NULL
)
1849 /* If there's nowhere to jump, just fall through. */
1852 if (*label_p
== NULL_TREE
)
1854 tree label
= create_artificial_label (UNKNOWN_LOCATION
);
1858 return build1 (GOTO_EXPR
, void_type_node
, *label_p
);
1861 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1862 This also involves building a label to jump to and communicating it to
1863 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1865 static enum gimplify_status
1866 gimplify_exit_expr (tree
*expr_p
)
1868 tree cond
= TREE_OPERAND (*expr_p
, 0);
1871 expr
= build_and_jump (&gimplify_ctxp
->exit_label
);
1872 expr
= build3 (COND_EXPR
, void_type_node
, cond
, expr
, NULL_TREE
);
1878 /* A helper function to be called via walk_tree. Mark all labels under *TP
1879 as being forced. To be called for DECL_INITIAL of static variables. */
1882 force_labels_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1886 if (TREE_CODE (*tp
) == LABEL_DECL
)
1887 FORCED_LABEL (*tp
) = 1;
1892 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1893 different from its canonical type, wrap the whole thing inside a
1894 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1897 The canonical type of a COMPONENT_REF is the type of the field being
1898 referenced--unless the field is a bit-field which can be read directly
1899 in a smaller mode, in which case the canonical type is the
1900 sign-appropriate type corresponding to that mode. */
1903 canonicalize_component_ref (tree
*expr_p
)
1905 tree expr
= *expr_p
;
1908 gcc_assert (TREE_CODE (expr
) == COMPONENT_REF
);
1910 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
1911 type
= TREE_TYPE (get_unwidened (expr
, NULL_TREE
));
1913 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
1915 /* One could argue that all the stuff below is not necessary for
1916 the non-bitfield case and declare it a FE error if type
1917 adjustment would be needed. */
1918 if (TREE_TYPE (expr
) != type
)
1920 #ifdef ENABLE_TYPES_CHECKING
1921 tree old_type
= TREE_TYPE (expr
);
1925 /* We need to preserve qualifiers and propagate them from
1927 type_quals
= TYPE_QUALS (type
)
1928 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1929 if (TYPE_QUALS (type
) != type_quals
)
1930 type
= build_qualified_type (TYPE_MAIN_VARIANT (type
), type_quals
);
1932 /* Set the type of the COMPONENT_REF to the underlying type. */
1933 TREE_TYPE (expr
) = type
;
1935 #ifdef ENABLE_TYPES_CHECKING
1936 /* It is now a FE error, if the conversion from the canonical
1937 type to the original expression type is not useless. */
1938 gcc_assert (useless_type_conversion_p (old_type
, type
));
1943 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1944 to foo, embed that change in the ADDR_EXPR by converting
1949 where L is the lower bound. For simplicity, only do this for constant
1951 The constraint is that the type of &array[L] is trivially convertible
1955 canonicalize_addr_expr (tree
*expr_p
)
1957 tree expr
= *expr_p
;
1958 tree addr_expr
= TREE_OPERAND (expr
, 0);
1959 tree datype
, ddatype
, pddatype
;
1961 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1962 if (!POINTER_TYPE_P (TREE_TYPE (expr
))
1963 || TREE_CODE (addr_expr
) != ADDR_EXPR
)
1966 /* The addr_expr type should be a pointer to an array. */
1967 datype
= TREE_TYPE (TREE_TYPE (addr_expr
));
1968 if (TREE_CODE (datype
) != ARRAY_TYPE
)
1971 /* The pointer to element type shall be trivially convertible to
1972 the expression pointer type. */
1973 ddatype
= TREE_TYPE (datype
);
1974 pddatype
= build_pointer_type (ddatype
);
1975 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)),
1979 /* The lower bound and element sizes must be constant. */
1980 if (!TYPE_SIZE_UNIT (ddatype
)
1981 || TREE_CODE (TYPE_SIZE_UNIT (ddatype
)) != INTEGER_CST
1982 || !TYPE_DOMAIN (datype
) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))
1983 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))) != INTEGER_CST
)
1986 /* All checks succeeded. Build a new node to merge the cast. */
1987 *expr_p
= build4 (ARRAY_REF
, ddatype
, TREE_OPERAND (addr_expr
, 0),
1988 TYPE_MIN_VALUE (TYPE_DOMAIN (datype
)),
1989 NULL_TREE
, NULL_TREE
);
1990 *expr_p
= build1 (ADDR_EXPR
, pddatype
, *expr_p
);
1992 /* We can have stripped a required restrict qualifier above. */
1993 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
1994 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
1997 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1998 underneath as appropriate. */
2000 static enum gimplify_status
2001 gimplify_conversion (tree
*expr_p
)
2003 location_t loc
= EXPR_LOCATION (*expr_p
);
2004 gcc_assert (CONVERT_EXPR_P (*expr_p
));
2006 /* Then strip away all but the outermost conversion. */
2007 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p
, 0));
2009 /* And remove the outermost conversion if it's useless. */
2010 if (tree_ssa_useless_type_conversion (*expr_p
))
2011 *expr_p
= TREE_OPERAND (*expr_p
, 0);
2013 /* If we still have a conversion at the toplevel,
2014 then canonicalize some constructs. */
2015 if (CONVERT_EXPR_P (*expr_p
))
2017 tree sub
= TREE_OPERAND (*expr_p
, 0);
2019 /* If a NOP conversion is changing the type of a COMPONENT_REF
2020 expression, then canonicalize its type now in order to expose more
2021 redundant conversions. */
2022 if (TREE_CODE (sub
) == COMPONENT_REF
)
2023 canonicalize_component_ref (&TREE_OPERAND (*expr_p
, 0));
2025 /* If a NOP conversion is changing a pointer to array of foo
2026 to a pointer to foo, embed that change in the ADDR_EXPR. */
2027 else if (TREE_CODE (sub
) == ADDR_EXPR
)
2028 canonicalize_addr_expr (expr_p
);
2031 /* If we have a conversion to a non-register type force the
2032 use of a VIEW_CONVERT_EXPR instead. */
2033 if (CONVERT_EXPR_P (*expr_p
) && !is_gimple_reg_type (TREE_TYPE (*expr_p
)))
2034 *expr_p
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (*expr_p
),
2035 TREE_OPERAND (*expr_p
, 0));
2040 /* Nonlocal VLAs seen in the current function. */
2041 static struct pointer_set_t
*nonlocal_vlas
;
2043 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
2044 DECL_VALUE_EXPR, and it's worth re-examining things. */
2046 static enum gimplify_status
2047 gimplify_var_or_parm_decl (tree
*expr_p
)
2049 tree decl
= *expr_p
;
2051 /* ??? If this is a local variable, and it has not been seen in any
2052 outer BIND_EXPR, then it's probably the result of a duplicate
2053 declaration, for which we've already issued an error. It would
2054 be really nice if the front end wouldn't leak these at all.
2055 Currently the only known culprit is C++ destructors, as seen
2056 in g++.old-deja/g++.jason/binding.C. */
2057 if (TREE_CODE (decl
) == VAR_DECL
2058 && !DECL_SEEN_IN_BIND_EXPR_P (decl
)
2059 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)
2060 && decl_function_context (decl
) == current_function_decl
)
2062 gcc_assert (seen_error ());
2066 /* When within an OpenMP context, notice uses of variables. */
2067 if (gimplify_omp_ctxp
&& omp_notice_variable (gimplify_omp_ctxp
, decl
, true))
2070 /* If the decl is an alias for another expression, substitute it now. */
2071 if (DECL_HAS_VALUE_EXPR_P (decl
))
2073 tree value_expr
= DECL_VALUE_EXPR (decl
);
2075 /* For referenced nonlocal VLAs add a decl for debugging purposes
2076 to the current function. */
2077 if (TREE_CODE (decl
) == VAR_DECL
2078 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
2079 && nonlocal_vlas
!= NULL
2080 && TREE_CODE (value_expr
) == INDIRECT_REF
2081 && TREE_CODE (TREE_OPERAND (value_expr
, 0)) == VAR_DECL
2082 && decl_function_context (decl
) != current_function_decl
)
2084 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
2085 while (ctx
&& ctx
->region_type
== ORT_WORKSHARE
)
2086 ctx
= ctx
->outer_context
;
2087 if (!ctx
&& !pointer_set_insert (nonlocal_vlas
, decl
))
2089 tree copy
= copy_node (decl
), block
;
2091 lang_hooks
.dup_lang_specific_decl (copy
);
2092 SET_DECL_RTL (copy
, 0);
2093 TREE_USED (copy
) = 1;
2094 block
= DECL_INITIAL (current_function_decl
);
2095 DECL_CHAIN (copy
) = BLOCK_VARS (block
);
2096 BLOCK_VARS (block
) = copy
;
2097 SET_DECL_VALUE_EXPR (copy
, unshare_expr (value_expr
));
2098 DECL_HAS_VALUE_EXPR_P (copy
) = 1;
2102 *expr_p
= unshare_expr (value_expr
);
2109 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
2113 : min_lval '[' val ']'
2115 | compound_lval '[' val ']'
2116 | compound_lval '.' ID
2118 This is not part of the original SIMPLE definition, which separates
2119 array and member references, but it seems reasonable to handle them
2120 together. Also, this way we don't run into problems with union
2121 aliasing; gcc requires that for accesses through a union to alias, the
2122 union reference must be explicit, which was not always the case when we
2123 were splitting up array and member refs.
2125 PRE_P points to the sequence where side effects that must happen before
2126 *EXPR_P should be stored.
2128 POST_P points to the sequence where side effects that must happen after
2129 *EXPR_P should be stored. */
2131 static enum gimplify_status
2132 gimplify_compound_lval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2133 fallback_t fallback
)
2136 vec
<tree
> expr_stack
;
2137 enum gimplify_status ret
= GS_ALL_DONE
, tret
;
2139 location_t loc
= EXPR_LOCATION (*expr_p
);
2140 tree expr
= *expr_p
;
2142 /* Create a stack of the subexpressions so later we can walk them in
2143 order from inner to outer. */
2144 expr_stack
.create (10);
2146 /* We can handle anything that get_inner_reference can deal with. */
2147 for (p
= expr_p
; ; p
= &TREE_OPERAND (*p
, 0))
2150 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2151 if (TREE_CODE (*p
) == INDIRECT_REF
)
2152 *p
= fold_indirect_ref_loc (loc
, *p
);
2154 if (handled_component_p (*p
))
2156 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2157 additional COMPONENT_REFs. */
2158 else if ((TREE_CODE (*p
) == VAR_DECL
|| TREE_CODE (*p
) == PARM_DECL
)
2159 && gimplify_var_or_parm_decl (p
) == GS_OK
)
2164 expr_stack
.safe_push (*p
);
2167 gcc_assert (expr_stack
.length ());
2169 /* Now EXPR_STACK is a stack of pointers to all the refs we've
2170 walked through and P points to the innermost expression.
2172 Java requires that we elaborated nodes in source order. That
2173 means we must gimplify the inner expression followed by each of
2174 the indices, in order. But we can't gimplify the inner
2175 expression until we deal with any variable bounds, sizes, or
2176 positions in order to deal with PLACEHOLDER_EXPRs.
2178 So we do this in three steps. First we deal with the annotations
2179 for any variables in the components, then we gimplify the base,
2180 then we gimplify any indices, from left to right. */
2181 for (i
= expr_stack
.length () - 1; i
>= 0; i
--)
2183 tree t
= expr_stack
[i
];
2185 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2187 /* Gimplify the low bound and element type size and put them into
2188 the ARRAY_REF. If these values are set, they have already been
2190 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2192 tree low
= unshare_expr (array_ref_low_bound (t
));
2193 if (!is_gimple_min_invariant (low
))
2195 TREE_OPERAND (t
, 2) = low
;
2196 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2197 post_p
, is_gimple_reg
,
2199 ret
= MIN (ret
, tret
);
2204 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2205 is_gimple_reg
, fb_rvalue
);
2206 ret
= MIN (ret
, tret
);
2209 if (TREE_OPERAND (t
, 3) == NULL_TREE
)
2211 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0)));
2212 tree elmt_size
= unshare_expr (array_ref_element_size (t
));
2213 tree factor
= size_int (TYPE_ALIGN_UNIT (elmt_type
));
2215 /* Divide the element size by the alignment of the element
2218 = size_binop_loc (loc
, EXACT_DIV_EXPR
, elmt_size
, factor
);
2220 if (!is_gimple_min_invariant (elmt_size
))
2222 TREE_OPERAND (t
, 3) = elmt_size
;
2223 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
,
2224 post_p
, is_gimple_reg
,
2226 ret
= MIN (ret
, tret
);
2231 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
, post_p
,
2232 is_gimple_reg
, fb_rvalue
);
2233 ret
= MIN (ret
, tret
);
2236 else if (TREE_CODE (t
) == COMPONENT_REF
)
2238 /* Set the field offset into T and gimplify it. */
2239 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2241 tree offset
= unshare_expr (component_ref_field_offset (t
));
2242 tree field
= TREE_OPERAND (t
, 1);
2244 = size_int (DECL_OFFSET_ALIGN (field
) / BITS_PER_UNIT
);
2246 /* Divide the offset by its alignment. */
2247 offset
= size_binop_loc (loc
, EXACT_DIV_EXPR
, offset
, factor
);
2249 if (!is_gimple_min_invariant (offset
))
2251 TREE_OPERAND (t
, 2) = offset
;
2252 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2253 post_p
, is_gimple_reg
,
2255 ret
= MIN (ret
, tret
);
2260 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2261 is_gimple_reg
, fb_rvalue
);
2262 ret
= MIN (ret
, tret
);
2267 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2268 so as to match the min_lval predicate. Failure to do so may result
2269 in the creation of large aggregate temporaries. */
2270 tret
= gimplify_expr (p
, pre_p
, post_p
, is_gimple_min_lval
,
2271 fallback
| fb_lvalue
);
2272 ret
= MIN (ret
, tret
);
2274 /* And finally, the indices and operands of ARRAY_REF. During this
2275 loop we also remove any useless conversions. */
2276 for (; expr_stack
.length () > 0; )
2278 tree t
= expr_stack
.pop ();
2280 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2282 /* Gimplify the dimension. */
2283 if (!is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
2285 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2286 is_gimple_val
, fb_rvalue
);
2287 ret
= MIN (ret
, tret
);
2291 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t
, 0));
2293 /* The innermost expression P may have originally had
2294 TREE_SIDE_EFFECTS set which would have caused all the outer
2295 expressions in *EXPR_P leading to P to also have had
2296 TREE_SIDE_EFFECTS set. */
2297 recalculate_side_effects (t
);
2300 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2301 if ((fallback
& fb_rvalue
) && TREE_CODE (*expr_p
) == COMPONENT_REF
)
2303 canonicalize_component_ref (expr_p
);
2306 expr_stack
.release ();
2308 gcc_assert (*expr_p
== expr
|| ret
!= GS_ALL_DONE
);
2313 /* Gimplify the self modifying expression pointed to by EXPR_P
2316 PRE_P points to the list where side effects that must happen before
2317 *EXPR_P should be stored.
2319 POST_P points to the list where side effects that must happen after
2320 *EXPR_P should be stored.
2322 WANT_VALUE is nonzero iff we want to use the value of this expression
2323 in another expression. */
2325 static enum gimplify_status
2326 gimplify_self_mod_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2329 enum tree_code code
;
2330 tree lhs
, lvalue
, rhs
, t1
;
2331 gimple_seq post
= NULL
, *orig_post_p
= post_p
;
2333 enum tree_code arith_code
;
2334 enum gimplify_status ret
;
2335 location_t loc
= EXPR_LOCATION (*expr_p
);
2337 code
= TREE_CODE (*expr_p
);
2339 gcc_assert (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
2340 || code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
);
2342 /* Prefix or postfix? */
2343 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
2344 /* Faster to treat as prefix if result is not used. */
2345 postfix
= want_value
;
2349 /* For postfix, make sure the inner expression's post side effects
2350 are executed after side effects from this expression. */
2354 /* Add or subtract? */
2355 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2356 arith_code
= PLUS_EXPR
;
2358 arith_code
= MINUS_EXPR
;
2360 /* Gimplify the LHS into a GIMPLE lvalue. */
2361 lvalue
= TREE_OPERAND (*expr_p
, 0);
2362 ret
= gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
2363 if (ret
== GS_ERROR
)
2366 /* Extract the operands to the arithmetic operation. */
2368 rhs
= TREE_OPERAND (*expr_p
, 1);
2370 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2371 that as the result value and in the postqueue operation. We also
2372 make sure to make lvalue a minimal lval, see
2373 gcc.c-torture/execute/20040313-1.c for an example where this matters. */
2376 if (!is_gimple_min_lval (lvalue
))
2378 mark_addressable (lvalue
);
2379 lvalue
= build_fold_addr_expr_loc (input_location
, lvalue
);
2380 gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
2381 lvalue
= build_fold_indirect_ref_loc (input_location
, lvalue
);
2383 ret
= gimplify_expr (&lhs
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
2384 if (ret
== GS_ERROR
)
2388 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2389 if (POINTER_TYPE_P (TREE_TYPE (lhs
)))
2391 rhs
= convert_to_ptrofftype_loc (loc
, rhs
);
2392 if (arith_code
== MINUS_EXPR
)
2393 rhs
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
2394 arith_code
= POINTER_PLUS_EXPR
;
2399 tree t2
= get_initialized_tmp_var (lhs
, pre_p
, NULL
);
2400 t1
= build2 (arith_code
, TREE_TYPE (*expr_p
), t2
, rhs
);
2401 gimplify_assign (lvalue
, t1
, pre_p
);
2402 gimplify_seq_add_seq (orig_post_p
, post
);
2408 t1
= build2 (arith_code
, TREE_TYPE (*expr_p
), lhs
, rhs
);
2409 *expr_p
= build2 (MODIFY_EXPR
, TREE_TYPE (lvalue
), lvalue
, t1
);
2414 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2417 maybe_with_size_expr (tree
*expr_p
)
2419 tree expr
= *expr_p
;
2420 tree type
= TREE_TYPE (expr
);
2423 /* If we've already wrapped this or the type is error_mark_node, we can't do
2425 if (TREE_CODE (expr
) == WITH_SIZE_EXPR
2426 || type
== error_mark_node
)
2429 /* If the size isn't known or is a constant, we have nothing to do. */
2430 size
= TYPE_SIZE_UNIT (type
);
2431 if (!size
|| TREE_CODE (size
) == INTEGER_CST
)
2434 /* Otherwise, make a WITH_SIZE_EXPR. */
2435 size
= unshare_expr (size
);
2436 size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (size
, expr
);
2437 *expr_p
= build2 (WITH_SIZE_EXPR
, type
, expr
, size
);
2440 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2441 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2444 static enum gimplify_status
2445 gimplify_arg (tree
*arg_p
, gimple_seq
*pre_p
, location_t call_location
)
2447 bool (*test
) (tree
);
2450 /* In general, we allow lvalues for function arguments to avoid
2451 extra overhead of copying large aggregates out of even larger
2452 aggregates into temporaries only to copy the temporaries to
2453 the argument list. Make optimizers happy by pulling out to
2454 temporaries those types that fit in registers. */
2455 if (is_gimple_reg_type (TREE_TYPE (*arg_p
)))
2456 test
= is_gimple_val
, fb
= fb_rvalue
;
2459 test
= is_gimple_lvalue
, fb
= fb_either
;
2460 /* Also strip a TARGET_EXPR that would force an extra copy. */
2461 if (TREE_CODE (*arg_p
) == TARGET_EXPR
)
2463 tree init
= TARGET_EXPR_INITIAL (*arg_p
);
2465 && !VOID_TYPE_P (TREE_TYPE (init
)))
2470 /* If this is a variable sized type, we must remember the size. */
2471 maybe_with_size_expr (arg_p
);
2473 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2474 /* Make sure arguments have the same location as the function call
2476 protected_set_expr_location (*arg_p
, call_location
);
2478 /* There is a sequence point before a function call. Side effects in
2479 the argument list must occur before the actual call. So, when
2480 gimplifying arguments, force gimplify_expr to use an internal
2481 post queue which is then appended to the end of PRE_P. */
2482 return gimplify_expr (arg_p
, pre_p
, NULL
, test
, fb
);
2485 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2486 WANT_VALUE is true if the result of the call is desired. */
2488 static enum gimplify_status
2489 gimplify_call_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
2491 tree fndecl
, parms
, p
, fnptrtype
;
2492 enum gimplify_status ret
;
2495 bool builtin_va_start_p
= FALSE
;
2496 location_t loc
= EXPR_LOCATION (*expr_p
);
2498 gcc_assert (TREE_CODE (*expr_p
) == CALL_EXPR
);
2500 /* For reliable diagnostics during inlining, it is necessary that
2501 every call_expr be annotated with file and line. */
2502 if (! EXPR_HAS_LOCATION (*expr_p
))
2503 SET_EXPR_LOCATION (*expr_p
, input_location
);
2505 /* This may be a call to a builtin function.
2507 Builtin function calls may be transformed into different
2508 (and more efficient) builtin function calls under certain
2509 circumstances. Unfortunately, gimplification can muck things
2510 up enough that the builtin expanders are not aware that certain
2511 transformations are still valid.
2513 So we attempt transformation/gimplification of the call before
2514 we gimplify the CALL_EXPR. At this time we do not manage to
2515 transform all calls in the same manner as the expanders do, but
2516 we do transform most of them. */
2517 fndecl
= get_callee_fndecl (*expr_p
);
2519 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
2520 switch (DECL_FUNCTION_CODE (fndecl
))
2522 case BUILT_IN_VA_START
:
2524 builtin_va_start_p
= TRUE
;
2525 if (call_expr_nargs (*expr_p
) < 2)
2527 error ("too few arguments to function %<va_start%>");
2528 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2532 if (fold_builtin_next_arg (*expr_p
, true))
2534 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2541 expanded_location loc
= expand_location (EXPR_LOCATION (*expr_p
));
2542 *expr_p
= build_int_cst (TREE_TYPE (*expr_p
), loc
.line
);
2547 expanded_location loc
= expand_location (EXPR_LOCATION (*expr_p
));
2548 *expr_p
= build_string_literal (strlen (loc
.file
) + 1, loc
.file
);
2551 case BUILT_IN_FUNCTION
:
2553 const char *function
;
2554 function
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
2555 *expr_p
= build_string_literal (strlen (function
) + 1, function
);
2561 if (fndecl
&& DECL_BUILT_IN (fndecl
))
2563 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2564 if (new_tree
&& new_tree
!= *expr_p
)
2566 /* There was a transformation of this call which computes the
2567 same value, but in a more efficient way. Return and try
2574 /* Remember the original function pointer type. */
2575 fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*expr_p
));
2577 /* There is a sequence point before the call, so any side effects in
2578 the calling expression must occur before the actual call. Force
2579 gimplify_expr to use an internal post queue. */
2580 ret
= gimplify_expr (&CALL_EXPR_FN (*expr_p
), pre_p
, NULL
,
2581 is_gimple_call_addr
, fb_rvalue
);
2583 nargs
= call_expr_nargs (*expr_p
);
2585 /* Get argument types for verification. */
2586 fndecl
= get_callee_fndecl (*expr_p
);
2589 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2590 else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p
))))
2591 parms
= TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p
))));
2593 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
2594 p
= DECL_ARGUMENTS (fndecl
);
2599 for (i
= 0; i
< nargs
&& p
; i
++, p
= TREE_CHAIN (p
))
2602 /* If the last argument is __builtin_va_arg_pack () and it is not
2603 passed as a named argument, decrease the number of CALL_EXPR
2604 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2607 && TREE_CODE (CALL_EXPR_ARG (*expr_p
, nargs
- 1)) == CALL_EXPR
)
2609 tree last_arg
= CALL_EXPR_ARG (*expr_p
, nargs
- 1);
2610 tree last_arg_fndecl
= get_callee_fndecl (last_arg
);
2613 && TREE_CODE (last_arg_fndecl
) == FUNCTION_DECL
2614 && DECL_BUILT_IN_CLASS (last_arg_fndecl
) == BUILT_IN_NORMAL
2615 && DECL_FUNCTION_CODE (last_arg_fndecl
) == BUILT_IN_VA_ARG_PACK
)
2617 tree call
= *expr_p
;
2620 *expr_p
= build_call_array_loc (loc
, TREE_TYPE (call
),
2621 CALL_EXPR_FN (call
),
2622 nargs
, CALL_EXPR_ARGP (call
));
2624 /* Copy all CALL_EXPR flags, location and block, except
2625 CALL_EXPR_VA_ARG_PACK flag. */
2626 CALL_EXPR_STATIC_CHAIN (*expr_p
) = CALL_EXPR_STATIC_CHAIN (call
);
2627 CALL_EXPR_TAILCALL (*expr_p
) = CALL_EXPR_TAILCALL (call
);
2628 CALL_EXPR_RETURN_SLOT_OPT (*expr_p
)
2629 = CALL_EXPR_RETURN_SLOT_OPT (call
);
2630 CALL_FROM_THUNK_P (*expr_p
) = CALL_FROM_THUNK_P (call
);
2631 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (call
));
2633 /* Set CALL_EXPR_VA_ARG_PACK. */
2634 CALL_EXPR_VA_ARG_PACK (*expr_p
) = 1;
2638 /* Finally, gimplify the function arguments. */
2641 for (i
= (PUSH_ARGS_REVERSED
? nargs
- 1 : 0);
2642 PUSH_ARGS_REVERSED
? i
>= 0 : i
< nargs
;
2643 PUSH_ARGS_REVERSED
? i
-- : i
++)
2645 enum gimplify_status t
;
2647 /* Avoid gimplifying the second argument to va_start, which needs to
2648 be the plain PARM_DECL. */
2649 if ((i
!= 1) || !builtin_va_start_p
)
2651 t
= gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
2652 EXPR_LOCATION (*expr_p
));
2660 /* Verify the function result. */
2661 if (want_value
&& fndecl
2662 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype
))))
2664 error_at (loc
, "using result of function returning %<void%>");
2668 /* Try this again in case gimplification exposed something. */
2669 if (ret
!= GS_ERROR
)
2671 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2673 if (new_tree
&& new_tree
!= *expr_p
)
2675 /* There was a transformation of this call which computes the
2676 same value, but in a more efficient way. Return and try
2684 *expr_p
= error_mark_node
;
2688 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2689 decl. This allows us to eliminate redundant or useless
2690 calls to "const" functions. */
2691 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
2693 int flags
= call_expr_flags (*expr_p
);
2694 if (flags
& (ECF_CONST
| ECF_PURE
)
2695 /* An infinite loop is considered a side effect. */
2696 && !(flags
& (ECF_LOOPING_CONST_OR_PURE
)))
2697 TREE_SIDE_EFFECTS (*expr_p
) = 0;
2700 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2701 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2702 form and delegate the creation of a GIMPLE_CALL to
2703 gimplify_modify_expr. This is always possible because when
2704 WANT_VALUE is true, the caller wants the result of this call into
2705 a temporary, which means that we will emit an INIT_EXPR in
2706 internal_get_tmp_var which will then be handled by
2707 gimplify_modify_expr. */
2710 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2711 have to do is replicate it as a GIMPLE_CALL tuple. */
2712 gimple_stmt_iterator gsi
;
2713 call
= gimple_build_call_from_tree (*expr_p
);
2714 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
2715 gimplify_seq_add_stmt (pre_p
, call
);
2716 gsi
= gsi_last (*pre_p
);
2718 *expr_p
= NULL_TREE
;
2721 /* Remember the original function type. */
2722 CALL_EXPR_FN (*expr_p
) = build1 (NOP_EXPR
, fnptrtype
,
2723 CALL_EXPR_FN (*expr_p
));
2728 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2729 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2731 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2732 condition is true or false, respectively. If null, we should generate
2733 our own to skip over the evaluation of this specific expression.
2735 LOCUS is the source location of the COND_EXPR.
2737 This function is the tree equivalent of do_jump.
2739 shortcut_cond_r should only be called by shortcut_cond_expr. */
2742 shortcut_cond_r (tree pred
, tree
*true_label_p
, tree
*false_label_p
,
2745 tree local_label
= NULL_TREE
;
2746 tree t
, expr
= NULL
;
2748 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2749 retain the shortcut semantics. Just insert the gotos here;
2750 shortcut_cond_expr will append the real blocks later. */
2751 if (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2753 location_t new_locus
;
2755 /* Turn if (a && b) into
2757 if (a); else goto no;
2758 if (b) goto yes; else goto no;
2761 if (false_label_p
== NULL
)
2762 false_label_p
= &local_label
;
2764 /* Keep the original source location on the first 'if'. */
2765 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), NULL
, false_label_p
, locus
);
2766 append_to_statement_list (t
, &expr
);
2768 /* Set the source location of the && on the second 'if'. */
2769 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2770 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2772 append_to_statement_list (t
, &expr
);
2774 else if (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2776 location_t new_locus
;
2778 /* Turn if (a || b) into
2781 if (b) goto yes; else goto no;
2784 if (true_label_p
== NULL
)
2785 true_label_p
= &local_label
;
2787 /* Keep the original source location on the first 'if'. */
2788 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), true_label_p
, NULL
, locus
);
2789 append_to_statement_list (t
, &expr
);
2791 /* Set the source location of the || on the second 'if'. */
2792 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2793 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2795 append_to_statement_list (t
, &expr
);
2797 else if (TREE_CODE (pred
) == COND_EXPR
2798 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 1)))
2799 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 2))))
2801 location_t new_locus
;
2803 /* As long as we're messing with gotos, turn if (a ? b : c) into
2805 if (b) goto yes; else goto no;
2807 if (c) goto yes; else goto no;
2809 Don't do this if one of the arms has void type, which can happen
2810 in C++ when the arm is throw. */
2812 /* Keep the original source location on the first 'if'. Set the source
2813 location of the ? on the second 'if'. */
2814 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2815 expr
= build3 (COND_EXPR
, void_type_node
, TREE_OPERAND (pred
, 0),
2816 shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
,
2817 false_label_p
, locus
),
2818 shortcut_cond_r (TREE_OPERAND (pred
, 2), true_label_p
,
2819 false_label_p
, new_locus
));
2823 expr
= build3 (COND_EXPR
, void_type_node
, pred
,
2824 build_and_jump (true_label_p
),
2825 build_and_jump (false_label_p
));
2826 SET_EXPR_LOCATION (expr
, locus
);
2831 t
= build1 (LABEL_EXPR
, void_type_node
, local_label
);
2832 append_to_statement_list (t
, &expr
);
2838 /* Given a conditional expression EXPR with short-circuit boolean
2839 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2840 predicate apart into the equivalent sequence of conditionals. */
2843 shortcut_cond_expr (tree expr
)
2845 tree pred
= TREE_OPERAND (expr
, 0);
2846 tree then_
= TREE_OPERAND (expr
, 1);
2847 tree else_
= TREE_OPERAND (expr
, 2);
2848 tree true_label
, false_label
, end_label
, t
;
2850 tree
*false_label_p
;
2851 bool emit_end
, emit_false
, jump_over_else
;
2852 bool then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2853 bool else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2855 /* First do simple transformations. */
2858 /* If there is no 'else', turn
2861 if (a) if (b) then c. */
2862 while (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2864 /* Keep the original source location on the first 'if'. */
2865 location_t locus
= EXPR_LOC_OR_HERE (expr
);
2866 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2867 /* Set the source location of the && on the second 'if'. */
2868 if (EXPR_HAS_LOCATION (pred
))
2869 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2870 then_
= shortcut_cond_expr (expr
);
2871 then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2872 pred
= TREE_OPERAND (pred
, 0);
2873 expr
= build3 (COND_EXPR
, void_type_node
, pred
, then_
, NULL_TREE
);
2874 SET_EXPR_LOCATION (expr
, locus
);
2880 /* If there is no 'then', turn
2883 if (a); else if (b); else d. */
2884 while (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2886 /* Keep the original source location on the first 'if'. */
2887 location_t locus
= EXPR_LOC_OR_HERE (expr
);
2888 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2889 /* Set the source location of the || on the second 'if'. */
2890 if (EXPR_HAS_LOCATION (pred
))
2891 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2892 else_
= shortcut_cond_expr (expr
);
2893 else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2894 pred
= TREE_OPERAND (pred
, 0);
2895 expr
= build3 (COND_EXPR
, void_type_node
, pred
, NULL_TREE
, else_
);
2896 SET_EXPR_LOCATION (expr
, locus
);
2900 /* If we're done, great. */
2901 if (TREE_CODE (pred
) != TRUTH_ANDIF_EXPR
2902 && TREE_CODE (pred
) != TRUTH_ORIF_EXPR
)
2905 /* Otherwise we need to mess with gotos. Change
2908 if (a); else goto no;
2911 and recursively gimplify the condition. */
2913 true_label
= false_label
= end_label
= NULL_TREE
;
2915 /* If our arms just jump somewhere, hijack those labels so we don't
2916 generate jumps to jumps. */
2919 && TREE_CODE (then_
) == GOTO_EXPR
2920 && TREE_CODE (GOTO_DESTINATION (then_
)) == LABEL_DECL
)
2922 true_label
= GOTO_DESTINATION (then_
);
2928 && TREE_CODE (else_
) == GOTO_EXPR
2929 && TREE_CODE (GOTO_DESTINATION (else_
)) == LABEL_DECL
)
2931 false_label
= GOTO_DESTINATION (else_
);
2936 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2938 true_label_p
= &true_label
;
2940 true_label_p
= NULL
;
2942 /* The 'else' branch also needs a label if it contains interesting code. */
2943 if (false_label
|| else_se
)
2944 false_label_p
= &false_label
;
2946 false_label_p
= NULL
;
2948 /* If there was nothing else in our arms, just forward the label(s). */
2949 if (!then_se
&& !else_se
)
2950 return shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2951 EXPR_LOC_OR_HERE (expr
));
2953 /* If our last subexpression already has a terminal label, reuse it. */
2955 t
= expr_last (else_
);
2957 t
= expr_last (then_
);
2960 if (t
&& TREE_CODE (t
) == LABEL_EXPR
)
2961 end_label
= LABEL_EXPR_LABEL (t
);
2963 /* If we don't care about jumping to the 'else' branch, jump to the end
2964 if the condition is false. */
2966 false_label_p
= &end_label
;
2968 /* We only want to emit these labels if we aren't hijacking them. */
2969 emit_end
= (end_label
== NULL_TREE
);
2970 emit_false
= (false_label
== NULL_TREE
);
2972 /* We only emit the jump over the else clause if we have to--if the
2973 then clause may fall through. Otherwise we can wind up with a
2974 useless jump and a useless label at the end of gimplified code,
2975 which will cause us to think that this conditional as a whole
2976 falls through even if it doesn't. If we then inline a function
2977 which ends with such a condition, that can cause us to issue an
2978 inappropriate warning about control reaching the end of a
2979 non-void function. */
2980 jump_over_else
= block_may_fallthru (then_
);
2982 pred
= shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2983 EXPR_LOC_OR_HERE (expr
));
2986 append_to_statement_list (pred
, &expr
);
2988 append_to_statement_list (then_
, &expr
);
2993 tree last
= expr_last (expr
);
2994 t
= build_and_jump (&end_label
);
2995 if (EXPR_HAS_LOCATION (last
))
2996 SET_EXPR_LOCATION (t
, EXPR_LOCATION (last
));
2997 append_to_statement_list (t
, &expr
);
3001 t
= build1 (LABEL_EXPR
, void_type_node
, false_label
);
3002 append_to_statement_list (t
, &expr
);
3004 append_to_statement_list (else_
, &expr
);
3006 if (emit_end
&& end_label
)
3008 t
= build1 (LABEL_EXPR
, void_type_node
, end_label
);
3009 append_to_statement_list (t
, &expr
);
3015 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
3018 gimple_boolify (tree expr
)
3020 tree type
= TREE_TYPE (expr
);
3021 location_t loc
= EXPR_LOCATION (expr
);
3023 if (TREE_CODE (expr
) == NE_EXPR
3024 && TREE_CODE (TREE_OPERAND (expr
, 0)) == CALL_EXPR
3025 && integer_zerop (TREE_OPERAND (expr
, 1)))
3027 tree call
= TREE_OPERAND (expr
, 0);
3028 tree fn
= get_callee_fndecl (call
);
3030 /* For __builtin_expect ((long) (x), y) recurse into x as well
3031 if x is truth_value_p. */
3033 && DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
3034 && DECL_FUNCTION_CODE (fn
) == BUILT_IN_EXPECT
3035 && call_expr_nargs (call
) == 2)
3037 tree arg
= CALL_EXPR_ARG (call
, 0);
3040 if (TREE_CODE (arg
) == NOP_EXPR
3041 && TREE_TYPE (arg
) == TREE_TYPE (call
))
3042 arg
= TREE_OPERAND (arg
, 0);
3043 if (truth_value_p (TREE_CODE (arg
)))
3045 arg
= gimple_boolify (arg
);
3046 CALL_EXPR_ARG (call
, 0)
3047 = fold_convert_loc (loc
, TREE_TYPE (call
), arg
);
3053 switch (TREE_CODE (expr
))
3055 case TRUTH_AND_EXPR
:
3057 case TRUTH_XOR_EXPR
:
3058 case TRUTH_ANDIF_EXPR
:
3059 case TRUTH_ORIF_EXPR
:
3060 /* Also boolify the arguments of truth exprs. */
3061 TREE_OPERAND (expr
, 1) = gimple_boolify (TREE_OPERAND (expr
, 1));
3064 case TRUTH_NOT_EXPR
:
3065 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3067 /* These expressions always produce boolean results. */
3068 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3069 TREE_TYPE (expr
) = boolean_type_node
;
3073 if (COMPARISON_CLASS_P (expr
))
3075 /* There expressions always prduce boolean results. */
3076 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3077 TREE_TYPE (expr
) = boolean_type_node
;
3080 /* Other expressions that get here must have boolean values, but
3081 might need to be converted to the appropriate mode. */
3082 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
3084 return fold_convert_loc (loc
, boolean_type_node
, expr
);
3088 /* Given a conditional expression *EXPR_P without side effects, gimplify
3089 its operands. New statements are inserted to PRE_P. */
3091 static enum gimplify_status
3092 gimplify_pure_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
)
3094 tree expr
= *expr_p
, cond
;
3095 enum gimplify_status ret
, tret
;
3096 enum tree_code code
;
3098 cond
= gimple_boolify (COND_EXPR_COND (expr
));
3100 /* We need to handle && and || specially, as their gimplification
3101 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
3102 code
= TREE_CODE (cond
);
3103 if (code
== TRUTH_ANDIF_EXPR
)
3104 TREE_SET_CODE (cond
, TRUTH_AND_EXPR
);
3105 else if (code
== TRUTH_ORIF_EXPR
)
3106 TREE_SET_CODE (cond
, TRUTH_OR_EXPR
);
3107 ret
= gimplify_expr (&cond
, pre_p
, NULL
, is_gimple_condexpr
, fb_rvalue
);
3108 COND_EXPR_COND (*expr_p
) = cond
;
3110 tret
= gimplify_expr (&COND_EXPR_THEN (expr
), pre_p
, NULL
,
3111 is_gimple_val
, fb_rvalue
);
3112 ret
= MIN (ret
, tret
);
3113 tret
= gimplify_expr (&COND_EXPR_ELSE (expr
), pre_p
, NULL
,
3114 is_gimple_val
, fb_rvalue
);
3116 return MIN (ret
, tret
);
3119 /* Return true if evaluating EXPR could trap.
3120 EXPR is GENERIC, while tree_could_trap_p can be called
3124 generic_expr_could_trap_p (tree expr
)
3128 if (!expr
|| is_gimple_val (expr
))
3131 if (!EXPR_P (expr
) || tree_could_trap_p (expr
))
3134 n
= TREE_OPERAND_LENGTH (expr
);
3135 for (i
= 0; i
< n
; i
++)
3136 if (generic_expr_could_trap_p (TREE_OPERAND (expr
, i
)))
3142 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3151 The second form is used when *EXPR_P is of type void.
3153 PRE_P points to the list where side effects that must happen before
3154 *EXPR_P should be stored. */
3156 static enum gimplify_status
3157 gimplify_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
, fallback_t fallback
)
3159 tree expr
= *expr_p
;
3160 tree type
= TREE_TYPE (expr
);
3161 location_t loc
= EXPR_LOCATION (expr
);
3162 tree tmp
, arm1
, arm2
;
3163 enum gimplify_status ret
;
3164 tree label_true
, label_false
, label_cont
;
3165 bool have_then_clause_p
, have_else_clause_p
;
3167 enum tree_code pred_code
;
3168 gimple_seq seq
= NULL
;
3170 /* If this COND_EXPR has a value, copy the values into a temporary within
3172 if (!VOID_TYPE_P (type
))
3174 tree then_
= TREE_OPERAND (expr
, 1), else_
= TREE_OPERAND (expr
, 2);
3177 /* If either an rvalue is ok or we do not require an lvalue, create the
3178 temporary. But we cannot do that if the type is addressable. */
3179 if (((fallback
& fb_rvalue
) || !(fallback
& fb_lvalue
))
3180 && !TREE_ADDRESSABLE (type
))
3182 if (gimplify_ctxp
->allow_rhs_cond_expr
3183 /* If either branch has side effects or could trap, it can't be
3184 evaluated unconditionally. */
3185 && !TREE_SIDE_EFFECTS (then_
)
3186 && !generic_expr_could_trap_p (then_
)
3187 && !TREE_SIDE_EFFECTS (else_
)
3188 && !generic_expr_could_trap_p (else_
))
3189 return gimplify_pure_cond_expr (expr_p
, pre_p
);
3191 tmp
= create_tmp_var (type
, "iftmp");
3195 /* Otherwise, only create and copy references to the values. */
3198 type
= build_pointer_type (type
);
3200 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3201 then_
= build_fold_addr_expr_loc (loc
, then_
);
3203 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3204 else_
= build_fold_addr_expr_loc (loc
, else_
);
3207 = build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0), then_
, else_
);
3209 tmp
= create_tmp_var (type
, "iftmp");
3210 result
= build_simple_mem_ref_loc (loc
, tmp
);
3213 /* Build the new then clause, `tmp = then_;'. But don't build the
3214 assignment if the value is void; in C++ it can be if it's a throw. */
3215 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3216 TREE_OPERAND (expr
, 1) = build2 (MODIFY_EXPR
, type
, tmp
, then_
);
3218 /* Similarly, build the new else clause, `tmp = else_;'. */
3219 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3220 TREE_OPERAND (expr
, 2) = build2 (MODIFY_EXPR
, type
, tmp
, else_
);
3222 TREE_TYPE (expr
) = void_type_node
;
3223 recalculate_side_effects (expr
);
3225 /* Move the COND_EXPR to the prequeue. */
3226 gimplify_stmt (&expr
, pre_p
);
3232 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
3233 STRIP_TYPE_NOPS (TREE_OPERAND (expr
, 0));
3234 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == COMPOUND_EXPR
)
3235 gimplify_compound_expr (&TREE_OPERAND (expr
, 0), pre_p
, true);
3237 /* Make sure the condition has BOOLEAN_TYPE. */
3238 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3240 /* Break apart && and || conditions. */
3241 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ANDIF_EXPR
3242 || TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ORIF_EXPR
)
3244 expr
= shortcut_cond_expr (expr
);
3246 if (expr
!= *expr_p
)
3250 /* We can't rely on gimplify_expr to re-gimplify the expanded
3251 form properly, as cleanups might cause the target labels to be
3252 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3253 set up a conditional context. */
3254 gimple_push_condition ();
3255 gimplify_stmt (expr_p
, &seq
);
3256 gimple_pop_condition (pre_p
);
3257 gimple_seq_add_seq (pre_p
, seq
);
3263 /* Now do the normal gimplification. */
3265 /* Gimplify condition. */
3266 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, NULL
, is_gimple_condexpr
,
3268 if (ret
== GS_ERROR
)
3270 gcc_assert (TREE_OPERAND (expr
, 0) != NULL_TREE
);
3272 gimple_push_condition ();
3274 have_then_clause_p
= have_else_clause_p
= false;
3275 if (TREE_OPERAND (expr
, 1) != NULL
3276 && TREE_CODE (TREE_OPERAND (expr
, 1)) == GOTO_EXPR
3277 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 1))) == LABEL_DECL
3278 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 1)))
3279 == current_function_decl
)
3280 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3281 have different locations, otherwise we end up with incorrect
3282 location information on the branches. */
3284 || !EXPR_HAS_LOCATION (expr
)
3285 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 1))
3286 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 1))))
3288 label_true
= GOTO_DESTINATION (TREE_OPERAND (expr
, 1));
3289 have_then_clause_p
= true;
3292 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
3293 if (TREE_OPERAND (expr
, 2) != NULL
3294 && TREE_CODE (TREE_OPERAND (expr
, 2)) == GOTO_EXPR
3295 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 2))) == LABEL_DECL
3296 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 2)))
3297 == current_function_decl
)
3298 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3299 have different locations, otherwise we end up with incorrect
3300 location information on the branches. */
3302 || !EXPR_HAS_LOCATION (expr
)
3303 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 2))
3304 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 2))))
3306 label_false
= GOTO_DESTINATION (TREE_OPERAND (expr
, 2));
3307 have_else_clause_p
= true;
3310 label_false
= create_artificial_label (UNKNOWN_LOCATION
);
3312 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr
), &pred_code
, &arm1
,
3315 gimple_cond
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
,
3318 gimplify_seq_add_stmt (&seq
, gimple_cond
);
3319 label_cont
= NULL_TREE
;
3320 if (!have_then_clause_p
)
3322 /* For if (...) {} else { code; } put label_true after
3324 if (TREE_OPERAND (expr
, 1) == NULL_TREE
3325 && !have_else_clause_p
3326 && TREE_OPERAND (expr
, 2) != NULL_TREE
)
3327 label_cont
= label_true
;
3330 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_true
));
3331 have_then_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 1), &seq
);
3332 /* For if (...) { code; } else {} or
3333 if (...) { code; } else goto label; or
3334 if (...) { code; return; } else { ... }
3335 label_cont isn't needed. */
3336 if (!have_else_clause_p
3337 && TREE_OPERAND (expr
, 2) != NULL_TREE
3338 && gimple_seq_may_fallthru (seq
))
3341 label_cont
= create_artificial_label (UNKNOWN_LOCATION
);
3343 g
= gimple_build_goto (label_cont
);
3345 /* GIMPLE_COND's are very low level; they have embedded
3346 gotos. This particular embedded goto should not be marked
3347 with the location of the original COND_EXPR, as it would
3348 correspond to the COND_EXPR's condition, not the ELSE or the
3349 THEN arms. To avoid marking it with the wrong location, flag
3350 it as "no location". */
3351 gimple_set_do_not_emit_location (g
);
3353 gimplify_seq_add_stmt (&seq
, g
);
3357 if (!have_else_clause_p
)
3359 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_false
));
3360 have_else_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 2), &seq
);
3363 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_cont
));
3365 gimple_pop_condition (pre_p
);
3366 gimple_seq_add_seq (pre_p
, seq
);
3368 if (ret
== GS_ERROR
)
3370 else if (have_then_clause_p
|| have_else_clause_p
)
3374 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3375 expr
= TREE_OPERAND (expr
, 0);
3376 gimplify_stmt (&expr
, pre_p
);
3383 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3384 to be marked addressable.
3386 We cannot rely on such an expression being directly markable if a temporary
3387 has been created by the gimplification. In this case, we create another
3388 temporary and initialize it with a copy, which will become a store after we
3389 mark it addressable. This can happen if the front-end passed us something
3390 that it could not mark addressable yet, like a Fortran pass-by-reference
3391 parameter (int) floatvar. */
3394 prepare_gimple_addressable (tree
*expr_p
, gimple_seq
*seq_p
)
3396 while (handled_component_p (*expr_p
))
3397 expr_p
= &TREE_OPERAND (*expr_p
, 0);
3398 if (is_gimple_reg (*expr_p
))
3399 *expr_p
= get_initialized_tmp_var (*expr_p
, seq_p
, NULL
);
3402 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3403 a call to __builtin_memcpy. */
3405 static enum gimplify_status
3406 gimplify_modify_expr_to_memcpy (tree
*expr_p
, tree size
, bool want_value
,
3409 tree t
, to
, to_ptr
, from
, from_ptr
;
3411 location_t loc
= EXPR_LOCATION (*expr_p
);
3413 to
= TREE_OPERAND (*expr_p
, 0);
3414 from
= TREE_OPERAND (*expr_p
, 1);
3416 /* Mark the RHS addressable. Beware that it may not be possible to do so
3417 directly if a temporary has been created by the gimplification. */
3418 prepare_gimple_addressable (&from
, seq_p
);
3420 mark_addressable (from
);
3421 from_ptr
= build_fold_addr_expr_loc (loc
, from
);
3422 gimplify_arg (&from_ptr
, seq_p
, loc
);
3424 mark_addressable (to
);
3425 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3426 gimplify_arg (&to_ptr
, seq_p
, loc
);
3428 t
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3430 gs
= gimple_build_call (t
, 3, to_ptr
, from_ptr
, size
);
3434 /* tmp = memcpy() */
3435 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3436 gimple_call_set_lhs (gs
, t
);
3437 gimplify_seq_add_stmt (seq_p
, gs
);
3439 *expr_p
= build_simple_mem_ref (t
);
3443 gimplify_seq_add_stmt (seq_p
, gs
);
3448 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3449 a call to __builtin_memset. In this case we know that the RHS is
3450 a CONSTRUCTOR with an empty element list. */
3452 static enum gimplify_status
3453 gimplify_modify_expr_to_memset (tree
*expr_p
, tree size
, bool want_value
,
3456 tree t
, from
, to
, to_ptr
;
3458 location_t loc
= EXPR_LOCATION (*expr_p
);
3460 /* Assert our assumptions, to abort instead of producing wrong code
3461 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3462 not be immediately exposed. */
3463 from
= TREE_OPERAND (*expr_p
, 1);
3464 if (TREE_CODE (from
) == WITH_SIZE_EXPR
)
3465 from
= TREE_OPERAND (from
, 0);
3467 gcc_assert (TREE_CODE (from
) == CONSTRUCTOR
3468 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from
)));
3471 to
= TREE_OPERAND (*expr_p
, 0);
3473 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3474 gimplify_arg (&to_ptr
, seq_p
, loc
);
3475 t
= builtin_decl_implicit (BUILT_IN_MEMSET
);
3477 gs
= gimple_build_call (t
, 3, to_ptr
, integer_zero_node
, size
);
3481 /* tmp = memset() */
3482 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3483 gimple_call_set_lhs (gs
, t
);
3484 gimplify_seq_add_stmt (seq_p
, gs
);
3486 *expr_p
= build1 (INDIRECT_REF
, TREE_TYPE (to
), t
);
3490 gimplify_seq_add_stmt (seq_p
, gs
);
3495 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3496 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3497 assignment. Return non-null if we detect a potential overlap. */
3499 struct gimplify_init_ctor_preeval_data
3501 /* The base decl of the lhs object. May be NULL, in which case we
3502 have to assume the lhs is indirect. */
3505 /* The alias set of the lhs object. */
3506 alias_set_type lhs_alias_set
;
3510 gimplify_init_ctor_preeval_1 (tree
*tp
, int *walk_subtrees
, void *xdata
)
3512 struct gimplify_init_ctor_preeval_data
*data
3513 = (struct gimplify_init_ctor_preeval_data
*) xdata
;
3516 /* If we find the base object, obviously we have overlap. */
3517 if (data
->lhs_base_decl
== t
)
3520 /* If the constructor component is indirect, determine if we have a
3521 potential overlap with the lhs. The only bits of information we
3522 have to go on at this point are addressability and alias sets. */
3523 if ((INDIRECT_REF_P (t
)
3524 || TREE_CODE (t
) == MEM_REF
)
3525 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3526 && alias_sets_conflict_p (data
->lhs_alias_set
, get_alias_set (t
)))
3529 /* If the constructor component is a call, determine if it can hide a
3530 potential overlap with the lhs through an INDIRECT_REF like above.
3531 ??? Ugh - this is completely broken. In fact this whole analysis
3532 doesn't look conservative. */
3533 if (TREE_CODE (t
) == CALL_EXPR
)
3535 tree type
, fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t
)));
3537 for (type
= TYPE_ARG_TYPES (fntype
); type
; type
= TREE_CHAIN (type
))
3538 if (POINTER_TYPE_P (TREE_VALUE (type
))
3539 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3540 && alias_sets_conflict_p (data
->lhs_alias_set
,
3542 (TREE_TYPE (TREE_VALUE (type
)))))
3546 if (IS_TYPE_OR_DECL_P (t
))
3551 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3552 force values that overlap with the lhs (as described by *DATA)
3553 into temporaries. */
3556 gimplify_init_ctor_preeval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3557 struct gimplify_init_ctor_preeval_data
*data
)
3559 enum gimplify_status one
;
3561 /* If the value is constant, then there's nothing to pre-evaluate. */
3562 if (TREE_CONSTANT (*expr_p
))
3564 /* Ensure it does not have side effects, it might contain a reference to
3565 the object we're initializing. */
3566 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p
));
3570 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3571 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p
)))
3574 /* Recurse for nested constructors. */
3575 if (TREE_CODE (*expr_p
) == CONSTRUCTOR
)
3577 unsigned HOST_WIDE_INT ix
;
3578 constructor_elt
*ce
;
3579 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (*expr_p
);
3581 FOR_EACH_VEC_SAFE_ELT (v
, ix
, ce
)
3582 gimplify_init_ctor_preeval (&ce
->value
, pre_p
, post_p
, data
);
3587 /* If this is a variable sized type, we must remember the size. */
3588 maybe_with_size_expr (expr_p
);
3590 /* Gimplify the constructor element to something appropriate for the rhs
3591 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3592 the gimplifier will consider this a store to memory. Doing this
3593 gimplification now means that we won't have to deal with complicated
3594 language-specific trees, nor trees like SAVE_EXPR that can induce
3595 exponential search behavior. */
3596 one
= gimplify_expr (expr_p
, pre_p
, post_p
, is_gimple_mem_rhs
, fb_rvalue
);
3597 if (one
== GS_ERROR
)
3603 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3604 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3605 always be true for all scalars, since is_gimple_mem_rhs insists on a
3606 temporary variable for them. */
3607 if (DECL_P (*expr_p
))
3610 /* If this is of variable size, we have no choice but to assume it doesn't
3611 overlap since we can't make a temporary for it. */
3612 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p
))) != INTEGER_CST
)
3615 /* Otherwise, we must search for overlap ... */
3616 if (!walk_tree (expr_p
, gimplify_init_ctor_preeval_1
, data
, NULL
))
3619 /* ... and if found, force the value into a temporary. */
3620 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
3623 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3624 a RANGE_EXPR in a CONSTRUCTOR for an array.
3628 object[var] = value;
3635 We increment var _after_ the loop exit check because we might otherwise
3636 fail if upper == TYPE_MAX_VALUE (type for upper).
3638 Note that we never have to deal with SAVE_EXPRs here, because this has
3639 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3641 static void gimplify_init_ctor_eval (tree
, vec
<constructor_elt
, va_gc
> *,
3642 gimple_seq
*, bool);
3645 gimplify_init_ctor_eval_range (tree object
, tree lower
, tree upper
,
3646 tree value
, tree array_elt_type
,
3647 gimple_seq
*pre_p
, bool cleared
)
3649 tree loop_entry_label
, loop_exit_label
, fall_thru_label
;
3650 tree var
, var_type
, cref
, tmp
;
3652 loop_entry_label
= create_artificial_label (UNKNOWN_LOCATION
);
3653 loop_exit_label
= create_artificial_label (UNKNOWN_LOCATION
);
3654 fall_thru_label
= create_artificial_label (UNKNOWN_LOCATION
);
3656 /* Create and initialize the index variable. */
3657 var_type
= TREE_TYPE (upper
);
3658 var
= create_tmp_var (var_type
, NULL
);
3659 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, lower
));
3661 /* Add the loop entry label. */
3662 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_entry_label
));
3664 /* Build the reference. */
3665 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3666 var
, NULL_TREE
, NULL_TREE
);
3668 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3669 the store. Otherwise just assign value to the reference. */
3671 if (TREE_CODE (value
) == CONSTRUCTOR
)
3672 /* NB we might have to call ourself recursively through
3673 gimplify_init_ctor_eval if the value is a constructor. */
3674 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3677 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (cref
, value
));
3679 /* We exit the loop when the index var is equal to the upper bound. */
3680 gimplify_seq_add_stmt (pre_p
,
3681 gimple_build_cond (EQ_EXPR
, var
, upper
,
3682 loop_exit_label
, fall_thru_label
));
3684 gimplify_seq_add_stmt (pre_p
, gimple_build_label (fall_thru_label
));
3686 /* Otherwise, increment the index var... */
3687 tmp
= build2 (PLUS_EXPR
, var_type
, var
,
3688 fold_convert (var_type
, integer_one_node
));
3689 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, tmp
));
3691 /* ...and jump back to the loop entry. */
3692 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (loop_entry_label
));
3694 /* Add the loop exit label. */
3695 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_exit_label
));
3698 /* Return true if FDECL is accessing a field that is zero sized. */
3701 zero_sized_field_decl (const_tree fdecl
)
3703 if (TREE_CODE (fdecl
) == FIELD_DECL
&& DECL_SIZE (fdecl
)
3704 && integer_zerop (DECL_SIZE (fdecl
)))
3709 /* Return true if TYPE is zero sized. */
3712 zero_sized_type (const_tree type
)
3714 if (AGGREGATE_TYPE_P (type
) && TYPE_SIZE (type
)
3715 && integer_zerop (TYPE_SIZE (type
)))
3720 /* A subroutine of gimplify_init_constructor. Generate individual
3721 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3722 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3723 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3727 gimplify_init_ctor_eval (tree object
, vec
<constructor_elt
, va_gc
> *elts
,
3728 gimple_seq
*pre_p
, bool cleared
)
3730 tree array_elt_type
= NULL
;
3731 unsigned HOST_WIDE_INT ix
;
3732 tree purpose
, value
;
3734 if (TREE_CODE (TREE_TYPE (object
)) == ARRAY_TYPE
)
3735 array_elt_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object
)));
3737 FOR_EACH_CONSTRUCTOR_ELT (elts
, ix
, purpose
, value
)
3741 /* NULL values are created above for gimplification errors. */
3745 if (cleared
&& initializer_zerop (value
))
3748 /* ??? Here's to hoping the front end fills in all of the indices,
3749 so we don't have to figure out what's missing ourselves. */
3750 gcc_assert (purpose
);
3752 /* Skip zero-sized fields, unless value has side-effects. This can
3753 happen with calls to functions returning a zero-sized type, which
3754 we shouldn't discard. As a number of downstream passes don't
3755 expect sets of zero-sized fields, we rely on the gimplification of
3756 the MODIFY_EXPR we make below to drop the assignment statement. */
3757 if (! TREE_SIDE_EFFECTS (value
) && zero_sized_field_decl (purpose
))
3760 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3762 if (TREE_CODE (purpose
) == RANGE_EXPR
)
3764 tree lower
= TREE_OPERAND (purpose
, 0);
3765 tree upper
= TREE_OPERAND (purpose
, 1);
3767 /* If the lower bound is equal to upper, just treat it as if
3768 upper was the index. */
3769 if (simple_cst_equal (lower
, upper
))
3773 gimplify_init_ctor_eval_range (object
, lower
, upper
, value
,
3774 array_elt_type
, pre_p
, cleared
);
3781 /* Do not use bitsizetype for ARRAY_REF indices. */
3782 if (TYPE_DOMAIN (TREE_TYPE (object
)))
3784 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object
))),
3786 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3787 purpose
, NULL_TREE
, NULL_TREE
);
3791 gcc_assert (TREE_CODE (purpose
) == FIELD_DECL
);
3792 cref
= build3 (COMPONENT_REF
, TREE_TYPE (purpose
),
3793 unshare_expr (object
), purpose
, NULL_TREE
);
3796 if (TREE_CODE (value
) == CONSTRUCTOR
3797 && TREE_CODE (TREE_TYPE (value
)) != VECTOR_TYPE
)
3798 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3802 tree init
= build2 (INIT_EXPR
, TREE_TYPE (cref
), cref
, value
);
3803 gimplify_and_add (init
, pre_p
);
3809 /* Return the appropriate RHS predicate for this LHS. */
3812 rhs_predicate_for (tree lhs
)
3814 if (is_gimple_reg (lhs
))
3815 return is_gimple_reg_rhs_or_call
;
3817 return is_gimple_mem_rhs_or_call
;
3820 /* Gimplify a C99 compound literal expression. This just means adding
3821 the DECL_EXPR before the current statement and using its anonymous
3824 static enum gimplify_status
3825 gimplify_compound_literal_expr (tree
*expr_p
, gimple_seq
*pre_p
,
3826 bool (*gimple_test_f
) (tree
),
3827 fallback_t fallback
)
3829 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p
);
3830 tree decl
= DECL_EXPR_DECL (decl_s
);
3831 tree init
= DECL_INITIAL (decl
);
3832 /* Mark the decl as addressable if the compound literal
3833 expression is addressable now, otherwise it is marked too late
3834 after we gimplify the initialization expression. */
3835 if (TREE_ADDRESSABLE (*expr_p
))
3836 TREE_ADDRESSABLE (decl
) = 1;
3837 /* Otherwise, if we don't need an lvalue and have a literal directly
3838 substitute it. Check if it matches the gimple predicate, as
3839 otherwise we'd generate a new temporary, and we can as well just
3840 use the decl we already have. */
3841 else if (!TREE_ADDRESSABLE (decl
)
3843 && (fallback
& fb_lvalue
) == 0
3844 && gimple_test_f (init
))
3850 /* Preliminarily mark non-addressed complex variables as eligible
3851 for promotion to gimple registers. We'll transform their uses
3853 if ((TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
3854 || TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
)
3855 && !TREE_THIS_VOLATILE (decl
)
3856 && !needs_to_live_in_memory (decl
))
3857 DECL_GIMPLE_REG_P (decl
) = 1;
3859 /* If the decl is not addressable, then it is being used in some
3860 expression or on the right hand side of a statement, and it can
3861 be put into a readonly data section. */
3862 if (!TREE_ADDRESSABLE (decl
) && (fallback
& fb_lvalue
) == 0)
3863 TREE_READONLY (decl
) = 1;
3865 /* This decl isn't mentioned in the enclosing block, so add it to the
3866 list of temps. FIXME it seems a bit of a kludge to say that
3867 anonymous artificial vars aren't pushed, but everything else is. */
3868 if (DECL_NAME (decl
) == NULL_TREE
&& !DECL_SEEN_IN_BIND_EXPR_P (decl
))
3869 gimple_add_tmp_var (decl
);
3871 gimplify_and_add (decl_s
, pre_p
);
3876 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3877 return a new CONSTRUCTOR if something changed. */
3880 optimize_compound_literals_in_ctor (tree orig_ctor
)
3882 tree ctor
= orig_ctor
;
3883 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
3884 unsigned int idx
, num
= vec_safe_length (elts
);
3886 for (idx
= 0; idx
< num
; idx
++)
3888 tree value
= (*elts
)[idx
].value
;
3889 tree newval
= value
;
3890 if (TREE_CODE (value
) == CONSTRUCTOR
)
3891 newval
= optimize_compound_literals_in_ctor (value
);
3892 else if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
3894 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (value
);
3895 tree decl
= DECL_EXPR_DECL (decl_s
);
3896 tree init
= DECL_INITIAL (decl
);
3898 if (!TREE_ADDRESSABLE (value
)
3899 && !TREE_ADDRESSABLE (decl
)
3901 && TREE_CODE (init
) == CONSTRUCTOR
)
3902 newval
= optimize_compound_literals_in_ctor (init
);
3904 if (newval
== value
)
3907 if (ctor
== orig_ctor
)
3909 ctor
= copy_node (orig_ctor
);
3910 CONSTRUCTOR_ELTS (ctor
) = vec_safe_copy (elts
);
3911 elts
= CONSTRUCTOR_ELTS (ctor
);
3913 (*elts
)[idx
].value
= newval
;
3918 /* A subroutine of gimplify_modify_expr. Break out elements of a
3919 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3921 Note that we still need to clear any elements that don't have explicit
3922 initializers, so if not all elements are initialized we keep the
3923 original MODIFY_EXPR, we just remove all of the constructor elements.
3925 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3926 GS_ERROR if we would have to create a temporary when gimplifying
3927 this constructor. Otherwise, return GS_OK.
3929 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3931 static enum gimplify_status
3932 gimplify_init_constructor (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3933 bool want_value
, bool notify_temp_creation
)
3935 tree object
, ctor
, type
;
3936 enum gimplify_status ret
;
3937 vec
<constructor_elt
, va_gc
> *elts
;
3939 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == CONSTRUCTOR
);
3941 if (!notify_temp_creation
)
3943 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
3944 is_gimple_lvalue
, fb_lvalue
);
3945 if (ret
== GS_ERROR
)
3949 object
= TREE_OPERAND (*expr_p
, 0);
3950 ctor
= TREE_OPERAND (*expr_p
, 1) =
3951 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p
, 1));
3952 type
= TREE_TYPE (ctor
);
3953 elts
= CONSTRUCTOR_ELTS (ctor
);
3956 switch (TREE_CODE (type
))
3960 case QUAL_UNION_TYPE
:
3963 struct gimplify_init_ctor_preeval_data preeval_data
;
3964 HOST_WIDE_INT num_ctor_elements
, num_nonzero_elements
;
3965 bool cleared
, complete_p
, valid_const_initializer
;
3967 /* Aggregate types must lower constructors to initialization of
3968 individual elements. The exception is that a CONSTRUCTOR node
3969 with no elements indicates zero-initialization of the whole. */
3970 if (vec_safe_is_empty (elts
))
3972 if (notify_temp_creation
)
3977 /* Fetch information about the constructor to direct later processing.
3978 We might want to make static versions of it in various cases, and
3979 can only do so if it known to be a valid constant initializer. */
3980 valid_const_initializer
3981 = categorize_ctor_elements (ctor
, &num_nonzero_elements
,
3982 &num_ctor_elements
, &complete_p
);
3984 /* If a const aggregate variable is being initialized, then it
3985 should never be a lose to promote the variable to be static. */
3986 if (valid_const_initializer
3987 && num_nonzero_elements
> 1
3988 && TREE_READONLY (object
)
3989 && TREE_CODE (object
) == VAR_DECL
3990 && (flag_merge_constants
>= 2 || !TREE_ADDRESSABLE (object
)))
3992 if (notify_temp_creation
)
3994 DECL_INITIAL (object
) = ctor
;
3995 TREE_STATIC (object
) = 1;
3996 if (!DECL_NAME (object
))
3997 DECL_NAME (object
) = create_tmp_var_name ("C");
3998 walk_tree (&DECL_INITIAL (object
), force_labels_r
, NULL
, NULL
);
4000 /* ??? C++ doesn't automatically append a .<number> to the
4001 assembler name, and even when it does, it looks at FE private
4002 data structures to figure out what that number should be,
4003 which are not set for this variable. I suppose this is
4004 important for local statics for inline functions, which aren't
4005 "local" in the object file sense. So in order to get a unique
4006 TU-local symbol, we must invoke the lhd version now. */
4007 lhd_set_decl_assembler_name (object
);
4009 *expr_p
= NULL_TREE
;
4013 /* If there are "lots" of initialized elements, even discounting
4014 those that are not address constants (and thus *must* be
4015 computed at runtime), then partition the constructor into
4016 constant and non-constant parts. Block copy the constant
4017 parts in, then generate code for the non-constant parts. */
4018 /* TODO. There's code in cp/typeck.c to do this. */
4020 if (int_size_in_bytes (TREE_TYPE (ctor
)) < 0)
4021 /* store_constructor will ignore the clearing of variable-sized
4022 objects. Initializers for such objects must explicitly set
4023 every field that needs to be set. */
4025 else if (!complete_p
)
4026 /* If the constructor isn't complete, clear the whole object
4029 ??? This ought not to be needed. For any element not present
4030 in the initializer, we should simply set them to zero. Except
4031 we'd need to *find* the elements that are not present, and that
4032 requires trickery to avoid quadratic compile-time behavior in
4033 large cases or excessive memory use in small cases. */
4035 else if (num_ctor_elements
- num_nonzero_elements
4036 > CLEAR_RATIO (optimize_function_for_speed_p (cfun
))
4037 && num_nonzero_elements
< num_ctor_elements
/ 4)
4038 /* If there are "lots" of zeros, it's more efficient to clear
4039 the memory and then set the nonzero elements. */
4044 /* If there are "lots" of initialized elements, and all of them
4045 are valid address constants, then the entire initializer can
4046 be dropped to memory, and then memcpy'd out. Don't do this
4047 for sparse arrays, though, as it's more efficient to follow
4048 the standard CONSTRUCTOR behavior of memset followed by
4049 individual element initialization. Also don't do this for small
4050 all-zero initializers (which aren't big enough to merit
4051 clearing), and don't try to make bitwise copies of
4052 TREE_ADDRESSABLE types. */
4053 if (valid_const_initializer
4054 && !(cleared
|| num_nonzero_elements
== 0)
4055 && !TREE_ADDRESSABLE (type
))
4057 HOST_WIDE_INT size
= int_size_in_bytes (type
);
4060 /* ??? We can still get unbounded array types, at least
4061 from the C++ front end. This seems wrong, but attempt
4062 to work around it for now. */
4065 size
= int_size_in_bytes (TREE_TYPE (object
));
4067 TREE_TYPE (ctor
) = type
= TREE_TYPE (object
);
4070 /* Find the maximum alignment we can assume for the object. */
4071 /* ??? Make use of DECL_OFFSET_ALIGN. */
4072 if (DECL_P (object
))
4073 align
= DECL_ALIGN (object
);
4075 align
= TYPE_ALIGN (type
);
4077 /* Do a block move either if the size is so small as to make
4078 each individual move a sub-unit move on average, or if it
4079 is so large as to make individual moves inefficient. */
4081 && num_nonzero_elements
> 1
4082 && (size
< num_nonzero_elements
4083 || !can_move_by_pieces (size
, align
)))
4085 if (notify_temp_creation
)
4088 walk_tree (&ctor
, force_labels_r
, NULL
, NULL
);
4089 ctor
= tree_output_constant_def (ctor
);
4090 if (!useless_type_conversion_p (type
, TREE_TYPE (ctor
)))
4091 ctor
= build1 (VIEW_CONVERT_EXPR
, type
, ctor
);
4092 TREE_OPERAND (*expr_p
, 1) = ctor
;
4094 /* This is no longer an assignment of a CONSTRUCTOR, but
4095 we still may have processing to do on the LHS. So
4096 pretend we didn't do anything here to let that happen. */
4097 return GS_UNHANDLED
;
4101 /* If the target is volatile, we have non-zero elements and more than
4102 one field to assign, initialize the target from a temporary. */
4103 if (TREE_THIS_VOLATILE (object
)
4104 && !TREE_ADDRESSABLE (type
)
4105 && num_nonzero_elements
> 0
4106 && vec_safe_length (elts
) > 1)
4108 tree temp
= create_tmp_var (TYPE_MAIN_VARIANT (type
), NULL
);
4109 TREE_OPERAND (*expr_p
, 0) = temp
;
4110 *expr_p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*expr_p
),
4112 build2 (MODIFY_EXPR
, void_type_node
,
4117 if (notify_temp_creation
)
4120 /* If there are nonzero elements and if needed, pre-evaluate to capture
4121 elements overlapping with the lhs into temporaries. We must do this
4122 before clearing to fetch the values before they are zeroed-out. */
4123 if (num_nonzero_elements
> 0 && TREE_CODE (*expr_p
) != INIT_EXPR
)
4125 preeval_data
.lhs_base_decl
= get_base_address (object
);
4126 if (!DECL_P (preeval_data
.lhs_base_decl
))
4127 preeval_data
.lhs_base_decl
= NULL
;
4128 preeval_data
.lhs_alias_set
= get_alias_set (object
);
4130 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p
, 1),
4131 pre_p
, post_p
, &preeval_data
);
4136 /* Zap the CONSTRUCTOR element list, which simplifies this case.
4137 Note that we still have to gimplify, in order to handle the
4138 case of variable sized types. Avoid shared tree structures. */
4139 CONSTRUCTOR_ELTS (ctor
) = NULL
;
4140 TREE_SIDE_EFFECTS (ctor
) = 0;
4141 object
= unshare_expr (object
);
4142 gimplify_stmt (expr_p
, pre_p
);
4145 /* If we have not block cleared the object, or if there are nonzero
4146 elements in the constructor, add assignments to the individual
4147 scalar fields of the object. */
4148 if (!cleared
|| num_nonzero_elements
> 0)
4149 gimplify_init_ctor_eval (object
, elts
, pre_p
, cleared
);
4151 *expr_p
= NULL_TREE
;
4159 if (notify_temp_creation
)
4162 /* Extract the real and imaginary parts out of the ctor. */
4163 gcc_assert (elts
->length () == 2);
4164 r
= (*elts
)[0].value
;
4165 i
= (*elts
)[1].value
;
4166 if (r
== NULL
|| i
== NULL
)
4168 tree zero
= build_zero_cst (TREE_TYPE (type
));
4175 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
4176 represent creation of a complex value. */
4177 if (TREE_CONSTANT (r
) && TREE_CONSTANT (i
))
4179 ctor
= build_complex (type
, r
, i
);
4180 TREE_OPERAND (*expr_p
, 1) = ctor
;
4184 ctor
= build2 (COMPLEX_EXPR
, type
, r
, i
);
4185 TREE_OPERAND (*expr_p
, 1) = ctor
;
4186 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1),
4189 rhs_predicate_for (TREE_OPERAND (*expr_p
, 0)),
4197 unsigned HOST_WIDE_INT ix
;
4198 constructor_elt
*ce
;
4200 if (notify_temp_creation
)
4203 /* Go ahead and simplify constant constructors to VECTOR_CST. */
4204 if (TREE_CONSTANT (ctor
))
4206 bool constant_p
= true;
4209 /* Even when ctor is constant, it might contain non-*_CST
4210 elements, such as addresses or trapping values like
4211 1.0/0.0 - 1.0/0.0. Such expressions don't belong
4212 in VECTOR_CST nodes. */
4213 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
4214 if (!CONSTANT_CLASS_P (value
))
4222 TREE_OPERAND (*expr_p
, 1) = build_vector_from_ctor (type
, elts
);
4226 /* Don't reduce an initializer constant even if we can't
4227 make a VECTOR_CST. It won't do anything for us, and it'll
4228 prevent us from representing it as a single constant. */
4229 if (initializer_constant_valid_p (ctor
, type
))
4232 TREE_CONSTANT (ctor
) = 0;
4235 /* Vector types use CONSTRUCTOR all the way through gimple
4236 compilation as a general initializer. */
4237 FOR_EACH_VEC_SAFE_ELT (elts
, ix
, ce
)
4239 enum gimplify_status tret
;
4240 tret
= gimplify_expr (&ce
->value
, pre_p
, post_p
, is_gimple_val
,
4242 if (tret
== GS_ERROR
)
4245 if (!is_gimple_reg (TREE_OPERAND (*expr_p
, 0)))
4246 TREE_OPERAND (*expr_p
, 1) = get_formal_tmp_var (ctor
, pre_p
);
4251 /* So how did we get a CONSTRUCTOR for a scalar type? */
4255 if (ret
== GS_ERROR
)
4257 else if (want_value
)
4264 /* If we have gimplified both sides of the initializer but have
4265 not emitted an assignment, do so now. */
4268 tree lhs
= TREE_OPERAND (*expr_p
, 0);
4269 tree rhs
= TREE_OPERAND (*expr_p
, 1);
4270 gimple init
= gimple_build_assign (lhs
, rhs
);
4271 gimplify_seq_add_stmt (pre_p
, init
);
4279 /* Given a pointer value OP0, return a simplified version of an
4280 indirection through OP0, or NULL_TREE if no simplification is
4281 possible. Note that the resulting type may be different from
4282 the type pointed to in the sense that it is still compatible
4283 from the langhooks point of view. */
4286 gimple_fold_indirect_ref (tree t
)
4288 tree ptype
= TREE_TYPE (t
), type
= TREE_TYPE (ptype
);
4293 subtype
= TREE_TYPE (sub
);
4294 if (!POINTER_TYPE_P (subtype
))
4297 if (TREE_CODE (sub
) == ADDR_EXPR
)
4299 tree op
= TREE_OPERAND (sub
, 0);
4300 tree optype
= TREE_TYPE (op
);
4302 if (useless_type_conversion_p (type
, optype
))
4305 /* *(foo *)&fooarray => fooarray[0] */
4306 if (TREE_CODE (optype
) == ARRAY_TYPE
4307 && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype
))) == INTEGER_CST
4308 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4310 tree type_domain
= TYPE_DOMAIN (optype
);
4311 tree min_val
= size_zero_node
;
4312 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
4313 min_val
= TYPE_MIN_VALUE (type_domain
);
4314 if (TREE_CODE (min_val
) == INTEGER_CST
)
4315 return build4 (ARRAY_REF
, type
, op
, min_val
, NULL_TREE
, NULL_TREE
);
4317 /* *(foo *)&complexfoo => __real__ complexfoo */
4318 else if (TREE_CODE (optype
) == COMPLEX_TYPE
4319 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4320 return fold_build1 (REALPART_EXPR
, type
, op
);
4321 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
4322 else if (TREE_CODE (optype
) == VECTOR_TYPE
4323 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4325 tree part_width
= TYPE_SIZE (type
);
4326 tree index
= bitsize_int (0);
4327 return fold_build3 (BIT_FIELD_REF
, type
, op
, part_width
, index
);
4331 /* *(p + CST) -> ... */
4332 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
4333 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
4335 tree addr
= TREE_OPERAND (sub
, 0);
4336 tree off
= TREE_OPERAND (sub
, 1);
4340 addrtype
= TREE_TYPE (addr
);
4342 /* ((foo*)&vectorfoo)[1] -> BIT_FIELD_REF<vectorfoo,...> */
4343 if (TREE_CODE (addr
) == ADDR_EXPR
4344 && TREE_CODE (TREE_TYPE (addrtype
)) == VECTOR_TYPE
4345 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
)))
4346 && host_integerp (off
, 1))
4348 unsigned HOST_WIDE_INT offset
= tree_low_cst (off
, 1);
4349 tree part_width
= TYPE_SIZE (type
);
4350 unsigned HOST_WIDE_INT part_widthi
4351 = tree_low_cst (part_width
, 0) / BITS_PER_UNIT
;
4352 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
4353 tree index
= bitsize_int (indexi
);
4354 if (offset
/ part_widthi
4355 <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype
)))
4356 return fold_build3 (BIT_FIELD_REF
, type
, TREE_OPERAND (addr
, 0),
4360 /* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
4361 if (TREE_CODE (addr
) == ADDR_EXPR
4362 && TREE_CODE (TREE_TYPE (addrtype
)) == COMPLEX_TYPE
4363 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
))))
4365 tree size
= TYPE_SIZE_UNIT (type
);
4366 if (tree_int_cst_equal (size
, off
))
4367 return fold_build1 (IMAGPART_EXPR
, type
, TREE_OPERAND (addr
, 0));
4370 /* *(p + CST) -> MEM_REF <p, CST>. */
4371 if (TREE_CODE (addr
) != ADDR_EXPR
4372 || DECL_P (TREE_OPERAND (addr
, 0)))
4373 return fold_build2 (MEM_REF
, type
,
4375 build_int_cst_wide (ptype
,
4376 TREE_INT_CST_LOW (off
),
4377 TREE_INT_CST_HIGH (off
)));
4380 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
4381 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
4382 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (subtype
)))) == INTEGER_CST
4383 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (subtype
))))
4386 tree min_val
= size_zero_node
;
4388 sub
= gimple_fold_indirect_ref (sub
);
4390 sub
= build1 (INDIRECT_REF
, TREE_TYPE (subtype
), osub
);
4391 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
4392 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
4393 min_val
= TYPE_MIN_VALUE (type_domain
);
4394 if (TREE_CODE (min_val
) == INTEGER_CST
)
4395 return build4 (ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
, NULL_TREE
);
4401 /* Given a pointer value OP0, return a simplified version of an
4402 indirection through OP0, or NULL_TREE if no simplification is
4403 possible. This may only be applied to a rhs of an expression.
4404 Note that the resulting type may be different from the type pointed
4405 to in the sense that it is still compatible from the langhooks
4409 gimple_fold_indirect_ref_rhs (tree t
)
4411 return gimple_fold_indirect_ref (t
);
4414 /* Subroutine of gimplify_modify_expr to do simplifications of
4415 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4416 something changes. */
4418 static enum gimplify_status
4419 gimplify_modify_expr_rhs (tree
*expr_p
, tree
*from_p
, tree
*to_p
,
4420 gimple_seq
*pre_p
, gimple_seq
*post_p
,
4423 enum gimplify_status ret
= GS_UNHANDLED
;
4429 switch (TREE_CODE (*from_p
))
4432 /* If we're assigning from a read-only variable initialized with
4433 a constructor, do the direct assignment from the constructor,
4434 but only if neither source nor target are volatile since this
4435 latter assignment might end up being done on a per-field basis. */
4436 if (DECL_INITIAL (*from_p
)
4437 && TREE_READONLY (*from_p
)
4438 && !TREE_THIS_VOLATILE (*from_p
)
4439 && !TREE_THIS_VOLATILE (*to_p
)
4440 && TREE_CODE (DECL_INITIAL (*from_p
)) == CONSTRUCTOR
)
4442 tree old_from
= *from_p
;
4443 enum gimplify_status subret
;
4445 /* Move the constructor into the RHS. */
4446 *from_p
= unshare_expr (DECL_INITIAL (*from_p
));
4448 /* Let's see if gimplify_init_constructor will need to put
4450 subret
= gimplify_init_constructor (expr_p
, NULL
, NULL
,
4452 if (subret
== GS_ERROR
)
4454 /* If so, revert the change. */
4466 /* If we have code like
4470 where the type of "x" is a (possibly cv-qualified variant
4471 of "A"), treat the entire expression as identical to "x".
4472 This kind of code arises in C++ when an object is bound
4473 to a const reference, and if "x" is a TARGET_EXPR we want
4474 to take advantage of the optimization below. */
4475 bool volatile_p
= TREE_THIS_VOLATILE (*from_p
);
4476 tree t
= gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p
, 0));
4479 if (TREE_THIS_VOLATILE (t
) != volatile_p
)
4481 if (TREE_CODE_CLASS (TREE_CODE (t
)) == tcc_declaration
)
4482 t
= build_simple_mem_ref_loc (EXPR_LOCATION (*from_p
),
4483 build_fold_addr_expr (t
));
4484 if (REFERENCE_CLASS_P (t
))
4485 TREE_THIS_VOLATILE (t
) = volatile_p
;
4496 /* If we are initializing something from a TARGET_EXPR, strip the
4497 TARGET_EXPR and initialize it directly, if possible. This can't
4498 be done if the initializer is void, since that implies that the
4499 temporary is set in some non-trivial way.
4501 ??? What about code that pulls out the temp and uses it
4502 elsewhere? I think that such code never uses the TARGET_EXPR as
4503 an initializer. If I'm wrong, we'll die because the temp won't
4504 have any RTL. In that case, I guess we'll need to replace
4505 references somehow. */
4506 tree init
= TARGET_EXPR_INITIAL (*from_p
);
4509 && !VOID_TYPE_P (TREE_TYPE (init
)))
4519 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4521 gimplify_compound_expr (from_p
, pre_p
, true);
4527 /* If we already made some changes, let the front end have a
4528 crack at this before we break it down. */
4529 if (ret
!= GS_UNHANDLED
)
4531 /* If we're initializing from a CONSTRUCTOR, break this into
4532 individual MODIFY_EXPRs. */
4533 return gimplify_init_constructor (expr_p
, pre_p
, post_p
, want_value
,
4537 /* If we're assigning to a non-register type, push the assignment
4538 down into the branches. This is mandatory for ADDRESSABLE types,
4539 since we cannot generate temporaries for such, but it saves a
4540 copy in other cases as well. */
4541 if (!is_gimple_reg_type (TREE_TYPE (*from_p
)))
4543 /* This code should mirror the code in gimplify_cond_expr. */
4544 enum tree_code code
= TREE_CODE (*expr_p
);
4545 tree cond
= *from_p
;
4546 tree result
= *to_p
;
4548 ret
= gimplify_expr (&result
, pre_p
, post_p
,
4549 is_gimple_lvalue
, fb_lvalue
);
4550 if (ret
!= GS_ERROR
)
4553 if (TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
)
4554 TREE_OPERAND (cond
, 1)
4555 = build2 (code
, void_type_node
, result
,
4556 TREE_OPERAND (cond
, 1));
4557 if (TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
4558 TREE_OPERAND (cond
, 2)
4559 = build2 (code
, void_type_node
, unshare_expr (result
),
4560 TREE_OPERAND (cond
, 2));
4562 TREE_TYPE (cond
) = void_type_node
;
4563 recalculate_side_effects (cond
);
4567 gimplify_and_add (cond
, pre_p
);
4568 *expr_p
= unshare_expr (result
);
4577 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4578 return slot so that we don't generate a temporary. */
4579 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p
)
4580 && aggregate_value_p (*from_p
, *from_p
))
4584 if (!(rhs_predicate_for (*to_p
))(*from_p
))
4585 /* If we need a temporary, *to_p isn't accurate. */
4587 /* It's OK to use the return slot directly unless it's an NRV. */
4588 else if (TREE_CODE (*to_p
) == RESULT_DECL
4589 && DECL_NAME (*to_p
) == NULL_TREE
4590 && needs_to_live_in_memory (*to_p
))
4592 else if (is_gimple_reg_type (TREE_TYPE (*to_p
))
4593 || (DECL_P (*to_p
) && DECL_REGISTER (*to_p
)))
4594 /* Don't force regs into memory. */
4596 else if (TREE_CODE (*expr_p
) == INIT_EXPR
)
4597 /* It's OK to use the target directly if it's being
4600 else if (variably_modified_type_p (TREE_TYPE (*to_p
), NULL_TREE
))
4601 /* Always use the target and thus RSO for variable-sized types.
4602 GIMPLE cannot deal with a variable-sized assignment
4603 embedded in a call statement. */
4605 else if (TREE_CODE (*to_p
) != SSA_NAME
4606 && (!is_gimple_variable (*to_p
)
4607 || needs_to_live_in_memory (*to_p
)))
4608 /* Don't use the original target if it's already addressable;
4609 if its address escapes, and the called function uses the
4610 NRV optimization, a conforming program could see *to_p
4611 change before the called function returns; see c++/19317.
4612 When optimizing, the return_slot pass marks more functions
4613 as safe after we have escape info. */
4620 CALL_EXPR_RETURN_SLOT_OPT (*from_p
) = 1;
4621 mark_addressable (*to_p
);
4626 case WITH_SIZE_EXPR
:
4627 /* Likewise for calls that return an aggregate of non-constant size,
4628 since we would not be able to generate a temporary at all. */
4629 if (TREE_CODE (TREE_OPERAND (*from_p
, 0)) == CALL_EXPR
)
4631 *from_p
= TREE_OPERAND (*from_p
, 0);
4632 /* We don't change ret in this case because the
4633 WITH_SIZE_EXPR might have been added in
4634 gimplify_modify_expr, so returning GS_OK would lead to an
4640 /* If we're initializing from a container, push the initialization
4642 case CLEANUP_POINT_EXPR
:
4644 case STATEMENT_LIST
:
4646 tree wrap
= *from_p
;
4649 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_min_lval
,
4651 if (ret
!= GS_ERROR
)
4654 t
= voidify_wrapper_expr (wrap
, *expr_p
);
4655 gcc_assert (t
== *expr_p
);
4659 gimplify_and_add (wrap
, pre_p
);
4660 *expr_p
= unshare_expr (*to_p
);
4667 case COMPOUND_LITERAL_EXPR
:
4669 tree complit
= TREE_OPERAND (*expr_p
, 1);
4670 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (complit
);
4671 tree decl
= DECL_EXPR_DECL (decl_s
);
4672 tree init
= DECL_INITIAL (decl
);
4674 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4675 into struct T x = { 0, 1, 2 } if the address of the
4676 compound literal has never been taken. */
4677 if (!TREE_ADDRESSABLE (complit
)
4678 && !TREE_ADDRESSABLE (decl
)
4681 *expr_p
= copy_node (*expr_p
);
4682 TREE_OPERAND (*expr_p
, 1) = init
;
4697 /* Return true if T looks like a valid GIMPLE statement. */
4700 is_gimple_stmt (tree t
)
4702 const enum tree_code code
= TREE_CODE (t
);
4707 /* The only valid NOP_EXPR is the empty statement. */
4708 return IS_EMPTY_STMT (t
);
4712 /* These are only valid if they're void. */
4713 return TREE_TYPE (t
) == NULL
|| VOID_TYPE_P (TREE_TYPE (t
));
4719 case CASE_LABEL_EXPR
:
4720 case TRY_CATCH_EXPR
:
4721 case TRY_FINALLY_EXPR
:
4722 case EH_FILTER_EXPR
:
4725 case STATEMENT_LIST
:
4735 /* These are always void. */
4741 /* These are valid regardless of their type. */
4750 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4751 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4752 DECL_GIMPLE_REG_P set.
4754 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4755 other, unmodified part of the complex object just before the total store.
4756 As a consequence, if the object is still uninitialized, an undefined value
4757 will be loaded into a register, which may result in a spurious exception
4758 if the register is floating-point and the value happens to be a signaling
4759 NaN for example. Then the fully-fledged complex operations lowering pass
4760 followed by a DCE pass are necessary in order to fix things up. */
4762 static enum gimplify_status
4763 gimplify_modify_expr_complex_part (tree
*expr_p
, gimple_seq
*pre_p
,
4766 enum tree_code code
, ocode
;
4767 tree lhs
, rhs
, new_rhs
, other
, realpart
, imagpart
;
4769 lhs
= TREE_OPERAND (*expr_p
, 0);
4770 rhs
= TREE_OPERAND (*expr_p
, 1);
4771 code
= TREE_CODE (lhs
);
4772 lhs
= TREE_OPERAND (lhs
, 0);
4774 ocode
= code
== REALPART_EXPR
? IMAGPART_EXPR
: REALPART_EXPR
;
4775 other
= build1 (ocode
, TREE_TYPE (rhs
), lhs
);
4776 TREE_NO_WARNING (other
) = 1;
4777 other
= get_formal_tmp_var (other
, pre_p
);
4779 realpart
= code
== REALPART_EXPR
? rhs
: other
;
4780 imagpart
= code
== REALPART_EXPR
? other
: rhs
;
4782 if (TREE_CONSTANT (realpart
) && TREE_CONSTANT (imagpart
))
4783 new_rhs
= build_complex (TREE_TYPE (lhs
), realpart
, imagpart
);
4785 new_rhs
= build2 (COMPLEX_EXPR
, TREE_TYPE (lhs
), realpart
, imagpart
);
4787 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (lhs
, new_rhs
));
4788 *expr_p
= (want_value
) ? rhs
: NULL_TREE
;
4793 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4799 PRE_P points to the list where side effects that must happen before
4800 *EXPR_P should be stored.
4802 POST_P points to the list where side effects that must happen after
4803 *EXPR_P should be stored.
4805 WANT_VALUE is nonzero iff we want to use the value of this expression
4806 in another expression. */
4808 static enum gimplify_status
4809 gimplify_modify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4812 tree
*from_p
= &TREE_OPERAND (*expr_p
, 1);
4813 tree
*to_p
= &TREE_OPERAND (*expr_p
, 0);
4814 enum gimplify_status ret
= GS_UNHANDLED
;
4816 location_t loc
= EXPR_LOCATION (*expr_p
);
4817 gimple_stmt_iterator gsi
;
4819 gcc_assert (TREE_CODE (*expr_p
) == MODIFY_EXPR
4820 || TREE_CODE (*expr_p
) == INIT_EXPR
);
4822 /* Trying to simplify a clobber using normal logic doesn't work,
4823 so handle it here. */
4824 if (TREE_CLOBBER_P (*from_p
))
4826 gcc_assert (!want_value
&& TREE_CODE (*to_p
) == VAR_DECL
);
4827 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (*to_p
, *from_p
));
4832 /* Insert pointer conversions required by the middle-end that are not
4833 required by the frontend. This fixes middle-end type checking for
4834 for example gcc.dg/redecl-6.c. */
4835 if (POINTER_TYPE_P (TREE_TYPE (*to_p
)))
4837 STRIP_USELESS_TYPE_CONVERSION (*from_p
);
4838 if (!useless_type_conversion_p (TREE_TYPE (*to_p
), TREE_TYPE (*from_p
)))
4839 *from_p
= fold_convert_loc (loc
, TREE_TYPE (*to_p
), *from_p
);
4842 /* See if any simplifications can be done based on what the RHS is. */
4843 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4845 if (ret
!= GS_UNHANDLED
)
4848 /* For zero sized types only gimplify the left hand side and right hand
4849 side as statements and throw away the assignment. Do this after
4850 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4852 if (zero_sized_type (TREE_TYPE (*from_p
)) && !want_value
)
4854 gimplify_stmt (from_p
, pre_p
);
4855 gimplify_stmt (to_p
, pre_p
);
4856 *expr_p
= NULL_TREE
;
4860 /* If the value being copied is of variable width, compute the length
4861 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4862 before gimplifying any of the operands so that we can resolve any
4863 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4864 the size of the expression to be copied, not of the destination, so
4865 that is what we must do here. */
4866 maybe_with_size_expr (from_p
);
4868 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4869 if (ret
== GS_ERROR
)
4872 /* As a special case, we have to temporarily allow for assignments
4873 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4874 a toplevel statement, when gimplifying the GENERIC expression
4875 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4876 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4878 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4879 prevent gimplify_expr from trying to create a new temporary for
4880 foo's LHS, we tell it that it should only gimplify until it
4881 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4882 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4883 and all we need to do here is set 'a' to be its LHS. */
4884 ret
= gimplify_expr (from_p
, pre_p
, post_p
, rhs_predicate_for (*to_p
),
4886 if (ret
== GS_ERROR
)
4889 /* Now see if the above changed *from_p to something we handle specially. */
4890 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4892 if (ret
!= GS_UNHANDLED
)
4895 /* If we've got a variable sized assignment between two lvalues (i.e. does
4896 not involve a call), then we can make things a bit more straightforward
4897 by converting the assignment to memcpy or memset. */
4898 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
4900 tree from
= TREE_OPERAND (*from_p
, 0);
4901 tree size
= TREE_OPERAND (*from_p
, 1);
4903 if (TREE_CODE (from
) == CONSTRUCTOR
)
4904 return gimplify_modify_expr_to_memset (expr_p
, size
, want_value
, pre_p
);
4906 if (is_gimple_addressable (from
))
4909 return gimplify_modify_expr_to_memcpy (expr_p
, size
, want_value
,
4914 /* Transform partial stores to non-addressable complex variables into
4915 total stores. This allows us to use real instead of virtual operands
4916 for these variables, which improves optimization. */
4917 if ((TREE_CODE (*to_p
) == REALPART_EXPR
4918 || TREE_CODE (*to_p
) == IMAGPART_EXPR
)
4919 && is_gimple_reg (TREE_OPERAND (*to_p
, 0)))
4920 return gimplify_modify_expr_complex_part (expr_p
, pre_p
, want_value
);
4922 /* Try to alleviate the effects of the gimplification creating artificial
4923 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
4924 if (!gimplify_ctxp
->into_ssa
4925 && TREE_CODE (*from_p
) == VAR_DECL
4926 && DECL_IGNORED_P (*from_p
)
4928 && !DECL_IGNORED_P (*to_p
))
4930 if (!DECL_NAME (*from_p
) && DECL_NAME (*to_p
))
4932 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p
)));
4933 DECL_DEBUG_EXPR_IS_FROM (*from_p
) = 1;
4934 SET_DECL_DEBUG_EXPR (*from_p
, *to_p
);
4937 if (want_value
&& TREE_THIS_VOLATILE (*to_p
))
4938 *from_p
= get_initialized_tmp_var (*from_p
, pre_p
, post_p
);
4940 if (TREE_CODE (*from_p
) == CALL_EXPR
)
4942 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4943 instead of a GIMPLE_ASSIGN. */
4944 tree fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*from_p
));
4945 CALL_EXPR_FN (*from_p
) = TREE_OPERAND (CALL_EXPR_FN (*from_p
), 0);
4946 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p
));
4947 assign
= gimple_build_call_from_tree (*from_p
);
4948 gimple_call_set_fntype (assign
, TREE_TYPE (fnptrtype
));
4949 if (!gimple_call_noreturn_p (assign
))
4950 gimple_call_set_lhs (assign
, *to_p
);
4954 assign
= gimple_build_assign (*to_p
, *from_p
);
4955 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
4958 if (gimplify_ctxp
->into_ssa
&& is_gimple_reg (*to_p
))
4960 /* We should have got an SSA name from the start. */
4961 gcc_assert (TREE_CODE (*to_p
) == SSA_NAME
);
4964 gimplify_seq_add_stmt (pre_p
, assign
);
4965 gsi
= gsi_last (*pre_p
);
4970 *expr_p
= TREE_THIS_VOLATILE (*to_p
) ? *from_p
: unshare_expr (*to_p
);
4979 /* Gimplify a comparison between two variable-sized objects. Do this
4980 with a call to BUILT_IN_MEMCMP. */
4982 static enum gimplify_status
4983 gimplify_variable_sized_compare (tree
*expr_p
)
4985 location_t loc
= EXPR_LOCATION (*expr_p
);
4986 tree op0
= TREE_OPERAND (*expr_p
, 0);
4987 tree op1
= TREE_OPERAND (*expr_p
, 1);
4988 tree t
, arg
, dest
, src
, expr
;
4990 arg
= TYPE_SIZE_UNIT (TREE_TYPE (op0
));
4991 arg
= unshare_expr (arg
);
4992 arg
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg
, op0
);
4993 src
= build_fold_addr_expr_loc (loc
, op1
);
4994 dest
= build_fold_addr_expr_loc (loc
, op0
);
4995 t
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
4996 t
= build_call_expr_loc (loc
, t
, 3, dest
, src
, arg
);
4999 = build2 (TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), t
, integer_zero_node
);
5000 SET_EXPR_LOCATION (expr
, loc
);
5006 /* Gimplify a comparison between two aggregate objects of integral scalar
5007 mode as a comparison between the bitwise equivalent scalar values. */
5009 static enum gimplify_status
5010 gimplify_scalar_mode_aggregate_compare (tree
*expr_p
)
5012 location_t loc
= EXPR_LOCATION (*expr_p
);
5013 tree op0
= TREE_OPERAND (*expr_p
, 0);
5014 tree op1
= TREE_OPERAND (*expr_p
, 1);
5016 tree type
= TREE_TYPE (op0
);
5017 tree scalar_type
= lang_hooks
.types
.type_for_mode (TYPE_MODE (type
), 1);
5019 op0
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op0
);
5020 op1
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op1
);
5023 = fold_build2_loc (loc
, TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), op0
, op1
);
5028 /* Gimplify an expression sequence. This function gimplifies each
5029 expression and rewrites the original expression with the last
5030 expression of the sequence in GIMPLE form.
5032 PRE_P points to the list where the side effects for all the
5033 expressions in the sequence will be emitted.
5035 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
5037 static enum gimplify_status
5038 gimplify_compound_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
5044 tree
*sub_p
= &TREE_OPERAND (t
, 0);
5046 if (TREE_CODE (*sub_p
) == COMPOUND_EXPR
)
5047 gimplify_compound_expr (sub_p
, pre_p
, false);
5049 gimplify_stmt (sub_p
, pre_p
);
5051 t
= TREE_OPERAND (t
, 1);
5053 while (TREE_CODE (t
) == COMPOUND_EXPR
);
5060 gimplify_stmt (expr_p
, pre_p
);
5065 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
5066 gimplify. After gimplification, EXPR_P will point to a new temporary
5067 that holds the original value of the SAVE_EXPR node.
5069 PRE_P points to the list where side effects that must happen before
5070 *EXPR_P should be stored. */
5072 static enum gimplify_status
5073 gimplify_save_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5075 enum gimplify_status ret
= GS_ALL_DONE
;
5078 gcc_assert (TREE_CODE (*expr_p
) == SAVE_EXPR
);
5079 val
= TREE_OPERAND (*expr_p
, 0);
5081 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
5082 if (!SAVE_EXPR_RESOLVED_P (*expr_p
))
5084 /* The operand may be a void-valued expression such as SAVE_EXPRs
5085 generated by the Java frontend for class initialization. It is
5086 being executed only for its side-effects. */
5087 if (TREE_TYPE (val
) == void_type_node
)
5089 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
5090 is_gimple_stmt
, fb_none
);
5094 val
= get_initialized_tmp_var (val
, pre_p
, post_p
);
5096 TREE_OPERAND (*expr_p
, 0) = val
;
5097 SAVE_EXPR_RESOLVED_P (*expr_p
) = 1;
5105 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
5112 PRE_P points to the list where side effects that must happen before
5113 *EXPR_P should be stored.
5115 POST_P points to the list where side effects that must happen after
5116 *EXPR_P should be stored. */
5118 static enum gimplify_status
5119 gimplify_addr_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5121 tree expr
= *expr_p
;
5122 tree op0
= TREE_OPERAND (expr
, 0);
5123 enum gimplify_status ret
;
5124 location_t loc
= EXPR_LOCATION (*expr_p
);
5126 switch (TREE_CODE (op0
))
5130 /* Check if we are dealing with an expression of the form '&*ptr'.
5131 While the front end folds away '&*ptr' into 'ptr', these
5132 expressions may be generated internally by the compiler (e.g.,
5133 builtins like __builtin_va_end). */
5134 /* Caution: the silent array decomposition semantics we allow for
5135 ADDR_EXPR means we can't always discard the pair. */
5136 /* Gimplification of the ADDR_EXPR operand may drop
5137 cv-qualification conversions, so make sure we add them if
5140 tree op00
= TREE_OPERAND (op0
, 0);
5141 tree t_expr
= TREE_TYPE (expr
);
5142 tree t_op00
= TREE_TYPE (op00
);
5144 if (!useless_type_conversion_p (t_expr
, t_op00
))
5145 op00
= fold_convert_loc (loc
, TREE_TYPE (expr
), op00
);
5151 case VIEW_CONVERT_EXPR
:
5152 /* Take the address of our operand and then convert it to the type of
5155 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
5156 all clear. The impact of this transformation is even less clear. */
5158 /* If the operand is a useless conversion, look through it. Doing so
5159 guarantees that the ADDR_EXPR and its operand will remain of the
5161 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0
, 0)))
5162 op0
= TREE_OPERAND (op0
, 0);
5164 *expr_p
= fold_convert_loc (loc
, TREE_TYPE (expr
),
5165 build_fold_addr_expr_loc (loc
,
5166 TREE_OPERAND (op0
, 0)));
5171 /* We use fb_either here because the C frontend sometimes takes
5172 the address of a call that returns a struct; see
5173 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
5174 the implied temporary explicit. */
5176 /* Make the operand addressable. */
5177 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, post_p
,
5178 is_gimple_addressable
, fb_either
);
5179 if (ret
== GS_ERROR
)
5182 /* Then mark it. Beware that it may not be possible to do so directly
5183 if a temporary has been created by the gimplification. */
5184 prepare_gimple_addressable (&TREE_OPERAND (expr
, 0), pre_p
);
5186 op0
= TREE_OPERAND (expr
, 0);
5188 /* For various reasons, the gimplification of the expression
5189 may have made a new INDIRECT_REF. */
5190 if (TREE_CODE (op0
) == INDIRECT_REF
)
5191 goto do_indirect_ref
;
5193 mark_addressable (TREE_OPERAND (expr
, 0));
5195 /* The FEs may end up building ADDR_EXPRs early on a decl with
5196 an incomplete type. Re-build ADDR_EXPRs in canonical form
5198 if (!types_compatible_p (TREE_TYPE (op0
), TREE_TYPE (TREE_TYPE (expr
))))
5199 *expr_p
= build_fold_addr_expr (op0
);
5201 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
5202 recompute_tree_invariant_for_addr_expr (*expr_p
);
5204 /* If we re-built the ADDR_EXPR add a conversion to the original type
5206 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
5207 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
5215 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
5216 value; output operands should be a gimple lvalue. */
5218 static enum gimplify_status
5219 gimplify_asm_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5223 const char **oconstraints
;
5226 const char *constraint
;
5227 bool allows_mem
, allows_reg
, is_inout
;
5228 enum gimplify_status ret
, tret
;
5230 vec
<tree
, va_gc
> *inputs
;
5231 vec
<tree
, va_gc
> *outputs
;
5232 vec
<tree
, va_gc
> *clobbers
;
5233 vec
<tree
, va_gc
> *labels
;
5237 noutputs
= list_length (ASM_OUTPUTS (expr
));
5238 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
5246 link_next
= NULL_TREE
;
5247 for (i
= 0, link
= ASM_OUTPUTS (expr
); link
; ++i
, link
= link_next
)
5250 size_t constraint_len
;
5252 link_next
= TREE_CHAIN (link
);
5256 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5257 constraint_len
= strlen (constraint
);
5258 if (constraint_len
== 0)
5261 ok
= parse_output_constraint (&constraint
, i
, 0, 0,
5262 &allows_mem
, &allows_reg
, &is_inout
);
5269 if (!allows_reg
&& allows_mem
)
5270 mark_addressable (TREE_VALUE (link
));
5272 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5273 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
5274 fb_lvalue
| fb_mayfail
);
5275 if (tret
== GS_ERROR
)
5277 error ("invalid lvalue in asm output %d", i
);
5281 vec_safe_push (outputs
, link
);
5282 TREE_CHAIN (link
) = NULL_TREE
;
5286 /* An input/output operand. To give the optimizers more
5287 flexibility, split it into separate input and output
5292 /* Turn the in/out constraint into an output constraint. */
5293 char *p
= xstrdup (constraint
);
5295 TREE_VALUE (TREE_PURPOSE (link
)) = build_string (constraint_len
, p
);
5297 /* And add a matching input constraint. */
5300 sprintf (buf
, "%d", i
);
5302 /* If there are multiple alternatives in the constraint,
5303 handle each of them individually. Those that allow register
5304 will be replaced with operand number, the others will stay
5306 if (strchr (p
, ',') != NULL
)
5308 size_t len
= 0, buflen
= strlen (buf
);
5309 char *beg
, *end
, *str
, *dst
;
5313 end
= strchr (beg
, ',');
5315 end
= strchr (beg
, '\0');
5316 if ((size_t) (end
- beg
) < buflen
)
5319 len
+= end
- beg
+ 1;
5326 str
= (char *) alloca (len
);
5327 for (beg
= p
+ 1, dst
= str
;;)
5330 bool mem_p
, reg_p
, inout_p
;
5332 end
= strchr (beg
, ',');
5337 parse_output_constraint (&tem
, i
, 0, 0,
5338 &mem_p
, ®_p
, &inout_p
);
5343 memcpy (dst
, buf
, buflen
);
5352 memcpy (dst
, beg
, len
);
5361 input
= build_string (dst
- str
, str
);
5364 input
= build_string (strlen (buf
), buf
);
5367 input
= build_string (constraint_len
- 1, constraint
+ 1);
5371 input
= build_tree_list (build_tree_list (NULL_TREE
, input
),
5372 unshare_expr (TREE_VALUE (link
)));
5373 ASM_INPUTS (expr
) = chainon (ASM_INPUTS (expr
), input
);
5377 link_next
= NULL_TREE
;
5378 for (link
= ASM_INPUTS (expr
); link
; ++i
, link
= link_next
)
5380 link_next
= TREE_CHAIN (link
);
5381 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5382 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
5383 oconstraints
, &allows_mem
, &allows_reg
);
5385 /* If we can't make copies, we can only accept memory. */
5386 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link
))))
5392 error ("impossible constraint in %<asm%>");
5393 error ("non-memory input %d must stay in memory", i
);
5398 /* If the operand is a memory input, it should be an lvalue. */
5399 if (!allows_reg
&& allows_mem
)
5401 tree inputv
= TREE_VALUE (link
);
5402 STRIP_NOPS (inputv
);
5403 if (TREE_CODE (inputv
) == PREDECREMENT_EXPR
5404 || TREE_CODE (inputv
) == PREINCREMENT_EXPR
5405 || TREE_CODE (inputv
) == POSTDECREMENT_EXPR
5406 || TREE_CODE (inputv
) == POSTINCREMENT_EXPR
)
5407 TREE_VALUE (link
) = error_mark_node
;
5408 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5409 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
5410 mark_addressable (TREE_VALUE (link
));
5411 if (tret
== GS_ERROR
)
5413 if (EXPR_HAS_LOCATION (TREE_VALUE (link
)))
5414 input_location
= EXPR_LOCATION (TREE_VALUE (link
));
5415 error ("memory input %d is not directly addressable", i
);
5421 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5422 is_gimple_asm_val
, fb_rvalue
);
5423 if (tret
== GS_ERROR
)
5427 TREE_CHAIN (link
) = NULL_TREE
;
5428 vec_safe_push (inputs
, link
);
5431 for (link
= ASM_CLOBBERS (expr
); link
; ++i
, link
= TREE_CHAIN (link
))
5432 vec_safe_push (clobbers
, link
);
5434 for (link
= ASM_LABELS (expr
); link
; ++i
, link
= TREE_CHAIN (link
))
5435 vec_safe_push (labels
, link
);
5437 /* Do not add ASMs with errors to the gimple IL stream. */
5438 if (ret
!= GS_ERROR
)
5440 stmt
= gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr
)),
5441 inputs
, outputs
, clobbers
, labels
);
5443 gimple_asm_set_volatile (stmt
, ASM_VOLATILE_P (expr
));
5444 gimple_asm_set_input (stmt
, ASM_INPUT_P (expr
));
5446 gimplify_seq_add_stmt (pre_p
, stmt
);
5452 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
5453 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
5454 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
5455 return to this function.
5457 FIXME should we complexify the prequeue handling instead? Or use flags
5458 for all the cleanups and let the optimizer tighten them up? The current
5459 code seems pretty fragile; it will break on a cleanup within any
5460 non-conditional nesting. But any such nesting would be broken, anyway;
5461 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
5462 and continues out of it. We can do that at the RTL level, though, so
5463 having an optimizer to tighten up try/finally regions would be a Good
5466 static enum gimplify_status
5467 gimplify_cleanup_point_expr (tree
*expr_p
, gimple_seq
*pre_p
)
5469 gimple_stmt_iterator iter
;
5470 gimple_seq body_sequence
= NULL
;
5472 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
5474 /* We only care about the number of conditions between the innermost
5475 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5476 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5477 int old_conds
= gimplify_ctxp
->conditions
;
5478 gimple_seq old_cleanups
= gimplify_ctxp
->conditional_cleanups
;
5479 bool old_in_cleanup_point_expr
= gimplify_ctxp
->in_cleanup_point_expr
;
5480 gimplify_ctxp
->conditions
= 0;
5481 gimplify_ctxp
->conditional_cleanups
= NULL
;
5482 gimplify_ctxp
->in_cleanup_point_expr
= true;
5484 gimplify_stmt (&TREE_OPERAND (*expr_p
, 0), &body_sequence
);
5486 gimplify_ctxp
->conditions
= old_conds
;
5487 gimplify_ctxp
->conditional_cleanups
= old_cleanups
;
5488 gimplify_ctxp
->in_cleanup_point_expr
= old_in_cleanup_point_expr
;
5490 for (iter
= gsi_start (body_sequence
); !gsi_end_p (iter
); )
5492 gimple wce
= gsi_stmt (iter
);
5494 if (gimple_code (wce
) == GIMPLE_WITH_CLEANUP_EXPR
)
5496 if (gsi_one_before_end_p (iter
))
5498 /* Note that gsi_insert_seq_before and gsi_remove do not
5499 scan operands, unlike some other sequence mutators. */
5500 if (!gimple_wce_cleanup_eh_only (wce
))
5501 gsi_insert_seq_before_without_update (&iter
,
5502 gimple_wce_cleanup (wce
),
5504 gsi_remove (&iter
, true);
5511 enum gimple_try_flags kind
;
5513 if (gimple_wce_cleanup_eh_only (wce
))
5514 kind
= GIMPLE_TRY_CATCH
;
5516 kind
= GIMPLE_TRY_FINALLY
;
5517 seq
= gsi_split_seq_after (iter
);
5519 gtry
= gimple_build_try (seq
, gimple_wce_cleanup (wce
), kind
);
5520 /* Do not use gsi_replace here, as it may scan operands.
5521 We want to do a simple structural modification only. */
5522 gsi_set_stmt (&iter
, gtry
);
5523 iter
= gsi_start (gtry
->gimple_try
.eval
);
5530 gimplify_seq_add_seq (pre_p
, body_sequence
);
5543 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5544 is the cleanup action required. EH_ONLY is true if the cleanup should
5545 only be executed if an exception is thrown, not on normal exit. */
5548 gimple_push_cleanup (tree var
, tree cleanup
, bool eh_only
, gimple_seq
*pre_p
)
5551 gimple_seq cleanup_stmts
= NULL
;
5553 /* Errors can result in improperly nested cleanups. Which results in
5554 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5558 if (gimple_conditional_context ())
5560 /* If we're in a conditional context, this is more complex. We only
5561 want to run the cleanup if we actually ran the initialization that
5562 necessitates it, but we want to run it after the end of the
5563 conditional context. So we wrap the try/finally around the
5564 condition and use a flag to determine whether or not to actually
5565 run the destructor. Thus
5569 becomes (approximately)
5573 if (test) { A::A(temp); flag = 1; val = f(temp); }
5576 if (flag) A::~A(temp);
5580 tree flag
= create_tmp_var (boolean_type_node
, "cleanup");
5581 gimple ffalse
= gimple_build_assign (flag
, boolean_false_node
);
5582 gimple ftrue
= gimple_build_assign (flag
, boolean_true_node
);
5584 cleanup
= build3 (COND_EXPR
, void_type_node
, flag
, cleanup
, NULL
);
5585 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5586 wce
= gimple_build_wce (cleanup_stmts
);
5588 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, ffalse
);
5589 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
5590 gimplify_seq_add_stmt (pre_p
, ftrue
);
5592 /* Because of this manipulation, and the EH edges that jump
5593 threading cannot redirect, the temporary (VAR) will appear
5594 to be used uninitialized. Don't warn. */
5595 TREE_NO_WARNING (var
) = 1;
5599 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5600 wce
= gimple_build_wce (cleanup_stmts
);
5601 gimple_wce_set_cleanup_eh_only (wce
, eh_only
);
5602 gimplify_seq_add_stmt (pre_p
, wce
);
5606 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5608 static enum gimplify_status
5609 gimplify_target_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5611 tree targ
= *expr_p
;
5612 tree temp
= TARGET_EXPR_SLOT (targ
);
5613 tree init
= TARGET_EXPR_INITIAL (targ
);
5614 enum gimplify_status ret
;
5618 tree cleanup
= NULL_TREE
;
5620 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5621 to the temps list. Handle also variable length TARGET_EXPRs. */
5622 if (TREE_CODE (DECL_SIZE (temp
)) != INTEGER_CST
)
5624 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp
)))
5625 gimplify_type_sizes (TREE_TYPE (temp
), pre_p
);
5626 gimplify_vla_decl (temp
, pre_p
);
5629 gimple_add_tmp_var (temp
);
5631 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5632 expression is supposed to initialize the slot. */
5633 if (VOID_TYPE_P (TREE_TYPE (init
)))
5634 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5637 tree init_expr
= build2 (INIT_EXPR
, void_type_node
, temp
, init
);
5639 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5641 ggc_free (init_expr
);
5643 if (ret
== GS_ERROR
)
5645 /* PR c++/28266 Make sure this is expanded only once. */
5646 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5650 gimplify_and_add (init
, pre_p
);
5652 /* If needed, push the cleanup for the temp. */
5653 if (TARGET_EXPR_CLEANUP (targ
))
5655 if (CLEANUP_EH_ONLY (targ
))
5656 gimple_push_cleanup (temp
, TARGET_EXPR_CLEANUP (targ
),
5657 CLEANUP_EH_ONLY (targ
), pre_p
);
5659 cleanup
= TARGET_EXPR_CLEANUP (targ
);
5662 /* Add a clobber for the temporary going out of scope, like
5663 gimplify_bind_expr. */
5664 if (gimplify_ctxp
->in_cleanup_point_expr
5665 && needs_to_live_in_memory (temp
)
5666 && flag_stack_reuse
== SR_ALL
)
5668 tree clobber
= build_constructor (TREE_TYPE (temp
),
5670 TREE_THIS_VOLATILE (clobber
) = true;
5671 clobber
= build2 (MODIFY_EXPR
, TREE_TYPE (temp
), temp
, clobber
);
5673 cleanup
= build2 (COMPOUND_EXPR
, void_type_node
, cleanup
,
5680 gimple_push_cleanup (temp
, cleanup
, false, pre_p
);
5682 /* Only expand this once. */
5683 TREE_OPERAND (targ
, 3) = init
;
5684 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5687 /* We should have expanded this before. */
5688 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp
));
5694 /* Gimplification of expression trees. */
5696 /* Gimplify an expression which appears at statement context. The
5697 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5698 NULL, a new sequence is allocated.
5700 Return true if we actually added a statement to the queue. */
5703 gimplify_stmt (tree
*stmt_p
, gimple_seq
*seq_p
)
5705 gimple_seq_node last
;
5707 last
= gimple_seq_last (*seq_p
);
5708 gimplify_expr (stmt_p
, seq_p
, NULL
, is_gimple_stmt
, fb_none
);
5709 return last
!= gimple_seq_last (*seq_p
);
5712 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5713 to CTX. If entries already exist, force them to be some flavor of private.
5714 If there is no enclosing parallel, do nothing. */
5717 omp_firstprivatize_variable (struct gimplify_omp_ctx
*ctx
, tree decl
)
5721 if (decl
== NULL
|| !DECL_P (decl
))
5726 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5729 if (n
->value
& GOVD_SHARED
)
5730 n
->value
= GOVD_FIRSTPRIVATE
| (n
->value
& GOVD_SEEN
);
5734 else if (ctx
->region_type
!= ORT_WORKSHARE
)
5735 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
5737 ctx
= ctx
->outer_context
;
5742 /* Similarly for each of the type sizes of TYPE. */
5745 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx
*ctx
, tree type
)
5747 if (type
== NULL
|| type
== error_mark_node
)
5749 type
= TYPE_MAIN_VARIANT (type
);
5751 if (pointer_set_insert (ctx
->privatized_types
, type
))
5754 switch (TREE_CODE (type
))
5760 case FIXED_POINT_TYPE
:
5761 omp_firstprivatize_variable (ctx
, TYPE_MIN_VALUE (type
));
5762 omp_firstprivatize_variable (ctx
, TYPE_MAX_VALUE (type
));
5766 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5767 omp_firstprivatize_type_sizes (ctx
, TYPE_DOMAIN (type
));
5772 case QUAL_UNION_TYPE
:
5775 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
5776 if (TREE_CODE (field
) == FIELD_DECL
)
5778 omp_firstprivatize_variable (ctx
, DECL_FIELD_OFFSET (field
));
5779 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (field
));
5785 case REFERENCE_TYPE
:
5786 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5793 omp_firstprivatize_variable (ctx
, TYPE_SIZE (type
));
5794 omp_firstprivatize_variable (ctx
, TYPE_SIZE_UNIT (type
));
5795 lang_hooks
.types
.omp_firstprivatize_type_sizes (ctx
, type
);
5798 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
5801 omp_add_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned int flags
)
5804 unsigned int nflags
;
5807 if (error_operand_p (decl
))
5810 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5811 there are constructors involved somewhere. */
5812 if (TREE_ADDRESSABLE (TREE_TYPE (decl
))
5813 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
5816 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5819 /* We shouldn't be re-adding the decl with the same data
5821 gcc_assert ((n
->value
& GOVD_DATA_SHARE_CLASS
& flags
) == 0);
5822 /* The only combination of data sharing classes we should see is
5823 FIRSTPRIVATE and LASTPRIVATE. */
5824 nflags
= n
->value
| flags
;
5825 gcc_assert ((nflags
& GOVD_DATA_SHARE_CLASS
)
5826 == (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
));
5831 /* When adding a variable-sized variable, we have to handle all sorts
5832 of additional bits of data: the pointer replacement variable, and
5833 the parameters of the type. */
5834 if (DECL_SIZE (decl
) && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5836 /* Add the pointer replacement variable as PRIVATE if the variable
5837 replacement is private, else FIRSTPRIVATE since we'll need the
5838 address of the original variable either for SHARED, or for the
5839 copy into or out of the context. */
5840 if (!(flags
& GOVD_LOCAL
))
5842 nflags
= flags
& GOVD_PRIVATE
? GOVD_PRIVATE
: GOVD_FIRSTPRIVATE
;
5843 nflags
|= flags
& GOVD_SEEN
;
5844 t
= DECL_VALUE_EXPR (decl
);
5845 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5846 t
= TREE_OPERAND (t
, 0);
5847 gcc_assert (DECL_P (t
));
5848 omp_add_variable (ctx
, t
, nflags
);
5851 /* Add all of the variable and type parameters (which should have
5852 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5853 omp_firstprivatize_variable (ctx
, DECL_SIZE_UNIT (decl
));
5854 omp_firstprivatize_variable (ctx
, DECL_SIZE (decl
));
5855 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5857 /* The variable-sized variable itself is never SHARED, only some form
5858 of PRIVATE. The sharing would take place via the pointer variable
5859 which we remapped above. */
5860 if (flags
& GOVD_SHARED
)
5861 flags
= GOVD_PRIVATE
| GOVD_DEBUG_PRIVATE
5862 | (flags
& (GOVD_SEEN
| GOVD_EXPLICIT
));
5864 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5865 alloca statement we generate for the variable, so make sure it
5866 is available. This isn't automatically needed for the SHARED
5867 case, since we won't be allocating local storage then.
5868 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5869 in this case omp_notice_variable will be called later
5870 on when it is gimplified. */
5871 else if (! (flags
& GOVD_LOCAL
)
5872 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl
))))
5873 omp_notice_variable (ctx
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)), true);
5875 else if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
5877 gcc_assert ((flags
& GOVD_LOCAL
) == 0);
5878 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5880 /* Similar to the direct variable sized case above, we'll need the
5881 size of references being privatized. */
5882 if ((flags
& GOVD_SHARED
) == 0)
5884 t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
5885 if (TREE_CODE (t
) != INTEGER_CST
)
5886 omp_notice_variable (ctx
, t
, true);
5890 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, flags
);
5893 /* Notice a threadprivate variable DECL used in OpenMP context CTX.
5894 This just prints out diagnostics about threadprivate variable uses
5895 in untied tasks. If DECL2 is non-NULL, prevent this warning
5896 on that variable. */
5899 omp_notice_threadprivate_variable (struct gimplify_omp_ctx
*ctx
, tree decl
,
5904 if (ctx
->region_type
!= ORT_UNTIED_TASK
)
5906 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5909 error ("threadprivate variable %qE used in untied task",
5911 error_at (ctx
->location
, "enclosing task");
5912 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, 0);
5915 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl2
, 0);
5919 /* Record the fact that DECL was used within the OpenMP context CTX.
5920 IN_CODE is true when real code uses DECL, and false when we should
5921 merely emit default(none) errors. Return true if DECL is going to
5922 be remapped and thus DECL shouldn't be gimplified into its
5923 DECL_VALUE_EXPR (if any). */
5926 omp_notice_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, bool in_code
)
5929 unsigned flags
= in_code
? GOVD_SEEN
: 0;
5930 bool ret
= false, shared
;
5932 if (error_operand_p (decl
))
5935 /* Threadprivate variables are predetermined. */
5936 if (is_global_var (decl
))
5938 if (DECL_THREAD_LOCAL_P (decl
))
5939 return omp_notice_threadprivate_variable (ctx
, decl
, NULL_TREE
);
5941 if (DECL_HAS_VALUE_EXPR_P (decl
))
5943 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
5945 if (value
&& DECL_P (value
) && DECL_THREAD_LOCAL_P (value
))
5946 return omp_notice_threadprivate_variable (ctx
, decl
, value
);
5950 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5953 enum omp_clause_default_kind default_kind
, kind
;
5954 struct gimplify_omp_ctx
*octx
;
5956 if (ctx
->region_type
== ORT_WORKSHARE
)
5959 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
5960 remapped firstprivate instead of shared. To some extent this is
5961 addressed in omp_firstprivatize_type_sizes, but not effectively. */
5962 default_kind
= ctx
->default_kind
;
5963 kind
= lang_hooks
.decls
.omp_predetermined_sharing (decl
);
5964 if (kind
!= OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
5965 default_kind
= kind
;
5967 switch (default_kind
)
5969 case OMP_CLAUSE_DEFAULT_NONE
:
5970 error ("%qE not specified in enclosing parallel",
5971 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5972 if ((ctx
->region_type
& ORT_TASK
) != 0)
5973 error_at (ctx
->location
, "enclosing task");
5975 error_at (ctx
->location
, "enclosing parallel");
5977 case OMP_CLAUSE_DEFAULT_SHARED
:
5978 flags
|= GOVD_SHARED
;
5980 case OMP_CLAUSE_DEFAULT_PRIVATE
:
5981 flags
|= GOVD_PRIVATE
;
5983 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
5984 flags
|= GOVD_FIRSTPRIVATE
;
5986 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
5987 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
5988 gcc_assert ((ctx
->region_type
& ORT_TASK
) != 0);
5989 if (ctx
->outer_context
)
5990 omp_notice_variable (ctx
->outer_context
, decl
, in_code
);
5991 for (octx
= ctx
->outer_context
; octx
; octx
= octx
->outer_context
)
5995 n2
= splay_tree_lookup (octx
->variables
, (splay_tree_key
) decl
);
5996 if (n2
&& (n2
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
)
5998 flags
|= GOVD_FIRSTPRIVATE
;
6001 if ((octx
->region_type
& ORT_PARALLEL
) != 0)
6004 if (flags
& GOVD_FIRSTPRIVATE
)
6007 && (TREE_CODE (decl
) == PARM_DECL
6008 || (!is_global_var (decl
)
6009 && DECL_CONTEXT (decl
) == current_function_decl
)))
6011 flags
|= GOVD_FIRSTPRIVATE
;
6014 flags
|= GOVD_SHARED
;
6020 if ((flags
& GOVD_PRIVATE
)
6021 && lang_hooks
.decls
.omp_private_outer_ref (decl
))
6022 flags
|= GOVD_PRIVATE_OUTER_REF
;
6024 omp_add_variable (ctx
, decl
, flags
);
6026 shared
= (flags
& GOVD_SHARED
) != 0;
6027 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
6031 if ((n
->value
& (GOVD_SEEN
| GOVD_LOCAL
)) == 0
6032 && (flags
& (GOVD_SEEN
| GOVD_LOCAL
)) == GOVD_SEEN
6034 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6037 tree t
= DECL_VALUE_EXPR (decl
);
6038 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
6039 t
= TREE_OPERAND (t
, 0);
6040 gcc_assert (DECL_P (t
));
6041 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
6042 n2
->value
|= GOVD_SEEN
;
6045 shared
= ((flags
| n
->value
) & GOVD_SHARED
) != 0;
6046 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
6048 /* If nothing changed, there's nothing left to do. */
6049 if ((n
->value
& flags
) == flags
)
6055 /* If the variable is private in the current context, then we don't
6056 need to propagate anything to an outer context. */
6057 if ((flags
& GOVD_PRIVATE
) && !(flags
& GOVD_PRIVATE_OUTER_REF
))
6059 if (ctx
->outer_context
6060 && omp_notice_variable (ctx
->outer_context
, decl
, in_code
))
6065 /* Verify that DECL is private within CTX. If there's specific information
6066 to the contrary in the innermost scope, generate an error. */
6069 omp_is_private (struct gimplify_omp_ctx
*ctx
, tree decl
)
6073 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
6076 if (n
->value
& GOVD_SHARED
)
6078 if (ctx
== gimplify_omp_ctxp
)
6080 error ("iteration variable %qE should be private",
6082 n
->value
= GOVD_PRIVATE
;
6088 else if ((n
->value
& GOVD_EXPLICIT
) != 0
6089 && (ctx
== gimplify_omp_ctxp
6090 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6091 && gimplify_omp_ctxp
->outer_context
== ctx
)))
6093 if ((n
->value
& GOVD_FIRSTPRIVATE
) != 0)
6094 error ("iteration variable %qE should not be firstprivate",
6096 else if ((n
->value
& GOVD_REDUCTION
) != 0)
6097 error ("iteration variable %qE should not be reduction",
6100 return (ctx
== gimplify_omp_ctxp
6101 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6102 && gimplify_omp_ctxp
->outer_context
== ctx
));
6105 if (ctx
->region_type
!= ORT_WORKSHARE
)
6107 else if (ctx
->outer_context
)
6108 return omp_is_private (ctx
->outer_context
, decl
);
6112 /* Return true if DECL is private within a parallel region
6113 that binds to the current construct's context or in parallel
6114 region's REDUCTION clause. */
6117 omp_check_private (struct gimplify_omp_ctx
*ctx
, tree decl
)
6123 ctx
= ctx
->outer_context
;
6125 return !(is_global_var (decl
)
6126 /* References might be private, but might be shared too. */
6127 || lang_hooks
.decls
.omp_privatize_by_reference (decl
));
6129 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6131 return (n
->value
& GOVD_SHARED
) == 0;
6133 while (ctx
->region_type
== ORT_WORKSHARE
);
6137 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
6138 and previous omp contexts. */
6141 gimplify_scan_omp_clauses (tree
*list_p
, gimple_seq
*pre_p
,
6142 enum omp_region_type region_type
)
6144 struct gimplify_omp_ctx
*ctx
, *outer_ctx
;
6145 struct gimplify_ctx gctx
;
6148 ctx
= new_omp_context (region_type
);
6149 outer_ctx
= ctx
->outer_context
;
6151 while ((c
= *list_p
) != NULL
)
6153 bool remove
= false;
6154 bool notice_outer
= true;
6155 const char *check_non_private
= NULL
;
6159 switch (OMP_CLAUSE_CODE (c
))
6161 case OMP_CLAUSE_PRIVATE
:
6162 flags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
6163 if (lang_hooks
.decls
.omp_private_outer_ref (OMP_CLAUSE_DECL (c
)))
6165 flags
|= GOVD_PRIVATE_OUTER_REF
;
6166 OMP_CLAUSE_PRIVATE_OUTER_REF (c
) = 1;
6169 notice_outer
= false;
6171 case OMP_CLAUSE_SHARED
:
6172 flags
= GOVD_SHARED
| GOVD_EXPLICIT
;
6174 case OMP_CLAUSE_FIRSTPRIVATE
:
6175 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
6176 check_non_private
= "firstprivate";
6178 case OMP_CLAUSE_LASTPRIVATE
:
6179 flags
= GOVD_LASTPRIVATE
| GOVD_SEEN
| GOVD_EXPLICIT
;
6180 check_non_private
= "lastprivate";
6182 case OMP_CLAUSE_REDUCTION
:
6183 flags
= GOVD_REDUCTION
| GOVD_SEEN
| GOVD_EXPLICIT
;
6184 check_non_private
= "reduction";
6188 decl
= OMP_CLAUSE_DECL (c
);
6189 if (error_operand_p (decl
))
6194 omp_add_variable (ctx
, decl
, flags
);
6195 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
6196 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
6198 omp_add_variable (ctx
, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
),
6199 GOVD_LOCAL
| GOVD_SEEN
);
6200 gimplify_omp_ctxp
= ctx
;
6201 push_gimplify_context (&gctx
);
6203 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
6204 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
6206 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c
),
6207 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
6208 pop_gimplify_context
6209 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
)));
6210 push_gimplify_context (&gctx
);
6211 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c
),
6212 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
6213 pop_gimplify_context
6214 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
)));
6215 OMP_CLAUSE_REDUCTION_INIT (c
) = NULL_TREE
;
6216 OMP_CLAUSE_REDUCTION_MERGE (c
) = NULL_TREE
;
6218 gimplify_omp_ctxp
= outer_ctx
;
6220 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6221 && OMP_CLAUSE_LASTPRIVATE_STMT (c
))
6223 gimplify_omp_ctxp
= ctx
;
6224 push_gimplify_context (&gctx
);
6225 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c
)) != BIND_EXPR
)
6227 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
6229 TREE_SIDE_EFFECTS (bind
) = 1;
6230 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LASTPRIVATE_STMT (c
);
6231 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = bind
;
6233 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c
),
6234 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6235 pop_gimplify_context
6236 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
)));
6237 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = NULL_TREE
;
6239 gimplify_omp_ctxp
= outer_ctx
;
6245 case OMP_CLAUSE_COPYIN
:
6246 case OMP_CLAUSE_COPYPRIVATE
:
6247 decl
= OMP_CLAUSE_DECL (c
);
6248 if (error_operand_p (decl
))
6255 omp_notice_variable (outer_ctx
, decl
, true);
6256 if (check_non_private
6257 && region_type
== ORT_WORKSHARE
6258 && omp_check_private (ctx
, decl
))
6260 error ("%s variable %qE is private in outer context",
6261 check_non_private
, DECL_NAME (decl
));
6266 case OMP_CLAUSE_FINAL
:
6268 OMP_CLAUSE_OPERAND (c
, 0)
6269 = gimple_boolify (OMP_CLAUSE_OPERAND (c
, 0));
6272 case OMP_CLAUSE_SCHEDULE
:
6273 case OMP_CLAUSE_NUM_THREADS
:
6274 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
6275 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6279 case OMP_CLAUSE_NOWAIT
:
6280 case OMP_CLAUSE_ORDERED
:
6281 case OMP_CLAUSE_UNTIED
:
6282 case OMP_CLAUSE_COLLAPSE
:
6283 case OMP_CLAUSE_MERGEABLE
:
6286 case OMP_CLAUSE_DEFAULT
:
6287 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
6295 *list_p
= OMP_CLAUSE_CHAIN (c
);
6297 list_p
= &OMP_CLAUSE_CHAIN (c
);
6300 gimplify_omp_ctxp
= ctx
;
6303 /* For all variables that were not actually used within the context,
6304 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
6307 gimplify_adjust_omp_clauses_1 (splay_tree_node n
, void *data
)
6309 tree
*list_p
= (tree
*) data
;
6310 tree decl
= (tree
) n
->key
;
6311 unsigned flags
= n
->value
;
6312 enum omp_clause_code code
;
6316 if (flags
& (GOVD_EXPLICIT
| GOVD_LOCAL
))
6318 if ((flags
& GOVD_SEEN
) == 0)
6320 if (flags
& GOVD_DEBUG_PRIVATE
)
6322 gcc_assert ((flags
& GOVD_DATA_SHARE_CLASS
) == GOVD_PRIVATE
);
6323 private_debug
= true;
6327 = lang_hooks
.decls
.omp_private_debug_clause (decl
,
6328 !!(flags
& GOVD_SHARED
));
6330 code
= OMP_CLAUSE_PRIVATE
;
6331 else if (flags
& GOVD_SHARED
)
6333 if (is_global_var (decl
))
6335 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
6339 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6340 if (on
&& (on
->value
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
6341 | GOVD_PRIVATE
| GOVD_REDUCTION
)) != 0)
6343 ctx
= ctx
->outer_context
;
6348 code
= OMP_CLAUSE_SHARED
;
6350 else if (flags
& GOVD_PRIVATE
)
6351 code
= OMP_CLAUSE_PRIVATE
;
6352 else if (flags
& GOVD_FIRSTPRIVATE
)
6353 code
= OMP_CLAUSE_FIRSTPRIVATE
;
6357 clause
= build_omp_clause (input_location
, code
);
6358 OMP_CLAUSE_DECL (clause
) = decl
;
6359 OMP_CLAUSE_CHAIN (clause
) = *list_p
;
6361 OMP_CLAUSE_PRIVATE_DEBUG (clause
) = 1;
6362 else if (code
== OMP_CLAUSE_PRIVATE
&& (flags
& GOVD_PRIVATE_OUTER_REF
))
6363 OMP_CLAUSE_PRIVATE_OUTER_REF (clause
) = 1;
6365 lang_hooks
.decls
.omp_finish_clause (clause
);
6371 gimplify_adjust_omp_clauses (tree
*list_p
)
6373 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6376 while ((c
= *list_p
) != NULL
)
6379 bool remove
= false;
6381 switch (OMP_CLAUSE_CODE (c
))
6383 case OMP_CLAUSE_PRIVATE
:
6384 case OMP_CLAUSE_SHARED
:
6385 case OMP_CLAUSE_FIRSTPRIVATE
:
6386 decl
= OMP_CLAUSE_DECL (c
);
6387 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6388 remove
= !(n
->value
& GOVD_SEEN
);
6391 bool shared
= OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
;
6392 if ((n
->value
& GOVD_DEBUG_PRIVATE
)
6393 || lang_hooks
.decls
.omp_private_debug_clause (decl
, shared
))
6395 gcc_assert ((n
->value
& GOVD_DEBUG_PRIVATE
) == 0
6396 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
6398 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_PRIVATE
);
6399 OMP_CLAUSE_PRIVATE_DEBUG (c
) = 1;
6404 case OMP_CLAUSE_LASTPRIVATE
:
6405 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
6406 accurately reflect the presence of a FIRSTPRIVATE clause. */
6407 decl
= OMP_CLAUSE_DECL (c
);
6408 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6409 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
6410 = (n
->value
& GOVD_FIRSTPRIVATE
) != 0;
6413 case OMP_CLAUSE_REDUCTION
:
6414 case OMP_CLAUSE_COPYIN
:
6415 case OMP_CLAUSE_COPYPRIVATE
:
6417 case OMP_CLAUSE_NUM_THREADS
:
6418 case OMP_CLAUSE_SCHEDULE
:
6419 case OMP_CLAUSE_NOWAIT
:
6420 case OMP_CLAUSE_ORDERED
:
6421 case OMP_CLAUSE_DEFAULT
:
6422 case OMP_CLAUSE_UNTIED
:
6423 case OMP_CLAUSE_COLLAPSE
:
6424 case OMP_CLAUSE_FINAL
:
6425 case OMP_CLAUSE_MERGEABLE
:
6433 *list_p
= OMP_CLAUSE_CHAIN (c
);
6435 list_p
= &OMP_CLAUSE_CHAIN (c
);
6438 /* Add in any implicit data sharing. */
6439 splay_tree_foreach (ctx
->variables
, gimplify_adjust_omp_clauses_1
, list_p
);
6441 gimplify_omp_ctxp
= ctx
->outer_context
;
6442 delete_omp_context (ctx
);
6445 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
6446 gimplification of the body, as well as scanning the body for used
6447 variables. We need to do this scan now, because variable-sized
6448 decls will be decomposed during gimplification. */
6451 gimplify_omp_parallel (tree
*expr_p
, gimple_seq
*pre_p
)
6453 tree expr
= *expr_p
;
6455 gimple_seq body
= NULL
;
6456 struct gimplify_ctx gctx
;
6458 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
), pre_p
,
6459 OMP_PARALLEL_COMBINED (expr
)
6460 ? ORT_COMBINED_PARALLEL
6463 push_gimplify_context (&gctx
);
6465 g
= gimplify_and_return_first (OMP_PARALLEL_BODY (expr
), &body
);
6466 if (gimple_code (g
) == GIMPLE_BIND
)
6467 pop_gimplify_context (g
);
6469 pop_gimplify_context (NULL
);
6471 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
));
6473 g
= gimple_build_omp_parallel (body
,
6474 OMP_PARALLEL_CLAUSES (expr
),
6475 NULL_TREE
, NULL_TREE
);
6476 if (OMP_PARALLEL_COMBINED (expr
))
6477 gimple_omp_set_subcode (g
, GF_OMP_PARALLEL_COMBINED
);
6478 gimplify_seq_add_stmt (pre_p
, g
);
6479 *expr_p
= NULL_TREE
;
6482 /* Gimplify the contents of an OMP_TASK statement. This involves
6483 gimplification of the body, as well as scanning the body for used
6484 variables. We need to do this scan now, because variable-sized
6485 decls will be decomposed during gimplification. */
6488 gimplify_omp_task (tree
*expr_p
, gimple_seq
*pre_p
)
6490 tree expr
= *expr_p
;
6492 gimple_seq body
= NULL
;
6493 struct gimplify_ctx gctx
;
6495 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr
), pre_p
,
6496 find_omp_clause (OMP_TASK_CLAUSES (expr
),
6498 ? ORT_UNTIED_TASK
: ORT_TASK
);
6500 push_gimplify_context (&gctx
);
6502 g
= gimplify_and_return_first (OMP_TASK_BODY (expr
), &body
);
6503 if (gimple_code (g
) == GIMPLE_BIND
)
6504 pop_gimplify_context (g
);
6506 pop_gimplify_context (NULL
);
6508 gimplify_adjust_omp_clauses (&OMP_TASK_CLAUSES (expr
));
6510 g
= gimple_build_omp_task (body
,
6511 OMP_TASK_CLAUSES (expr
),
6512 NULL_TREE
, NULL_TREE
,
6513 NULL_TREE
, NULL_TREE
, NULL_TREE
);
6514 gimplify_seq_add_stmt (pre_p
, g
);
6515 *expr_p
= NULL_TREE
;
6518 /* Gimplify the gross structure of an OMP_FOR statement. */
6520 static enum gimplify_status
6521 gimplify_omp_for (tree
*expr_p
, gimple_seq
*pre_p
)
6523 tree for_stmt
, decl
, var
, t
;
6524 enum gimplify_status ret
= GS_ALL_DONE
;
6525 enum gimplify_status tret
;
6527 gimple_seq for_body
, for_pre_body
;
6532 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
), pre_p
,
6535 /* Handle OMP_FOR_INIT. */
6536 for_pre_body
= NULL
;
6537 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
6538 OMP_FOR_PRE_BODY (for_stmt
) = NULL_TREE
;
6541 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6542 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt
)));
6543 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6544 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt
)));
6545 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6547 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6548 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6549 decl
= TREE_OPERAND (t
, 0);
6550 gcc_assert (DECL_P (decl
));
6551 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl
))
6552 || POINTER_TYPE_P (TREE_TYPE (decl
)));
6554 /* Make sure the iteration variable is private. */
6555 if (omp_is_private (gimplify_omp_ctxp
, decl
))
6556 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
6558 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_PRIVATE
| GOVD_SEEN
);
6560 /* If DECL is not a gimple register, create a temporary variable to act
6561 as an iteration counter. This is valid, since DECL cannot be
6562 modified in the body of the loop. */
6563 if (!is_gimple_reg (decl
))
6565 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
6566 TREE_OPERAND (t
, 0) = var
;
6568 gimplify_seq_add_stmt (&for_body
, gimple_build_assign (decl
, var
));
6570 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
6575 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6576 is_gimple_val
, fb_rvalue
);
6577 ret
= MIN (ret
, tret
);
6578 if (ret
== GS_ERROR
)
6581 /* Handle OMP_FOR_COND. */
6582 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
6583 gcc_assert (COMPARISON_CLASS_P (t
));
6584 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6586 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6587 is_gimple_val
, fb_rvalue
);
6588 ret
= MIN (ret
, tret
);
6590 /* Handle OMP_FOR_INCR. */
6591 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6592 switch (TREE_CODE (t
))
6594 case PREINCREMENT_EXPR
:
6595 case POSTINCREMENT_EXPR
:
6596 t
= build_int_cst (TREE_TYPE (decl
), 1);
6597 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6598 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6599 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6602 case PREDECREMENT_EXPR
:
6603 case POSTDECREMENT_EXPR
:
6604 t
= build_int_cst (TREE_TYPE (decl
), -1);
6605 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6606 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6607 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6611 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6612 TREE_OPERAND (t
, 0) = var
;
6614 t
= TREE_OPERAND (t
, 1);
6615 switch (TREE_CODE (t
))
6618 if (TREE_OPERAND (t
, 1) == decl
)
6620 TREE_OPERAND (t
, 1) = TREE_OPERAND (t
, 0);
6621 TREE_OPERAND (t
, 0) = var
;
6627 case POINTER_PLUS_EXPR
:
6628 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6629 TREE_OPERAND (t
, 0) = var
;
6635 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6636 is_gimple_val
, fb_rvalue
);
6637 ret
= MIN (ret
, tret
);
6644 if (var
!= decl
|| TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1)
6647 for (c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
6648 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6649 && OMP_CLAUSE_DECL (c
) == decl
6650 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) == NULL
)
6652 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6653 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6654 gcc_assert (TREE_OPERAND (t
, 0) == var
);
6655 t
= TREE_OPERAND (t
, 1);
6656 gcc_assert (TREE_CODE (t
) == PLUS_EXPR
6657 || TREE_CODE (t
) == MINUS_EXPR
6658 || TREE_CODE (t
) == POINTER_PLUS_EXPR
);
6659 gcc_assert (TREE_OPERAND (t
, 0) == var
);
6660 t
= build2 (TREE_CODE (t
), TREE_TYPE (decl
), decl
,
6661 TREE_OPERAND (t
, 1));
6662 gimplify_assign (decl
, t
,
6663 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6668 gimplify_and_add (OMP_FOR_BODY (for_stmt
), &for_body
);
6670 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
));
6672 gfor
= gimple_build_omp_for (for_body
, OMP_FOR_CLAUSES (for_stmt
),
6673 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)),
6676 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6678 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6679 gimple_omp_for_set_index (gfor
, i
, TREE_OPERAND (t
, 0));
6680 gimple_omp_for_set_initial (gfor
, i
, TREE_OPERAND (t
, 1));
6681 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
6682 gimple_omp_for_set_cond (gfor
, i
, TREE_CODE (t
));
6683 gimple_omp_for_set_final (gfor
, i
, TREE_OPERAND (t
, 1));
6684 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6685 gimple_omp_for_set_incr (gfor
, i
, TREE_OPERAND (t
, 1));
6688 gimplify_seq_add_stmt (pre_p
, gfor
);
6689 return ret
== GS_ALL_DONE
? GS_ALL_DONE
: GS_ERROR
;
6692 /* Gimplify the gross structure of other OpenMP worksharing constructs.
6693 In particular, OMP_SECTIONS and OMP_SINGLE. */
6696 gimplify_omp_workshare (tree
*expr_p
, gimple_seq
*pre_p
)
6698 tree expr
= *expr_p
;
6700 gimple_seq body
= NULL
;
6702 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr
), pre_p
, ORT_WORKSHARE
);
6703 gimplify_and_add (OMP_BODY (expr
), &body
);
6704 gimplify_adjust_omp_clauses (&OMP_CLAUSES (expr
));
6706 if (TREE_CODE (expr
) == OMP_SECTIONS
)
6707 stmt
= gimple_build_omp_sections (body
, OMP_CLAUSES (expr
));
6708 else if (TREE_CODE (expr
) == OMP_SINGLE
)
6709 stmt
= gimple_build_omp_single (body
, OMP_CLAUSES (expr
));
6713 gimplify_seq_add_stmt (pre_p
, stmt
);
6716 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
6717 stabilized the lhs of the atomic operation as *ADDR. Return true if
6718 EXPR is this stabilized form. */
6721 goa_lhs_expr_p (tree expr
, tree addr
)
6723 /* Also include casts to other type variants. The C front end is fond
6724 of adding these for e.g. volatile variables. This is like
6725 STRIP_TYPE_NOPS but includes the main variant lookup. */
6726 STRIP_USELESS_TYPE_CONVERSION (expr
);
6728 if (TREE_CODE (expr
) == INDIRECT_REF
)
6730 expr
= TREE_OPERAND (expr
, 0);
6732 && (CONVERT_EXPR_P (expr
)
6733 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
6734 && TREE_CODE (expr
) == TREE_CODE (addr
)
6735 && types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (addr
)))
6737 expr
= TREE_OPERAND (expr
, 0);
6738 addr
= TREE_OPERAND (addr
, 0);
6742 return (TREE_CODE (addr
) == ADDR_EXPR
6743 && TREE_CODE (expr
) == ADDR_EXPR
6744 && TREE_OPERAND (addr
, 0) == TREE_OPERAND (expr
, 0));
6746 if (TREE_CODE (addr
) == ADDR_EXPR
&& expr
== TREE_OPERAND (addr
, 0))
6751 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
6752 expression does not involve the lhs, evaluate it into a temporary.
6753 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
6754 or -1 if an error was encountered. */
6757 goa_stabilize_expr (tree
*expr_p
, gimple_seq
*pre_p
, tree lhs_addr
,
6760 tree expr
= *expr_p
;
6763 if (goa_lhs_expr_p (expr
, lhs_addr
))
6768 if (is_gimple_val (expr
))
6772 switch (TREE_CODE_CLASS (TREE_CODE (expr
)))
6775 case tcc_comparison
:
6776 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
, lhs_addr
,
6779 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
, lhs_addr
,
6782 case tcc_expression
:
6783 switch (TREE_CODE (expr
))
6785 case TRUTH_ANDIF_EXPR
:
6786 case TRUTH_ORIF_EXPR
:
6787 case TRUTH_AND_EXPR
:
6789 case TRUTH_XOR_EXPR
:
6790 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
,
6792 case TRUTH_NOT_EXPR
:
6793 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
6797 /* Break out any preevaluations from cp_build_modify_expr. */
6798 for (; TREE_CODE (expr
) == COMPOUND_EXPR
;
6799 expr
= TREE_OPERAND (expr
, 1))
6800 gimplify_stmt (&TREE_OPERAND (expr
, 0), pre_p
);
6802 return goa_stabilize_expr (expr_p
, pre_p
, lhs_addr
, lhs_var
);
6813 enum gimplify_status gs
;
6814 gs
= gimplify_expr (expr_p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
6815 if (gs
!= GS_ALL_DONE
)
6822 /* Gimplify an OMP_ATOMIC statement. */
6824 static enum gimplify_status
6825 gimplify_omp_atomic (tree
*expr_p
, gimple_seq
*pre_p
)
6827 tree addr
= TREE_OPERAND (*expr_p
, 0);
6828 tree rhs
= TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
6829 ? NULL
: TREE_OPERAND (*expr_p
, 1);
6830 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
6832 gimple loadstmt
, storestmt
;
6834 tmp_load
= create_tmp_reg (type
, NULL
);
6835 if (rhs
&& goa_stabilize_expr (&rhs
, pre_p
, addr
, tmp_load
) < 0)
6838 if (gimplify_expr (&addr
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
6842 loadstmt
= gimple_build_omp_atomic_load (tmp_load
, addr
);
6843 gimplify_seq_add_stmt (pre_p
, loadstmt
);
6844 if (rhs
&& gimplify_expr (&rhs
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
6848 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
)
6850 storestmt
= gimple_build_omp_atomic_store (rhs
);
6851 gimplify_seq_add_stmt (pre_p
, storestmt
);
6852 switch (TREE_CODE (*expr_p
))
6854 case OMP_ATOMIC_READ
:
6855 case OMP_ATOMIC_CAPTURE_OLD
:
6857 gimple_omp_atomic_set_need_value (loadstmt
);
6859 case OMP_ATOMIC_CAPTURE_NEW
:
6861 gimple_omp_atomic_set_need_value (storestmt
);
6871 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
6872 body, and adding some EH bits. */
6874 static enum gimplify_status
6875 gimplify_transaction (tree
*expr_p
, gimple_seq
*pre_p
)
6877 tree expr
= *expr_p
, temp
, tbody
= TRANSACTION_EXPR_BODY (expr
);
6879 gimple_seq body
= NULL
;
6880 struct gimplify_ctx gctx
;
6883 /* Wrap the transaction body in a BIND_EXPR so we have a context
6884 where to put decls for OpenMP. */
6885 if (TREE_CODE (tbody
) != BIND_EXPR
)
6887 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, tbody
, NULL
);
6888 TREE_SIDE_EFFECTS (bind
) = 1;
6889 SET_EXPR_LOCATION (bind
, EXPR_LOCATION (tbody
));
6890 TRANSACTION_EXPR_BODY (expr
) = bind
;
6893 push_gimplify_context (&gctx
);
6894 temp
= voidify_wrapper_expr (*expr_p
, NULL
);
6896 g
= gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr
), &body
);
6897 pop_gimplify_context (g
);
6899 g
= gimple_build_transaction (body
, NULL
);
6900 if (TRANSACTION_EXPR_OUTER (expr
))
6901 subcode
= GTMA_IS_OUTER
;
6902 else if (TRANSACTION_EXPR_RELAXED (expr
))
6903 subcode
= GTMA_IS_RELAXED
;
6904 gimple_transaction_set_subcode (g
, subcode
);
6906 gimplify_seq_add_stmt (pre_p
, g
);
6914 *expr_p
= NULL_TREE
;
6918 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
6919 expression produces a value to be used as an operand inside a GIMPLE
6920 statement, the value will be stored back in *EXPR_P. This value will
6921 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
6922 an SSA_NAME. The corresponding sequence of GIMPLE statements is
6923 emitted in PRE_P and POST_P.
6925 Additionally, this process may overwrite parts of the input
6926 expression during gimplification. Ideally, it should be
6927 possible to do non-destructive gimplification.
6929 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
6930 the expression needs to evaluate to a value to be used as
6931 an operand in a GIMPLE statement, this value will be stored in
6932 *EXPR_P on exit. This happens when the caller specifies one
6933 of fb_lvalue or fb_rvalue fallback flags.
6935 PRE_P will contain the sequence of GIMPLE statements corresponding
6936 to the evaluation of EXPR and all the side-effects that must
6937 be executed before the main expression. On exit, the last
6938 statement of PRE_P is the core statement being gimplified. For
6939 instance, when gimplifying 'if (++a)' the last statement in
6940 PRE_P will be 'if (t.1)' where t.1 is the result of
6941 pre-incrementing 'a'.
6943 POST_P will contain the sequence of GIMPLE statements corresponding
6944 to the evaluation of all the side-effects that must be executed
6945 after the main expression. If this is NULL, the post
6946 side-effects are stored at the end of PRE_P.
6948 The reason why the output is split in two is to handle post
6949 side-effects explicitly. In some cases, an expression may have
6950 inner and outer post side-effects which need to be emitted in
6951 an order different from the one given by the recursive
6952 traversal. For instance, for the expression (*p--)++ the post
6953 side-effects of '--' must actually occur *after* the post
6954 side-effects of '++'. However, gimplification will first visit
6955 the inner expression, so if a separate POST sequence was not
6956 used, the resulting sequence would be:
6963 However, the post-decrement operation in line #2 must not be
6964 evaluated until after the store to *p at line #4, so the
6965 correct sequence should be:
6972 So, by specifying a separate post queue, it is possible
6973 to emit the post side-effects in the correct order.
6974 If POST_P is NULL, an internal queue will be used. Before
6975 returning to the caller, the sequence POST_P is appended to
6976 the main output sequence PRE_P.
6978 GIMPLE_TEST_F points to a function that takes a tree T and
6979 returns nonzero if T is in the GIMPLE form requested by the
6980 caller. The GIMPLE predicates are in gimple.c.
6982 FALLBACK tells the function what sort of a temporary we want if
6983 gimplification cannot produce an expression that complies with
6986 fb_none means that no temporary should be generated
6987 fb_rvalue means that an rvalue is OK to generate
6988 fb_lvalue means that an lvalue is OK to generate
6989 fb_either means that either is OK, but an lvalue is preferable.
6990 fb_mayfail means that gimplification may fail (in which case
6991 GS_ERROR will be returned)
6993 The return value is either GS_ERROR or GS_ALL_DONE, since this
6994 function iterates until EXPR is completely gimplified or an error
6997 enum gimplify_status
6998 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
6999 bool (*gimple_test_f
) (tree
), fallback_t fallback
)
7002 gimple_seq internal_pre
= NULL
;
7003 gimple_seq internal_post
= NULL
;
7006 location_t saved_location
;
7007 enum gimplify_status ret
;
7008 gimple_stmt_iterator pre_last_gsi
, post_last_gsi
;
7010 save_expr
= *expr_p
;
7011 if (save_expr
== NULL_TREE
)
7014 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
7015 is_statement
= gimple_test_f
== is_gimple_stmt
;
7019 /* Consistency checks. */
7020 if (gimple_test_f
== is_gimple_reg
)
7021 gcc_assert (fallback
& (fb_rvalue
| fb_lvalue
));
7022 else if (gimple_test_f
== is_gimple_val
7023 || gimple_test_f
== is_gimple_call_addr
7024 || gimple_test_f
== is_gimple_condexpr
7025 || gimple_test_f
== is_gimple_mem_rhs
7026 || gimple_test_f
== is_gimple_mem_rhs_or_call
7027 || gimple_test_f
== is_gimple_reg_rhs
7028 || gimple_test_f
== is_gimple_reg_rhs_or_call
7029 || gimple_test_f
== is_gimple_asm_val
7030 || gimple_test_f
== is_gimple_mem_ref_addr
)
7031 gcc_assert (fallback
& fb_rvalue
);
7032 else if (gimple_test_f
== is_gimple_min_lval
7033 || gimple_test_f
== is_gimple_lvalue
)
7034 gcc_assert (fallback
& fb_lvalue
);
7035 else if (gimple_test_f
== is_gimple_addressable
)
7036 gcc_assert (fallback
& fb_either
);
7037 else if (gimple_test_f
== is_gimple_stmt
)
7038 gcc_assert (fallback
== fb_none
);
7041 /* We should have recognized the GIMPLE_TEST_F predicate to
7042 know what kind of fallback to use in case a temporary is
7043 needed to hold the value or address of *EXPR_P. */
7047 /* We used to check the predicate here and return immediately if it
7048 succeeds. This is wrong; the design is for gimplification to be
7049 idempotent, and for the predicates to only test for valid forms, not
7050 whether they are fully simplified. */
7052 pre_p
= &internal_pre
;
7055 post_p
= &internal_post
;
7057 /* Remember the last statements added to PRE_P and POST_P. Every
7058 new statement added by the gimplification helpers needs to be
7059 annotated with location information. To centralize the
7060 responsibility, we remember the last statement that had been
7061 added to both queues before gimplifying *EXPR_P. If
7062 gimplification produces new statements in PRE_P and POST_P, those
7063 statements will be annotated with the same location information
7065 pre_last_gsi
= gsi_last (*pre_p
);
7066 post_last_gsi
= gsi_last (*post_p
);
7068 saved_location
= input_location
;
7069 if (save_expr
!= error_mark_node
7070 && EXPR_HAS_LOCATION (*expr_p
))
7071 input_location
= EXPR_LOCATION (*expr_p
);
7073 /* Loop over the specific gimplifiers until the toplevel node
7074 remains the same. */
7077 /* Strip away as many useless type conversions as possible
7079 STRIP_USELESS_TYPE_CONVERSION (*expr_p
);
7081 /* Remember the expr. */
7082 save_expr
= *expr_p
;
7084 /* Die, die, die, my darling. */
7085 if (save_expr
== error_mark_node
7086 || (TREE_TYPE (save_expr
)
7087 && TREE_TYPE (save_expr
) == error_mark_node
))
7093 /* Do any language-specific gimplification. */
7094 ret
= ((enum gimplify_status
)
7095 lang_hooks
.gimplify_expr (expr_p
, pre_p
, post_p
));
7098 if (*expr_p
== NULL_TREE
)
7100 if (*expr_p
!= save_expr
)
7103 else if (ret
!= GS_UNHANDLED
)
7106 /* Make sure that all the cases set 'ret' appropriately. */
7108 switch (TREE_CODE (*expr_p
))
7110 /* First deal with the special cases. */
7112 case POSTINCREMENT_EXPR
:
7113 case POSTDECREMENT_EXPR
:
7114 case PREINCREMENT_EXPR
:
7115 case PREDECREMENT_EXPR
:
7116 ret
= gimplify_self_mod_expr (expr_p
, pre_p
, post_p
,
7117 fallback
!= fb_none
);
7121 case ARRAY_RANGE_REF
:
7125 case VIEW_CONVERT_EXPR
:
7126 ret
= gimplify_compound_lval (expr_p
, pre_p
, post_p
,
7127 fallback
? fallback
: fb_rvalue
);
7131 ret
= gimplify_cond_expr (expr_p
, pre_p
, fallback
);
7133 /* C99 code may assign to an array in a structure value of a
7134 conditional expression, and this has undefined behavior
7135 only on execution, so create a temporary if an lvalue is
7137 if (fallback
== fb_lvalue
)
7139 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7140 mark_addressable (*expr_p
);
7146 ret
= gimplify_call_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7148 /* C99 code may assign to an array in a structure returned
7149 from a function, and this has undefined behavior only on
7150 execution, so create a temporary if an lvalue is
7152 if (fallback
== fb_lvalue
)
7154 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7155 mark_addressable (*expr_p
);
7164 ret
= gimplify_compound_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7167 case COMPOUND_LITERAL_EXPR
:
7168 ret
= gimplify_compound_literal_expr (expr_p
, pre_p
,
7169 gimple_test_f
, fallback
);
7174 ret
= gimplify_modify_expr (expr_p
, pre_p
, post_p
,
7175 fallback
!= fb_none
);
7178 case TRUTH_ANDIF_EXPR
:
7179 case TRUTH_ORIF_EXPR
:
7181 /* Preserve the original type of the expression and the
7182 source location of the outer expression. */
7183 tree org_type
= TREE_TYPE (*expr_p
);
7184 *expr_p
= gimple_boolify (*expr_p
);
7185 *expr_p
= build3_loc (input_location
, COND_EXPR
,
7189 org_type
, boolean_true_node
),
7192 org_type
, boolean_false_node
));
7197 case TRUTH_NOT_EXPR
:
7199 tree type
= TREE_TYPE (*expr_p
);
7200 /* The parsers are careful to generate TRUTH_NOT_EXPR
7201 only with operands that are always zero or one.
7202 We do not fold here but handle the only interesting case
7203 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
7204 *expr_p
= gimple_boolify (*expr_p
);
7205 if (TYPE_PRECISION (TREE_TYPE (*expr_p
)) == 1)
7206 *expr_p
= build1_loc (input_location
, BIT_NOT_EXPR
,
7207 TREE_TYPE (*expr_p
),
7208 TREE_OPERAND (*expr_p
, 0));
7210 *expr_p
= build2_loc (input_location
, BIT_XOR_EXPR
,
7211 TREE_TYPE (*expr_p
),
7212 TREE_OPERAND (*expr_p
, 0),
7213 build_int_cst (TREE_TYPE (*expr_p
), 1));
7214 if (!useless_type_conversion_p (type
, TREE_TYPE (*expr_p
)))
7215 *expr_p
= fold_convert_loc (input_location
, type
, *expr_p
);
7221 ret
= gimplify_addr_expr (expr_p
, pre_p
, post_p
);
7225 ret
= gimplify_va_arg_expr (expr_p
, pre_p
, post_p
);
7229 if (IS_EMPTY_STMT (*expr_p
))
7235 if (VOID_TYPE_P (TREE_TYPE (*expr_p
))
7236 || fallback
== fb_none
)
7238 /* Just strip a conversion to void (or in void context) and
7240 *expr_p
= TREE_OPERAND (*expr_p
, 0);
7245 ret
= gimplify_conversion (expr_p
);
7246 if (ret
== GS_ERROR
)
7248 if (*expr_p
!= save_expr
)
7252 case FIX_TRUNC_EXPR
:
7253 /* unary_expr: ... | '(' cast ')' val | ... */
7254 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7255 is_gimple_val
, fb_rvalue
);
7256 recalculate_side_effects (*expr_p
);
7261 bool volatilep
= TREE_THIS_VOLATILE (*expr_p
);
7262 bool notrap
= TREE_THIS_NOTRAP (*expr_p
);
7263 tree saved_ptr_type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 0));
7265 *expr_p
= fold_indirect_ref_loc (input_location
, *expr_p
);
7266 if (*expr_p
!= save_expr
)
7272 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7273 is_gimple_reg
, fb_rvalue
);
7274 if (ret
== GS_ERROR
)
7277 recalculate_side_effects (*expr_p
);
7278 *expr_p
= fold_build2_loc (input_location
, MEM_REF
,
7279 TREE_TYPE (*expr_p
),
7280 TREE_OPERAND (*expr_p
, 0),
7281 build_int_cst (saved_ptr_type
, 0));
7282 TREE_THIS_VOLATILE (*expr_p
) = volatilep
;
7283 TREE_THIS_NOTRAP (*expr_p
) = notrap
;
7288 /* We arrive here through the various re-gimplifcation paths. */
7290 /* First try re-folding the whole thing. */
7291 tmp
= fold_binary (MEM_REF
, TREE_TYPE (*expr_p
),
7292 TREE_OPERAND (*expr_p
, 0),
7293 TREE_OPERAND (*expr_p
, 1));
7297 recalculate_side_effects (*expr_p
);
7301 /* Avoid re-gimplifying the address operand if it is already
7302 in suitable form. Re-gimplifying would mark the address
7303 operand addressable. Always gimplify when not in SSA form
7304 as we still may have to gimplify decls with value-exprs. */
7305 if (!gimplify_ctxp
|| !gimplify_ctxp
->into_ssa
7306 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p
, 0)))
7308 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7309 is_gimple_mem_ref_addr
, fb_rvalue
);
7310 if (ret
== GS_ERROR
)
7313 recalculate_side_effects (*expr_p
);
7317 /* Constants need not be gimplified. */
7328 /* If we require an lvalue, such as for ADDR_EXPR, retain the
7329 CONST_DECL node. Otherwise the decl is replaceable by its
7331 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
7332 if (fallback
& fb_lvalue
)
7336 *expr_p
= DECL_INITIAL (*expr_p
);
7342 ret
= gimplify_decl_expr (expr_p
, pre_p
);
7346 ret
= gimplify_bind_expr (expr_p
, pre_p
);
7350 ret
= gimplify_loop_expr (expr_p
, pre_p
);
7354 ret
= gimplify_switch_expr (expr_p
, pre_p
);
7358 ret
= gimplify_exit_expr (expr_p
);
7362 /* If the target is not LABEL, then it is a computed jump
7363 and the target needs to be gimplified. */
7364 if (TREE_CODE (GOTO_DESTINATION (*expr_p
)) != LABEL_DECL
)
7366 ret
= gimplify_expr (&GOTO_DESTINATION (*expr_p
), pre_p
,
7367 NULL
, is_gimple_val
, fb_rvalue
);
7368 if (ret
== GS_ERROR
)
7371 gimplify_seq_add_stmt (pre_p
,
7372 gimple_build_goto (GOTO_DESTINATION (*expr_p
)));
7377 gimplify_seq_add_stmt (pre_p
,
7378 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p
),
7379 PREDICT_EXPR_OUTCOME (*expr_p
)));
7385 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p
))
7386 == current_function_decl
);
7387 gimplify_seq_add_stmt (pre_p
,
7388 gimple_build_label (LABEL_EXPR_LABEL (*expr_p
)));
7391 case CASE_LABEL_EXPR
:
7392 ret
= gimplify_case_label_expr (expr_p
, pre_p
);
7396 ret
= gimplify_return_expr (*expr_p
, pre_p
);
7400 /* Don't reduce this in place; let gimplify_init_constructor work its
7401 magic. Buf if we're just elaborating this for side effects, just
7402 gimplify any element that has side-effects. */
7403 if (fallback
== fb_none
)
7405 unsigned HOST_WIDE_INT ix
;
7407 tree temp
= NULL_TREE
;
7408 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p
), ix
, val
)
7409 if (TREE_SIDE_EFFECTS (val
))
7410 append_to_statement_list (val
, &temp
);
7413 ret
= temp
? GS_OK
: GS_ALL_DONE
;
7415 /* C99 code may assign to an array in a constructed
7416 structure or union, and this has undefined behavior only
7417 on execution, so create a temporary if an lvalue is
7419 else if (fallback
== fb_lvalue
)
7421 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7422 mark_addressable (*expr_p
);
7429 /* The following are special cases that are not handled by the
7430 original GIMPLE grammar. */
7432 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
7435 ret
= gimplify_save_expr (expr_p
, pre_p
, post_p
);
7439 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7440 post_p
, is_gimple_lvalue
, fb_either
);
7441 recalculate_side_effects (*expr_p
);
7444 case TARGET_MEM_REF
:
7446 enum gimplify_status r0
= GS_ALL_DONE
, r1
= GS_ALL_DONE
;
7448 if (TMR_BASE (*expr_p
))
7449 r0
= gimplify_expr (&TMR_BASE (*expr_p
), pre_p
,
7450 post_p
, is_gimple_mem_ref_addr
, fb_either
);
7451 if (TMR_INDEX (*expr_p
))
7452 r1
= gimplify_expr (&TMR_INDEX (*expr_p
), pre_p
,
7453 post_p
, is_gimple_val
, fb_rvalue
);
7454 if (TMR_INDEX2 (*expr_p
))
7455 r1
= gimplify_expr (&TMR_INDEX2 (*expr_p
), pre_p
,
7456 post_p
, is_gimple_val
, fb_rvalue
);
7457 /* TMR_STEP and TMR_OFFSET are always integer constants. */
7462 case NON_LVALUE_EXPR
:
7463 /* This should have been stripped above. */
7467 ret
= gimplify_asm_expr (expr_p
, pre_p
, post_p
);
7470 case TRY_FINALLY_EXPR
:
7471 case TRY_CATCH_EXPR
:
7473 gimple_seq eval
, cleanup
;
7476 /* Calls to destructors are generated automatically in FINALLY/CATCH
7477 block. They should have location as UNKNOWN_LOCATION. However,
7478 gimplify_call_expr will reset these call stmts to input_location
7479 if it finds stmt's location is unknown. To prevent resetting for
7480 destructors, we set the input_location to unknown.
7481 Note that this only affects the destructor calls in FINALLY/CATCH
7482 block, and will automatically reset to its original value by the
7483 end of gimplify_expr. */
7484 input_location
= UNKNOWN_LOCATION
;
7485 eval
= cleanup
= NULL
;
7486 gimplify_and_add (TREE_OPERAND (*expr_p
, 0), &eval
);
7487 gimplify_and_add (TREE_OPERAND (*expr_p
, 1), &cleanup
);
7488 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
7489 if (gimple_seq_empty_p (cleanup
))
7491 gimple_seq_add_seq (pre_p
, eval
);
7495 try_
= gimple_build_try (eval
, cleanup
,
7496 TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
7497 ? GIMPLE_TRY_FINALLY
7498 : GIMPLE_TRY_CATCH
);
7499 if (LOCATION_LOCUS (saved_location
) != UNKNOWN_LOCATION
)
7500 gimple_set_location (try_
, saved_location
);
7502 gimple_set_location (try_
, EXPR_LOCATION (save_expr
));
7503 if (TREE_CODE (*expr_p
) == TRY_CATCH_EXPR
)
7504 gimple_try_set_catch_is_cleanup (try_
,
7505 TRY_CATCH_IS_CLEANUP (*expr_p
));
7506 gimplify_seq_add_stmt (pre_p
, try_
);
7511 case CLEANUP_POINT_EXPR
:
7512 ret
= gimplify_cleanup_point_expr (expr_p
, pre_p
);
7516 ret
= gimplify_target_expr (expr_p
, pre_p
, post_p
);
7522 gimple_seq handler
= NULL
;
7523 gimplify_and_add (CATCH_BODY (*expr_p
), &handler
);
7524 c
= gimple_build_catch (CATCH_TYPES (*expr_p
), handler
);
7525 gimplify_seq_add_stmt (pre_p
, c
);
7530 case EH_FILTER_EXPR
:
7533 gimple_seq failure
= NULL
;
7535 gimplify_and_add (EH_FILTER_FAILURE (*expr_p
), &failure
);
7536 ehf
= gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p
), failure
);
7537 gimple_set_no_warning (ehf
, TREE_NO_WARNING (*expr_p
));
7538 gimplify_seq_add_stmt (pre_p
, ehf
);
7545 enum gimplify_status r0
, r1
;
7546 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
,
7547 post_p
, is_gimple_val
, fb_rvalue
);
7548 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
,
7549 post_p
, is_gimple_val
, fb_rvalue
);
7550 TREE_SIDE_EFFECTS (*expr_p
) = 0;
7556 /* We get here when taking the address of a label. We mark
7557 the label as "forced"; meaning it can never be removed and
7558 it is a potential target for any computed goto. */
7559 FORCED_LABEL (*expr_p
) = 1;
7563 case STATEMENT_LIST
:
7564 ret
= gimplify_statement_list (expr_p
, pre_p
);
7567 case WITH_SIZE_EXPR
:
7569 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7570 post_p
== &internal_post
? NULL
: post_p
,
7571 gimple_test_f
, fallback
);
7572 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
7573 is_gimple_val
, fb_rvalue
);
7580 ret
= gimplify_var_or_parm_decl (expr_p
);
7584 /* When within an OpenMP context, notice uses of variables. */
7585 if (gimplify_omp_ctxp
)
7586 omp_notice_variable (gimplify_omp_ctxp
, *expr_p
, true);
7591 /* Allow callbacks into the gimplifier during optimization. */
7596 gimplify_omp_parallel (expr_p
, pre_p
);
7601 gimplify_omp_task (expr_p
, pre_p
);
7606 ret
= gimplify_omp_for (expr_p
, pre_p
);
7611 gimplify_omp_workshare (expr_p
, pre_p
);
7620 gimple_seq body
= NULL
;
7623 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
7624 switch (TREE_CODE (*expr_p
))
7627 g
= gimple_build_omp_section (body
);
7630 g
= gimple_build_omp_master (body
);
7633 g
= gimple_build_omp_ordered (body
);
7636 g
= gimple_build_omp_critical (body
,
7637 OMP_CRITICAL_NAME (*expr_p
));
7642 gimplify_seq_add_stmt (pre_p
, g
);
7648 case OMP_ATOMIC_READ
:
7649 case OMP_ATOMIC_CAPTURE_OLD
:
7650 case OMP_ATOMIC_CAPTURE_NEW
:
7651 ret
= gimplify_omp_atomic (expr_p
, pre_p
);
7654 case TRANSACTION_EXPR
:
7655 ret
= gimplify_transaction (expr_p
, pre_p
);
7658 case TRUTH_AND_EXPR
:
7660 case TRUTH_XOR_EXPR
:
7662 tree orig_type
= TREE_TYPE (*expr_p
);
7663 tree new_type
, xop0
, xop1
;
7664 *expr_p
= gimple_boolify (*expr_p
);
7665 new_type
= TREE_TYPE (*expr_p
);
7666 if (!useless_type_conversion_p (orig_type
, new_type
))
7668 *expr_p
= fold_convert_loc (input_location
, orig_type
, *expr_p
);
7673 /* Boolified binary truth expressions are semantically equivalent
7674 to bitwise binary expressions. Canonicalize them to the
7676 switch (TREE_CODE (*expr_p
))
7678 case TRUTH_AND_EXPR
:
7679 TREE_SET_CODE (*expr_p
, BIT_AND_EXPR
);
7682 TREE_SET_CODE (*expr_p
, BIT_IOR_EXPR
);
7684 case TRUTH_XOR_EXPR
:
7685 TREE_SET_CODE (*expr_p
, BIT_XOR_EXPR
);
7690 /* Now make sure that operands have compatible type to
7691 expression's new_type. */
7692 xop0
= TREE_OPERAND (*expr_p
, 0);
7693 xop1
= TREE_OPERAND (*expr_p
, 1);
7694 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop0
)))
7695 TREE_OPERAND (*expr_p
, 0) = fold_convert_loc (input_location
,
7698 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop1
)))
7699 TREE_OPERAND (*expr_p
, 1) = fold_convert_loc (input_location
,
7702 /* Continue classified as tcc_binary. */
7709 /* Classified as tcc_expression. */
7712 case POINTER_PLUS_EXPR
:
7714 enum gimplify_status r0
, r1
;
7715 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7716 post_p
, is_gimple_val
, fb_rvalue
);
7717 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7718 post_p
, is_gimple_val
, fb_rvalue
);
7719 recalculate_side_effects (*expr_p
);
7721 /* Convert &X + CST to invariant &MEM[&X, CST]. Do this
7722 after gimplifying operands - this is similar to how
7723 it would be folding all gimplified stmts on creation
7724 to have them canonicalized, which is what we eventually
7725 should do anyway. */
7726 if (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == INTEGER_CST
7727 && is_gimple_min_invariant (TREE_OPERAND (*expr_p
, 0)))
7729 *expr_p
= build_fold_addr_expr_with_type_loc
7731 fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (*expr_p
)),
7732 TREE_OPERAND (*expr_p
, 0),
7733 fold_convert (ptr_type_node
,
7734 TREE_OPERAND (*expr_p
, 1))),
7735 TREE_TYPE (*expr_p
));
7736 ret
= MIN (ret
, GS_OK
);
7742 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p
)))
7744 case tcc_comparison
:
7745 /* Handle comparison of objects of non scalar mode aggregates
7746 with a call to memcmp. It would be nice to only have to do
7747 this for variable-sized objects, but then we'd have to allow
7748 the same nest of reference nodes we allow for MODIFY_EXPR and
7751 Compare scalar mode aggregates as scalar mode values. Using
7752 memcmp for them would be very inefficient at best, and is
7753 plain wrong if bitfields are involved. */
7755 tree type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 1));
7757 /* Vector comparisons need no boolification. */
7758 if (TREE_CODE (type
) == VECTOR_TYPE
)
7760 else if (!AGGREGATE_TYPE_P (type
))
7762 tree org_type
= TREE_TYPE (*expr_p
);
7763 *expr_p
= gimple_boolify (*expr_p
);
7764 if (!useless_type_conversion_p (org_type
,
7765 TREE_TYPE (*expr_p
)))
7767 *expr_p
= fold_convert_loc (input_location
,
7774 else if (TYPE_MODE (type
) != BLKmode
)
7775 ret
= gimplify_scalar_mode_aggregate_compare (expr_p
);
7777 ret
= gimplify_variable_sized_compare (expr_p
);
7782 /* If *EXPR_P does not need to be special-cased, handle it
7783 according to its class. */
7785 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7786 post_p
, is_gimple_val
, fb_rvalue
);
7792 enum gimplify_status r0
, r1
;
7794 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7795 post_p
, is_gimple_val
, fb_rvalue
);
7796 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7797 post_p
, is_gimple_val
, fb_rvalue
);
7805 enum gimplify_status r0
, r1
, r2
;
7807 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7808 post_p
, is_gimple_val
, fb_rvalue
);
7809 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7810 post_p
, is_gimple_val
, fb_rvalue
);
7811 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
7812 post_p
, is_gimple_val
, fb_rvalue
);
7814 ret
= MIN (MIN (r0
, r1
), r2
);
7818 case tcc_declaration
:
7821 goto dont_recalculate
;
7827 recalculate_side_effects (*expr_p
);
7833 gcc_assert (*expr_p
|| ret
!= GS_OK
);
7835 while (ret
== GS_OK
);
7837 /* If we encountered an error_mark somewhere nested inside, either
7838 stub out the statement or propagate the error back out. */
7839 if (ret
== GS_ERROR
)
7846 /* This was only valid as a return value from the langhook, which
7847 we handled. Make sure it doesn't escape from any other context. */
7848 gcc_assert (ret
!= GS_UNHANDLED
);
7850 if (fallback
== fb_none
&& *expr_p
&& !is_gimple_stmt (*expr_p
))
7852 /* We aren't looking for a value, and we don't have a valid
7853 statement. If it doesn't have side-effects, throw it away. */
7854 if (!TREE_SIDE_EFFECTS (*expr_p
))
7856 else if (!TREE_THIS_VOLATILE (*expr_p
))
7858 /* This is probably a _REF that contains something nested that
7859 has side effects. Recurse through the operands to find it. */
7860 enum tree_code code
= TREE_CODE (*expr_p
);
7867 case VIEW_CONVERT_EXPR
:
7868 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7869 gimple_test_f
, fallback
);
7873 case ARRAY_RANGE_REF
:
7874 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7875 gimple_test_f
, fallback
);
7876 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
7877 gimple_test_f
, fallback
);
7881 /* Anything else with side-effects must be converted to
7882 a valid statement before we get here. */
7888 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p
))
7889 && TYPE_MODE (TREE_TYPE (*expr_p
)) != BLKmode
)
7891 /* Historically, the compiler has treated a bare reference
7892 to a non-BLKmode volatile lvalue as forcing a load. */
7893 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p
));
7895 /* Normally, we do not want to create a temporary for a
7896 TREE_ADDRESSABLE type because such a type should not be
7897 copied by bitwise-assignment. However, we make an
7898 exception here, as all we are doing here is ensuring that
7899 we read the bytes that make up the type. We use
7900 create_tmp_var_raw because create_tmp_var will abort when
7901 given a TREE_ADDRESSABLE type. */
7902 tree tmp
= create_tmp_var_raw (type
, "vol");
7903 gimple_add_tmp_var (tmp
);
7904 gimplify_assign (tmp
, *expr_p
, pre_p
);
7908 /* We can't do anything useful with a volatile reference to
7909 an incomplete type, so just throw it away. Likewise for
7910 a BLKmode type, since any implicit inner load should
7911 already have been turned into an explicit one by the
7912 gimplification process. */
7916 /* If we are gimplifying at the statement level, we're done. Tack
7917 everything together and return. */
7918 if (fallback
== fb_none
|| is_statement
)
7920 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
7921 it out for GC to reclaim it. */
7922 *expr_p
= NULL_TREE
;
7924 if (!gimple_seq_empty_p (internal_pre
)
7925 || !gimple_seq_empty_p (internal_post
))
7927 gimplify_seq_add_seq (&internal_pre
, internal_post
);
7928 gimplify_seq_add_seq (pre_p
, internal_pre
);
7931 /* The result of gimplifying *EXPR_P is going to be the last few
7932 statements in *PRE_P and *POST_P. Add location information
7933 to all the statements that were added by the gimplification
7935 if (!gimple_seq_empty_p (*pre_p
))
7936 annotate_all_with_location_after (*pre_p
, pre_last_gsi
, input_location
);
7938 if (!gimple_seq_empty_p (*post_p
))
7939 annotate_all_with_location_after (*post_p
, post_last_gsi
,
7945 #ifdef ENABLE_GIMPLE_CHECKING
7948 enum tree_code code
= TREE_CODE (*expr_p
);
7949 /* These expressions should already be in gimple IR form. */
7950 gcc_assert (code
!= MODIFY_EXPR
7952 && code
!= BIND_EXPR
7953 && code
!= CATCH_EXPR
7954 && (code
!= COND_EXPR
|| gimplify_ctxp
->allow_rhs_cond_expr
)
7955 && code
!= EH_FILTER_EXPR
7956 && code
!= GOTO_EXPR
7957 && code
!= LABEL_EXPR
7958 && code
!= LOOP_EXPR
7959 && code
!= SWITCH_EXPR
7960 && code
!= TRY_FINALLY_EXPR
7961 && code
!= OMP_CRITICAL
7963 && code
!= OMP_MASTER
7964 && code
!= OMP_ORDERED
7965 && code
!= OMP_PARALLEL
7966 && code
!= OMP_SECTIONS
7967 && code
!= OMP_SECTION
7968 && code
!= OMP_SINGLE
);
7972 /* Otherwise we're gimplifying a subexpression, so the resulting
7973 value is interesting. If it's a valid operand that matches
7974 GIMPLE_TEST_F, we're done. Unless we are handling some
7975 post-effects internally; if that's the case, we need to copy into
7976 a temporary before adding the post-effects to POST_P. */
7977 if (gimple_seq_empty_p (internal_post
) && (*gimple_test_f
) (*expr_p
))
7980 /* Otherwise, we need to create a new temporary for the gimplified
7983 /* We can't return an lvalue if we have an internal postqueue. The
7984 object the lvalue refers to would (probably) be modified by the
7985 postqueue; we need to copy the value out first, which means an
7987 if ((fallback
& fb_lvalue
)
7988 && gimple_seq_empty_p (internal_post
)
7989 && is_gimple_addressable (*expr_p
))
7991 /* An lvalue will do. Take the address of the expression, store it
7992 in a temporary, and replace the expression with an INDIRECT_REF of
7994 tmp
= build_fold_addr_expr_loc (input_location
, *expr_p
);
7995 gimplify_expr (&tmp
, pre_p
, post_p
, is_gimple_reg
, fb_rvalue
);
7996 *expr_p
= build_simple_mem_ref (tmp
);
7998 else if ((fallback
& fb_rvalue
) && is_gimple_reg_rhs_or_call (*expr_p
))
8000 /* An rvalue will do. Assign the gimplified expression into a
8001 new temporary TMP and replace the original expression with
8002 TMP. First, make sure that the expression has a type so that
8003 it can be assigned into a temporary. */
8004 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p
)));
8005 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
8009 #ifdef ENABLE_GIMPLE_CHECKING
8010 if (!(fallback
& fb_mayfail
))
8012 fprintf (stderr
, "gimplification failed:\n");
8013 print_generic_expr (stderr
, *expr_p
, 0);
8014 debug_tree (*expr_p
);
8015 internal_error ("gimplification failed");
8018 gcc_assert (fallback
& fb_mayfail
);
8020 /* If this is an asm statement, and the user asked for the
8021 impossible, don't die. Fail and let gimplify_asm_expr
8027 /* Make sure the temporary matches our predicate. */
8028 gcc_assert ((*gimple_test_f
) (*expr_p
));
8030 if (!gimple_seq_empty_p (internal_post
))
8032 annotate_all_with_location (internal_post
, input_location
);
8033 gimplify_seq_add_seq (pre_p
, internal_post
);
8037 input_location
= saved_location
;
8041 /* Look through TYPE for variable-sized objects and gimplify each such
8042 size that we find. Add to LIST_P any statements generated. */
8045 gimplify_type_sizes (tree type
, gimple_seq
*list_p
)
8049 if (type
== NULL
|| type
== error_mark_node
)
8052 /* We first do the main variant, then copy into any other variants. */
8053 type
= TYPE_MAIN_VARIANT (type
);
8055 /* Avoid infinite recursion. */
8056 if (TYPE_SIZES_GIMPLIFIED (type
))
8059 TYPE_SIZES_GIMPLIFIED (type
) = 1;
8061 switch (TREE_CODE (type
))
8067 case FIXED_POINT_TYPE
:
8068 gimplify_one_sizepos (&TYPE_MIN_VALUE (type
), list_p
);
8069 gimplify_one_sizepos (&TYPE_MAX_VALUE (type
), list_p
);
8071 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8073 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (type
);
8074 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (type
);
8079 /* These types may not have declarations, so handle them here. */
8080 gimplify_type_sizes (TREE_TYPE (type
), list_p
);
8081 gimplify_type_sizes (TYPE_DOMAIN (type
), list_p
);
8082 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
8083 with assigned stack slots, for -O1+ -g they should be tracked
8085 if (!(TYPE_NAME (type
)
8086 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
8087 && DECL_IGNORED_P (TYPE_NAME (type
)))
8088 && TYPE_DOMAIN (type
)
8089 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type
)))
8091 t
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
8092 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8093 DECL_IGNORED_P (t
) = 0;
8094 t
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
8095 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8096 DECL_IGNORED_P (t
) = 0;
8102 case QUAL_UNION_TYPE
:
8103 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
8104 if (TREE_CODE (field
) == FIELD_DECL
)
8106 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field
), list_p
);
8107 gimplify_one_sizepos (&DECL_SIZE (field
), list_p
);
8108 gimplify_one_sizepos (&DECL_SIZE_UNIT (field
), list_p
);
8109 gimplify_type_sizes (TREE_TYPE (field
), list_p
);
8114 case REFERENCE_TYPE
:
8115 /* We used to recurse on the pointed-to type here, which turned out to
8116 be incorrect because its definition might refer to variables not
8117 yet initialized at this point if a forward declaration is involved.
8119 It was actually useful for anonymous pointed-to types to ensure
8120 that the sizes evaluation dominates every possible later use of the
8121 values. Restricting to such types here would be safe since there
8122 is no possible forward declaration around, but would introduce an
8123 undesirable middle-end semantic to anonymity. We then defer to
8124 front-ends the responsibility of ensuring that the sizes are
8125 evaluated both early and late enough, e.g. by attaching artificial
8126 type declarations to the tree. */
8133 gimplify_one_sizepos (&TYPE_SIZE (type
), list_p
);
8134 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type
), list_p
);
8136 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8138 TYPE_SIZE (t
) = TYPE_SIZE (type
);
8139 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (type
);
8140 TYPE_SIZES_GIMPLIFIED (t
) = 1;
8144 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
8145 a size or position, has had all of its SAVE_EXPRs evaluated.
8146 We add any required statements to *STMT_P. */
8149 gimplify_one_sizepos (tree
*expr_p
, gimple_seq
*stmt_p
)
8151 tree expr
= *expr_p
;
8153 /* We don't do anything if the value isn't there, is constant, or contains
8154 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
8155 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
8156 will want to replace it with a new variable, but that will cause problems
8157 if this type is from outside the function. It's OK to have that here. */
8158 if (is_gimple_sizepos (expr
))
8161 *expr_p
= unshare_expr (expr
);
8163 gimplify_expr (expr_p
, stmt_p
, NULL
, is_gimple_val
, fb_rvalue
);
8166 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
8167 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
8168 is true, also gimplify the parameters. */
8171 gimplify_body (tree fndecl
, bool do_parms
)
8173 location_t saved_location
= input_location
;
8174 gimple_seq parm_stmts
, seq
;
8176 struct gimplify_ctx gctx
;
8177 struct cgraph_node
*cgn
;
8179 timevar_push (TV_TREE_GIMPLIFY
);
8181 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
8183 default_rtl_profile ();
8185 gcc_assert (gimplify_ctxp
== NULL
);
8186 push_gimplify_context (&gctx
);
8188 /* Unshare most shared trees in the body and in that of any nested functions.
8189 It would seem we don't have to do this for nested functions because
8190 they are supposed to be output and then the outer function gimplified
8191 first, but the g++ front end doesn't always do it that way. */
8192 unshare_body (fndecl
);
8193 unvisit_body (fndecl
);
8195 cgn
= cgraph_get_node (fndecl
);
8196 if (cgn
&& cgn
->origin
)
8197 nonlocal_vlas
= pointer_set_create ();
8199 /* Make sure input_location isn't set to something weird. */
8200 input_location
= DECL_SOURCE_LOCATION (fndecl
);
8202 /* Resolve callee-copies. This has to be done before processing
8203 the body so that DECL_VALUE_EXPR gets processed correctly. */
8204 parm_stmts
= do_parms
? gimplify_parameters () : NULL
;
8206 /* Gimplify the function's body. */
8208 gimplify_stmt (&DECL_SAVED_TREE (fndecl
), &seq
);
8209 outer_bind
= gimple_seq_first_stmt (seq
);
8212 outer_bind
= gimple_build_nop ();
8213 gimplify_seq_add_stmt (&seq
, outer_bind
);
8216 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
8217 not the case, wrap everything in a GIMPLE_BIND to make it so. */
8218 if (gimple_code (outer_bind
) == GIMPLE_BIND
8219 && gimple_seq_first (seq
) == gimple_seq_last (seq
))
8222 outer_bind
= gimple_build_bind (NULL_TREE
, seq
, NULL
);
8224 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
8226 /* If we had callee-copies statements, insert them at the beginning
8227 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
8228 if (!gimple_seq_empty_p (parm_stmts
))
8232 gimplify_seq_add_seq (&parm_stmts
, gimple_bind_body (outer_bind
));
8233 gimple_bind_set_body (outer_bind
, parm_stmts
);
8235 for (parm
= DECL_ARGUMENTS (current_function_decl
);
8236 parm
; parm
= DECL_CHAIN (parm
))
8237 if (DECL_HAS_VALUE_EXPR_P (parm
))
8239 DECL_HAS_VALUE_EXPR_P (parm
) = 0;
8240 DECL_IGNORED_P (parm
) = 0;
8246 pointer_set_destroy (nonlocal_vlas
);
8247 nonlocal_vlas
= NULL
;
8250 pop_gimplify_context (outer_bind
);
8251 gcc_assert (gimplify_ctxp
== NULL
);
8253 #ifdef ENABLE_CHECKING
8255 verify_gimple_in_seq (gimple_bind_body (outer_bind
));
8258 timevar_pop (TV_TREE_GIMPLIFY
);
8259 input_location
= saved_location
;
8264 typedef char *char_p
; /* For DEF_VEC_P. */
8266 /* Return whether we should exclude FNDECL from instrumentation. */
8269 flag_instrument_functions_exclude_p (tree fndecl
)
8273 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_functions
;
8274 if (v
&& v
->length () > 0)
8280 name
= lang_hooks
.decl_printable_name (fndecl
, 0);
8281 FOR_EACH_VEC_ELT (*v
, i
, s
)
8282 if (strstr (name
, s
) != NULL
)
8286 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_files
;
8287 if (v
&& v
->length () > 0)
8293 name
= DECL_SOURCE_FILE (fndecl
);
8294 FOR_EACH_VEC_ELT (*v
, i
, s
)
8295 if (strstr (name
, s
) != NULL
)
8302 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
8303 node for the function we want to gimplify.
8305 Return the sequence of GIMPLE statements corresponding to the body
8309 gimplify_function_tree (tree fndecl
)
8315 gcc_assert (!gimple_body (fndecl
));
8317 if (DECL_STRUCT_FUNCTION (fndecl
))
8318 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
8320 push_struct_function (fndecl
);
8322 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
8324 /* Preliminarily mark non-addressed complex variables as eligible
8325 for promotion to gimple registers. We'll transform their uses
8327 if ((TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
8328 || TREE_CODE (TREE_TYPE (parm
)) == VECTOR_TYPE
)
8329 && !TREE_THIS_VOLATILE (parm
)
8330 && !needs_to_live_in_memory (parm
))
8331 DECL_GIMPLE_REG_P (parm
) = 1;
8334 ret
= DECL_RESULT (fndecl
);
8335 if ((TREE_CODE (TREE_TYPE (ret
)) == COMPLEX_TYPE
8336 || TREE_CODE (TREE_TYPE (ret
)) == VECTOR_TYPE
)
8337 && !needs_to_live_in_memory (ret
))
8338 DECL_GIMPLE_REG_P (ret
) = 1;
8340 bind
= gimplify_body (fndecl
, true);
8342 /* The tree body of the function is no longer needed, replace it
8343 with the new GIMPLE body. */
8345 gimple_seq_add_stmt (&seq
, bind
);
8346 gimple_set_body (fndecl
, seq
);
8348 /* If we're instrumenting function entry/exit, then prepend the call to
8349 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
8350 catch the exit hook. */
8351 /* ??? Add some way to ignore exceptions for this TFE. */
8352 if (flag_instrument_function_entry_exit
8353 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
)
8354 && !flag_instrument_functions_exclude_p (fndecl
))
8359 gimple_seq cleanup
= NULL
, body
= NULL
;
8363 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
8364 call
= gimple_build_call (x
, 1, integer_zero_node
);
8365 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
8366 gimple_call_set_lhs (call
, tmp_var
);
8367 gimplify_seq_add_stmt (&cleanup
, call
);
8368 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT
);
8369 call
= gimple_build_call (x
, 2,
8370 build_fold_addr_expr (current_function_decl
),
8372 gimplify_seq_add_stmt (&cleanup
, call
);
8373 tf
= gimple_build_try (seq
, cleanup
, GIMPLE_TRY_FINALLY
);
8375 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
8376 call
= gimple_build_call (x
, 1, integer_zero_node
);
8377 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
8378 gimple_call_set_lhs (call
, tmp_var
);
8379 gimplify_seq_add_stmt (&body
, call
);
8380 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER
);
8381 call
= gimple_build_call (x
, 2,
8382 build_fold_addr_expr (current_function_decl
),
8384 gimplify_seq_add_stmt (&body
, call
);
8385 gimplify_seq_add_stmt (&body
, tf
);
8386 new_bind
= gimple_build_bind (NULL
, body
, gimple_bind_block (bind
));
8387 /* Clear the block for BIND, since it is no longer directly inside
8388 the function, but within a try block. */
8389 gimple_bind_set_block (bind
, NULL
);
8391 /* Replace the current function body with the body
8392 wrapped in the try/finally TF. */
8394 gimple_seq_add_stmt (&seq
, new_bind
);
8395 gimple_set_body (fndecl
, seq
);
8398 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
8399 cfun
->curr_properties
= PROP_gimple_any
;
8404 /* Some transformations like inlining may invalidate the GIMPLE form
8405 for operands. This function traverses all the operands in STMT and
8406 gimplifies anything that is not a valid gimple operand. Any new
8407 GIMPLE statements are inserted before *GSI_P. */
8410 gimple_regimplify_operands (gimple stmt
, gimple_stmt_iterator
*gsi_p
)
8414 gimple_seq pre
= NULL
;
8415 gimple post_stmt
= NULL
;
8416 struct gimplify_ctx gctx
;
8418 push_gimplify_context (&gctx
);
8419 gimplify_ctxp
->into_ssa
= gimple_in_ssa_p (cfun
);
8421 switch (gimple_code (stmt
))
8424 gimplify_expr (gimple_cond_lhs_ptr (stmt
), &pre
, NULL
,
8425 is_gimple_val
, fb_rvalue
);
8426 gimplify_expr (gimple_cond_rhs_ptr (stmt
), &pre
, NULL
,
8427 is_gimple_val
, fb_rvalue
);
8430 gimplify_expr (gimple_switch_index_ptr (stmt
), &pre
, NULL
,
8431 is_gimple_val
, fb_rvalue
);
8433 case GIMPLE_OMP_ATOMIC_LOAD
:
8434 gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt
), &pre
, NULL
,
8435 is_gimple_val
, fb_rvalue
);
8439 size_t i
, noutputs
= gimple_asm_noutputs (stmt
);
8440 const char *constraint
, **oconstraints
;
8441 bool allows_mem
, allows_reg
, is_inout
;
8444 = (const char **) alloca ((noutputs
) * sizeof (const char *));
8445 for (i
= 0; i
< noutputs
; i
++)
8447 tree op
= gimple_asm_output_op (stmt
, i
);
8448 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op
)));
8449 oconstraints
[i
] = constraint
;
8450 parse_output_constraint (&constraint
, i
, 0, 0, &allows_mem
,
8451 &allows_reg
, &is_inout
);
8452 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8453 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
8454 fb_lvalue
| fb_mayfail
);
8456 for (i
= 0; i
< gimple_asm_ninputs (stmt
); i
++)
8458 tree op
= gimple_asm_input_op (stmt
, i
);
8459 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op
)));
8460 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
8461 oconstraints
, &allows_mem
, &allows_reg
);
8462 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op
))) && allows_mem
)
8464 if (!allows_reg
&& allows_mem
)
8465 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8466 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
8468 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8469 is_gimple_asm_val
, fb_rvalue
);
8474 /* NOTE: We start gimplifying operands from last to first to
8475 make sure that side-effects on the RHS of calls, assignments
8476 and ASMs are executed before the LHS. The ordering is not
8477 important for other statements. */
8478 num_ops
= gimple_num_ops (stmt
);
8479 for (i
= num_ops
; i
> 0; i
--)
8481 tree op
= gimple_op (stmt
, i
- 1);
8482 if (op
== NULL_TREE
)
8484 if (i
== 1 && (is_gimple_call (stmt
) || is_gimple_assign (stmt
)))
8485 gimplify_expr (&op
, &pre
, NULL
, is_gimple_lvalue
, fb_lvalue
);
8487 && is_gimple_assign (stmt
)
8489 && get_gimple_rhs_class (gimple_expr_code (stmt
))
8490 == GIMPLE_SINGLE_RHS
)
8491 gimplify_expr (&op
, &pre
, NULL
,
8492 rhs_predicate_for (gimple_assign_lhs (stmt
)),
8494 else if (i
== 2 && is_gimple_call (stmt
))
8496 if (TREE_CODE (op
) == FUNCTION_DECL
)
8498 gimplify_expr (&op
, &pre
, NULL
, is_gimple_call_addr
, fb_rvalue
);
8501 gimplify_expr (&op
, &pre
, NULL
, is_gimple_val
, fb_rvalue
);
8502 gimple_set_op (stmt
, i
- 1, op
);
8505 lhs
= gimple_get_lhs (stmt
);
8506 /* If the LHS changed it in a way that requires a simple RHS,
8507 create temporary. */
8508 if (lhs
&& !is_gimple_reg (lhs
))
8510 bool need_temp
= false;
8512 if (is_gimple_assign (stmt
)
8514 && get_gimple_rhs_class (gimple_expr_code (stmt
))
8515 == GIMPLE_SINGLE_RHS
)
8516 gimplify_expr (gimple_assign_rhs1_ptr (stmt
), &pre
, NULL
,
8517 rhs_predicate_for (gimple_assign_lhs (stmt
)),
8519 else if (is_gimple_reg (lhs
))
8521 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
8523 if (is_gimple_call (stmt
))
8525 i
= gimple_call_flags (stmt
);
8526 if ((i
& ECF_LOOPING_CONST_OR_PURE
)
8527 || !(i
& (ECF_CONST
| ECF_PURE
)))
8530 if (stmt_can_throw_internal (stmt
))
8536 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
8538 else if (TYPE_MODE (TREE_TYPE (lhs
)) != BLKmode
)
8540 if (is_gimple_call (stmt
))
8542 tree fndecl
= gimple_call_fndecl (stmt
);
8544 if (!aggregate_value_p (TREE_TYPE (lhs
), fndecl
)
8545 && !(fndecl
&& DECL_RESULT (fndecl
)
8546 && DECL_BY_REFERENCE (DECL_RESULT (fndecl
))))
8555 tree temp
= create_tmp_reg (TREE_TYPE (lhs
), NULL
);
8556 if (gimple_in_ssa_p (cfun
))
8557 temp
= make_ssa_name (temp
, NULL
);
8558 gimple_set_lhs (stmt
, temp
);
8559 post_stmt
= gimple_build_assign (lhs
, temp
);
8560 if (TREE_CODE (lhs
) == SSA_NAME
)
8561 SSA_NAME_DEF_STMT (lhs
) = post_stmt
;
8567 if (!gimple_seq_empty_p (pre
))
8568 gsi_insert_seq_before (gsi_p
, pre
, GSI_SAME_STMT
);
8570 gsi_insert_after (gsi_p
, post_stmt
, GSI_NEW_STMT
);
8572 pop_gimplify_context (NULL
);
8575 /* Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
8576 the predicate that will hold for the result. If VAR is not NULL, make the
8577 base variable of the final destination be VAR if suitable. */
8580 force_gimple_operand_1 (tree expr
, gimple_seq
*stmts
,
8581 gimple_predicate gimple_test_f
, tree var
)
8583 enum gimplify_status ret
;
8584 struct gimplify_ctx gctx
;
8588 /* gimple_test_f might be more strict than is_gimple_val, make
8589 sure we pass both. Just checking gimple_test_f doesn't work
8590 because most gimple predicates do not work recursively. */
8591 if (is_gimple_val (expr
)
8592 && (*gimple_test_f
) (expr
))
8595 push_gimplify_context (&gctx
);
8596 gimplify_ctxp
->into_ssa
= gimple_in_ssa_p (cfun
);
8597 gimplify_ctxp
->allow_rhs_cond_expr
= true;
8601 if (gimplify_ctxp
->into_ssa
8602 && is_gimple_reg (var
))
8603 var
= make_ssa_name (var
, NULL
);
8604 expr
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, expr
);
8607 if (TREE_CODE (expr
) != MODIFY_EXPR
8608 && TREE_TYPE (expr
) == void_type_node
)
8610 gimplify_and_add (expr
, stmts
);
8615 ret
= gimplify_expr (&expr
, stmts
, NULL
, gimple_test_f
, fb_rvalue
);
8616 gcc_assert (ret
!= GS_ERROR
);
8619 pop_gimplify_context (NULL
);
8624 /* Expand EXPR to list of gimple statements STMTS. If SIMPLE is true,
8625 force the result to be either ssa_name or an invariant, otherwise
8626 just force it to be a rhs expression. If VAR is not NULL, make the
8627 base variable of the final destination be VAR if suitable. */
8630 force_gimple_operand (tree expr
, gimple_seq
*stmts
, bool simple
, tree var
)
8632 return force_gimple_operand_1 (expr
, stmts
,
8633 simple
? is_gimple_val
: is_gimple_reg_rhs
,
8637 /* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
8638 and VAR. If some statements are produced, emits them at GSI.
8639 If BEFORE is true. the statements are appended before GSI, otherwise
8640 they are appended after it. M specifies the way GSI moves after
8641 insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values). */
8644 force_gimple_operand_gsi_1 (gimple_stmt_iterator
*gsi
, tree expr
,
8645 gimple_predicate gimple_test_f
,
8646 tree var
, bool before
,
8647 enum gsi_iterator_update m
)
8651 expr
= force_gimple_operand_1 (expr
, &stmts
, gimple_test_f
, var
);
8653 if (!gimple_seq_empty_p (stmts
))
8656 gsi_insert_seq_before (gsi
, stmts
, m
);
8658 gsi_insert_seq_after (gsi
, stmts
, m
);
8664 /* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
8665 If SIMPLE is true, force the result to be either ssa_name or an invariant,
8666 otherwise just force it to be a rhs expression. If some statements are
8667 produced, emits them at GSI. If BEFORE is true, the statements are
8668 appended before GSI, otherwise they are appended after it. M specifies
8669 the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
8670 are the usual values). */
8673 force_gimple_operand_gsi (gimple_stmt_iterator
*gsi
, tree expr
,
8674 bool simple_p
, tree var
, bool before
,
8675 enum gsi_iterator_update m
)
8677 return force_gimple_operand_gsi_1 (gsi
, expr
,
8679 ? is_gimple_val
: is_gimple_reg_rhs
,
8684 #include "gt-gimplify.h"