1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002-2013 Free Software Foundation, Inc.
4 Major work done by Sebastian Pop <s.pop@laposte.net>,
5 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
29 #include "tree-iterator.h"
30 #include "tree-inline.h"
31 #include "tree-pretty-print.h"
32 #include "langhooks.h"
40 #include "diagnostic-core.h"
42 #include "pointer-set.h"
43 #include "splay-tree.h"
46 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */
47 #include "tree-pass.h" /* FIXME: only for PROP_gimple_any */
49 enum gimplify_omp_var_data
55 GOVD_FIRSTPRIVATE
= 16,
56 GOVD_LASTPRIVATE
= 32,
59 GOVD_DEBUG_PRIVATE
= 256,
60 GOVD_PRIVATE_OUTER_REF
= 512,
62 GOVD_DATA_SHARE_CLASS
= (GOVD_SHARED
| GOVD_PRIVATE
| GOVD_FIRSTPRIVATE
63 | GOVD_LASTPRIVATE
| GOVD_REDUCTION
| GOVD_LINEAR
73 ORT_COMBINED_PARALLEL
= 3,
78 struct gimplify_omp_ctx
80 struct gimplify_omp_ctx
*outer_context
;
82 struct pointer_set_t
*privatized_types
;
84 enum omp_clause_default_kind default_kind
;
85 enum omp_region_type region_type
;
88 static struct gimplify_ctx
*gimplify_ctxp
;
89 static struct gimplify_omp_ctx
*gimplify_omp_ctxp
;
92 /* Forward declaration. */
93 static enum gimplify_status
gimplify_compound_expr (tree
*, gimple_seq
*, bool);
95 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
96 form and we don't do any syntax checking. */
99 mark_addressable (tree x
)
101 while (handled_component_p (x
))
102 x
= TREE_OPERAND (x
, 0);
103 if (TREE_CODE (x
) == MEM_REF
104 && TREE_CODE (TREE_OPERAND (x
, 0)) == ADDR_EXPR
)
105 x
= TREE_OPERAND (TREE_OPERAND (x
, 0), 0);
106 if (TREE_CODE (x
) != VAR_DECL
107 && TREE_CODE (x
) != PARM_DECL
108 && TREE_CODE (x
) != RESULT_DECL
)
110 TREE_ADDRESSABLE (x
) = 1;
112 /* Also mark the artificial SSA_NAME that points to the partition of X. */
113 if (TREE_CODE (x
) == VAR_DECL
114 && !DECL_EXTERNAL (x
)
116 && cfun
->gimple_df
!= NULL
117 && cfun
->gimple_df
->decls_to_pointers
!= NULL
)
120 = pointer_map_contains (cfun
->gimple_df
->decls_to_pointers
, x
);
122 TREE_ADDRESSABLE (*(tree
*)namep
) = 1;
126 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
127 *SEQ_P is NULL, a new sequence is allocated. This function is
128 similar to gimple_seq_add_stmt, but does not scan the operands.
129 During gimplification, we need to manipulate statement sequences
130 before the def/use vectors have been constructed. */
133 gimple_seq_add_stmt_without_update (gimple_seq
*seq_p
, gimple gs
)
135 gimple_stmt_iterator si
;
140 si
= gsi_last (*seq_p
);
141 gsi_insert_after_without_update (&si
, gs
, GSI_NEW_STMT
);
144 /* Shorter alias name for the above function for use in gimplify.c
148 gimplify_seq_add_stmt (gimple_seq
*seq_p
, gimple gs
)
150 gimple_seq_add_stmt_without_update (seq_p
, gs
);
153 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
154 NULL, a new sequence is allocated. This function is
155 similar to gimple_seq_add_seq, but does not scan the operands.
156 During gimplification, we need to manipulate statement sequences
157 before the def/use vectors have been constructed. */
160 gimplify_seq_add_seq (gimple_seq
*dst_p
, gimple_seq src
)
162 gimple_stmt_iterator si
;
167 si
= gsi_last (*dst_p
);
168 gsi_insert_seq_after_without_update (&si
, src
, GSI_NEW_STMT
);
171 /* Set up a context for the gimplifier. */
174 push_gimplify_context (struct gimplify_ctx
*c
)
176 memset (c
, '\0', sizeof (*c
));
177 c
->prev_context
= gimplify_ctxp
;
181 /* Tear down a context for the gimplifier. If BODY is non-null, then
182 put the temporaries into the outer BIND_EXPR. Otherwise, put them
185 BODY is not a sequence, but the first tuple in a sequence. */
188 pop_gimplify_context (gimple body
)
190 struct gimplify_ctx
*c
= gimplify_ctxp
;
193 && (!c
->bind_expr_stack
.exists ()
194 || c
->bind_expr_stack
.is_empty ()));
195 c
->bind_expr_stack
.release ();
196 gimplify_ctxp
= c
->prev_context
;
199 declare_vars (c
->temps
, body
, false);
201 record_vars (c
->temps
);
203 if (c
->temp_htab
.is_created ())
204 c
->temp_htab
.dispose ();
207 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
210 gimple_push_bind_expr (gimple gimple_bind
)
212 gimplify_ctxp
->bind_expr_stack
.reserve (8);
213 gimplify_ctxp
->bind_expr_stack
.safe_push (gimple_bind
);
216 /* Pop the first element off the stack of bindings. */
219 gimple_pop_bind_expr (void)
221 gimplify_ctxp
->bind_expr_stack
.pop ();
224 /* Return the first element of the stack of bindings. */
227 gimple_current_bind_expr (void)
229 return gimplify_ctxp
->bind_expr_stack
.last ();
232 /* Return the stack of bindings created during gimplification. */
235 gimple_bind_expr_stack (void)
237 return gimplify_ctxp
->bind_expr_stack
;
240 /* Return true iff there is a COND_EXPR between us and the innermost
241 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
244 gimple_conditional_context (void)
246 return gimplify_ctxp
->conditions
> 0;
249 /* Note that we've entered a COND_EXPR. */
252 gimple_push_condition (void)
254 #ifdef ENABLE_GIMPLE_CHECKING
255 if (gimplify_ctxp
->conditions
== 0)
256 gcc_assert (gimple_seq_empty_p (gimplify_ctxp
->conditional_cleanups
));
258 ++(gimplify_ctxp
->conditions
);
261 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
262 now, add any conditional cleanups we've seen to the prequeue. */
265 gimple_pop_condition (gimple_seq
*pre_p
)
267 int conds
= --(gimplify_ctxp
->conditions
);
269 gcc_assert (conds
>= 0);
272 gimplify_seq_add_seq (pre_p
, gimplify_ctxp
->conditional_cleanups
);
273 gimplify_ctxp
->conditional_cleanups
= NULL
;
277 /* A stable comparison routine for use with splay trees and DECLs. */
280 splay_tree_compare_decl_uid (splay_tree_key xa
, splay_tree_key xb
)
285 return DECL_UID (a
) - DECL_UID (b
);
288 /* Create a new omp construct that deals with variable remapping. */
290 static struct gimplify_omp_ctx
*
291 new_omp_context (enum omp_region_type region_type
)
293 struct gimplify_omp_ctx
*c
;
295 c
= XCNEW (struct gimplify_omp_ctx
);
296 c
->outer_context
= gimplify_omp_ctxp
;
297 c
->variables
= splay_tree_new (splay_tree_compare_decl_uid
, 0, 0);
298 c
->privatized_types
= pointer_set_create ();
299 c
->location
= input_location
;
300 c
->region_type
= region_type
;
301 if ((region_type
& ORT_TASK
) == 0)
302 c
->default_kind
= OMP_CLAUSE_DEFAULT_SHARED
;
304 c
->default_kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
309 /* Destroy an omp construct that deals with variable remapping. */
312 delete_omp_context (struct gimplify_omp_ctx
*c
)
314 splay_tree_delete (c
->variables
);
315 pointer_set_destroy (c
->privatized_types
);
319 static void omp_add_variable (struct gimplify_omp_ctx
*, tree
, unsigned int);
320 static bool omp_notice_variable (struct gimplify_omp_ctx
*, tree
, bool);
322 /* Both gimplify the statement T and append it to *SEQ_P. This function
323 behaves exactly as gimplify_stmt, but you don't have to pass T as a
327 gimplify_and_add (tree t
, gimple_seq
*seq_p
)
329 gimplify_stmt (&t
, seq_p
);
332 /* Gimplify statement T into sequence *SEQ_P, and return the first
333 tuple in the sequence of generated tuples for this statement.
334 Return NULL if gimplifying T produced no tuples. */
337 gimplify_and_return_first (tree t
, gimple_seq
*seq_p
)
339 gimple_stmt_iterator last
= gsi_last (*seq_p
);
341 gimplify_and_add (t
, seq_p
);
343 if (!gsi_end_p (last
))
346 return gsi_stmt (last
);
349 return gimple_seq_first_stmt (*seq_p
);
352 /* Strip off a legitimate source ending from the input string NAME of
353 length LEN. Rather than having to know the names used by all of
354 our front ends, we strip off an ending of a period followed by
355 up to five characters. (Java uses ".class".) */
358 remove_suffix (char *name
, int len
)
362 for (i
= 2; i
< 8 && len
> i
; i
++)
364 if (name
[len
- i
] == '.')
366 name
[len
- i
] = '\0';
372 /* Create a new temporary name with PREFIX. Return an identifier. */
374 static GTY(()) unsigned int tmp_var_id_num
;
377 create_tmp_var_name (const char *prefix
)
383 char *preftmp
= ASTRDUP (prefix
);
385 remove_suffix (preftmp
, strlen (preftmp
));
386 clean_symbol_name (preftmp
);
391 ASM_FORMAT_PRIVATE_NAME (tmp_name
, prefix
? prefix
: "T", tmp_var_id_num
++);
392 return get_identifier (tmp_name
);
395 /* Create a new temporary variable declaration of type TYPE.
396 Do NOT push it into the current binding. */
399 create_tmp_var_raw (tree type
, const char *prefix
)
403 tmp_var
= build_decl (input_location
,
404 VAR_DECL
, prefix
? create_tmp_var_name (prefix
) : NULL
,
407 /* The variable was declared by the compiler. */
408 DECL_ARTIFICIAL (tmp_var
) = 1;
409 /* And we don't want debug info for it. */
410 DECL_IGNORED_P (tmp_var
) = 1;
412 /* Make the variable writable. */
413 TREE_READONLY (tmp_var
) = 0;
415 DECL_EXTERNAL (tmp_var
) = 0;
416 TREE_STATIC (tmp_var
) = 0;
417 TREE_USED (tmp_var
) = 1;
422 /* Create a new temporary variable declaration of type TYPE. DO push the
423 variable into the current binding. Further, assume that this is called
424 only from gimplification or optimization, at which point the creation of
425 certain types are bugs. */
428 create_tmp_var (tree type
, const char *prefix
)
432 /* We don't allow types that are addressable (meaning we can't make copies),
433 or incomplete. We also used to reject every variable size objects here,
434 but now support those for which a constant upper bound can be obtained.
435 The processing for variable sizes is performed in gimple_add_tmp_var,
436 point at which it really matters and possibly reached via paths not going
437 through this function, e.g. after direct calls to create_tmp_var_raw. */
438 gcc_assert (!TREE_ADDRESSABLE (type
) && COMPLETE_TYPE_P (type
));
440 tmp_var
= create_tmp_var_raw (type
, prefix
);
441 gimple_add_tmp_var (tmp_var
);
445 /* Create a new temporary variable declaration of type TYPE by calling
446 create_tmp_var and if TYPE is a vector or a complex number, mark the new
447 temporary as gimple register. */
450 create_tmp_reg (tree type
, const char *prefix
)
454 tmp
= create_tmp_var (type
, prefix
);
455 if (TREE_CODE (type
) == COMPLEX_TYPE
456 || TREE_CODE (type
) == VECTOR_TYPE
)
457 DECL_GIMPLE_REG_P (tmp
) = 1;
462 /* Returns true iff T is a valid RHS for an assignment to a renamed
463 user -- or front-end generated artificial -- variable. */
466 is_gimple_reg_rhs (tree t
)
468 return get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
;
471 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
472 LHS, or for a call argument. */
475 is_gimple_mem_rhs (tree t
)
477 /* If we're dealing with a renamable type, either source or dest must be
478 a renamed variable. */
479 if (is_gimple_reg_type (TREE_TYPE (t
)))
480 return is_gimple_val (t
);
482 return is_gimple_val (t
) || is_gimple_lvalue (t
);
485 /* Return true if T is a CALL_EXPR or an expression that can be
486 assigned to a temporary. Note that this predicate should only be
487 used during gimplification. See the rationale for this in
488 gimplify_modify_expr. */
491 is_gimple_reg_rhs_or_call (tree t
)
493 return (get_gimple_rhs_class (TREE_CODE (t
)) != GIMPLE_INVALID_RHS
494 || TREE_CODE (t
) == CALL_EXPR
);
497 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
498 this predicate should only be used during gimplification. See the
499 rationale for this in gimplify_modify_expr. */
502 is_gimple_mem_rhs_or_call (tree t
)
504 /* If we're dealing with a renamable type, either source or dest must be
505 a renamed variable. */
506 if (is_gimple_reg_type (TREE_TYPE (t
)))
507 return is_gimple_val (t
);
509 return (is_gimple_val (t
) || is_gimple_lvalue (t
)
510 || TREE_CODE (t
) == CALL_EXPR
);
513 /* Create a temporary with a name derived from VAL. Subroutine of
514 lookup_tmp_var; nobody else should call this function. */
517 create_tmp_from_val (tree val
, bool is_formal
)
519 /* Drop all qualifiers and address-space information from the value type. */
520 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (val
));
521 tree var
= create_tmp_var (type
, get_name (val
));
523 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
524 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
))
525 DECL_GIMPLE_REG_P (var
) = 1;
529 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
530 an existing expression temporary. */
533 lookup_tmp_var (tree val
, bool is_formal
)
537 /* If not optimizing, never really reuse a temporary. local-alloc
538 won't allocate any variable that is used in more than one basic
539 block, which means it will go into memory, causing much extra
540 work in reload and final and poorer code generation, outweighing
541 the extra memory allocation here. */
542 if (!optimize
|| !is_formal
|| TREE_SIDE_EFFECTS (val
))
543 ret
= create_tmp_from_val (val
, is_formal
);
550 if (!gimplify_ctxp
->temp_htab
.is_created ())
551 gimplify_ctxp
->temp_htab
.create (1000);
552 slot
= gimplify_ctxp
->temp_htab
.find_slot (&elt
, INSERT
);
555 elt_p
= XNEW (elt_t
);
557 elt_p
->temp
= ret
= create_tmp_from_val (val
, is_formal
);
570 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
573 internal_get_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
578 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
579 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
580 gimplify_expr (&val
, pre_p
, post_p
, is_gimple_reg_rhs_or_call
,
583 if (gimplify_ctxp
->into_ssa
584 && is_gimple_reg_type (TREE_TYPE (val
)))
585 t
= make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val
)), NULL
);
587 t
= lookup_tmp_var (val
, is_formal
);
589 mod
= build2 (INIT_EXPR
, TREE_TYPE (t
), t
, unshare_expr (val
));
591 SET_EXPR_LOCATION (mod
, EXPR_LOC_OR_HERE (val
));
593 /* gimplify_modify_expr might want to reduce this further. */
594 gimplify_and_add (mod
, pre_p
);
600 /* Return a formal temporary variable initialized with VAL. PRE_P is as
601 in gimplify_expr. Only use this function if:
603 1) The value of the unfactored expression represented by VAL will not
604 change between the initialization and use of the temporary, and
605 2) The temporary will not be otherwise modified.
607 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
608 and #2 means it is inappropriate for && temps.
610 For other cases, use get_initialized_tmp_var instead. */
613 get_formal_tmp_var (tree val
, gimple_seq
*pre_p
)
615 return internal_get_tmp_var (val
, pre_p
, NULL
, true);
618 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
619 are as in gimplify_expr. */
622 get_initialized_tmp_var (tree val
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
624 return internal_get_tmp_var (val
, pre_p
, post_p
, false);
627 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
628 generate debug info for them; otherwise don't. */
631 declare_vars (tree vars
, gimple scope
, bool debug_info
)
638 gcc_assert (gimple_code (scope
) == GIMPLE_BIND
);
640 temps
= nreverse (last
);
642 block
= gimple_bind_block (scope
);
643 gcc_assert (!block
|| TREE_CODE (block
) == BLOCK
);
644 if (!block
|| !debug_info
)
646 DECL_CHAIN (last
) = gimple_bind_vars (scope
);
647 gimple_bind_set_vars (scope
, temps
);
651 /* We need to attach the nodes both to the BIND_EXPR and to its
652 associated BLOCK for debugging purposes. The key point here
653 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
654 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
655 if (BLOCK_VARS (block
))
656 BLOCK_VARS (block
) = chainon (BLOCK_VARS (block
), temps
);
659 gimple_bind_set_vars (scope
,
660 chainon (gimple_bind_vars (scope
), temps
));
661 BLOCK_VARS (block
) = temps
;
667 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
668 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
669 no such upper bound can be obtained. */
672 force_constant_size (tree var
)
674 /* The only attempt we make is by querying the maximum size of objects
675 of the variable's type. */
677 HOST_WIDE_INT max_size
;
679 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
681 max_size
= max_int_size_in_bytes (TREE_TYPE (var
));
683 gcc_assert (max_size
>= 0);
686 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var
)), max_size
);
688 = build_int_cst (TREE_TYPE (DECL_SIZE (var
)), max_size
* BITS_PER_UNIT
);
691 /* Push the temporary variable TMP into the current binding. */
694 gimple_add_tmp_var (tree tmp
)
696 gcc_assert (!DECL_CHAIN (tmp
) && !DECL_SEEN_IN_BIND_EXPR_P (tmp
));
698 /* Later processing assumes that the object size is constant, which might
699 not be true at this point. Force the use of a constant upper bound in
701 if (!host_integerp (DECL_SIZE_UNIT (tmp
), 1))
702 force_constant_size (tmp
);
704 DECL_CONTEXT (tmp
) = current_function_decl
;
705 DECL_SEEN_IN_BIND_EXPR_P (tmp
) = 1;
709 DECL_CHAIN (tmp
) = gimplify_ctxp
->temps
;
710 gimplify_ctxp
->temps
= tmp
;
712 /* Mark temporaries local within the nearest enclosing parallel. */
713 if (gimplify_omp_ctxp
)
715 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
717 && (ctx
->region_type
== ORT_WORKSHARE
718 || ctx
->region_type
== ORT_SIMD
))
719 ctx
= ctx
->outer_context
;
721 omp_add_variable (ctx
, tmp
, GOVD_LOCAL
| GOVD_SEEN
);
730 /* This case is for nested functions. We need to expose the locals
732 body_seq
= gimple_body (current_function_decl
);
733 declare_vars (tmp
, gimple_seq_first_stmt (body_seq
), false);
737 /* Determine whether to assign a location to the statement GS. */
740 should_carry_location_p (gimple gs
)
742 /* Don't emit a line note for a label. We particularly don't want to
743 emit one for the break label, since it doesn't actually correspond
744 to the beginning of the loop/switch. */
745 if (gimple_code (gs
) == GIMPLE_LABEL
)
751 /* Return true if a location should not be emitted for this statement
752 by annotate_one_with_location. */
755 gimple_do_not_emit_location_p (gimple g
)
757 return gimple_plf (g
, GF_PLF_1
);
760 /* Mark statement G so a location will not be emitted by
761 annotate_one_with_location. */
764 gimple_set_do_not_emit_location (gimple g
)
766 /* The PLF flags are initialized to 0 when a new tuple is created,
767 so no need to initialize it anywhere. */
768 gimple_set_plf (g
, GF_PLF_1
, true);
771 /* Set the location for gimple statement GS to LOCATION. */
774 annotate_one_with_location (gimple gs
, location_t location
)
776 if (!gimple_has_location (gs
)
777 && !gimple_do_not_emit_location_p (gs
)
778 && should_carry_location_p (gs
))
779 gimple_set_location (gs
, location
);
782 /* Set LOCATION for all the statements after iterator GSI in sequence
783 SEQ. If GSI is pointing to the end of the sequence, start with the
784 first statement in SEQ. */
787 annotate_all_with_location_after (gimple_seq seq
, gimple_stmt_iterator gsi
,
791 gsi
= gsi_start (seq
);
795 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
796 annotate_one_with_location (gsi_stmt (gsi
), location
);
799 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
802 annotate_all_with_location (gimple_seq stmt_p
, location_t location
)
804 gimple_stmt_iterator i
;
806 if (gimple_seq_empty_p (stmt_p
))
809 for (i
= gsi_start (stmt_p
); !gsi_end_p (i
); gsi_next (&i
))
811 gimple gs
= gsi_stmt (i
);
812 annotate_one_with_location (gs
, location
);
816 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
817 nodes that are referenced more than once in GENERIC functions. This is
818 necessary because gimplification (translation into GIMPLE) is performed
819 by modifying tree nodes in-place, so gimplication of a shared node in a
820 first context could generate an invalid GIMPLE form in a second context.
822 This is achieved with a simple mark/copy/unmark algorithm that walks the
823 GENERIC representation top-down, marks nodes with TREE_VISITED the first
824 time it encounters them, duplicates them if they already have TREE_VISITED
825 set, and finally removes the TREE_VISITED marks it has set.
827 The algorithm works only at the function level, i.e. it generates a GENERIC
828 representation of a function with no nodes shared within the function when
829 passed a GENERIC function (except for nodes that are allowed to be shared).
831 At the global level, it is also necessary to unshare tree nodes that are
832 referenced in more than one function, for the same aforementioned reason.
833 This requires some cooperation from the front-end. There are 2 strategies:
835 1. Manual unsharing. The front-end needs to call unshare_expr on every
836 expression that might end up being shared across functions.
838 2. Deep unsharing. This is an extension of regular unsharing. Instead
839 of calling unshare_expr on expressions that might be shared across
840 functions, the front-end pre-marks them with TREE_VISITED. This will
841 ensure that they are unshared on the first reference within functions
842 when the regular unsharing algorithm runs. The counterpart is that
843 this algorithm must look deeper than for manual unsharing, which is
844 specified by LANG_HOOKS_DEEP_UNSHARING.
846 If there are only few specific cases of node sharing across functions, it is
847 probably easier for a front-end to unshare the expressions manually. On the
848 contrary, if the expressions generated at the global level are as widespread
849 as expressions generated within functions, deep unsharing is very likely the
852 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
853 These nodes model computations that must be done once. If we were to
854 unshare something like SAVE_EXPR(i++), the gimplification process would
855 create wrong code. However, if DATA is non-null, it must hold a pointer
856 set that is used to unshare the subtrees of these nodes. */
859 mostly_copy_tree_r (tree
*tp
, int *walk_subtrees
, void *data
)
862 enum tree_code code
= TREE_CODE (t
);
864 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
865 copy their subtrees if we can make sure to do it only once. */
866 if (code
== SAVE_EXPR
|| code
== TARGET_EXPR
|| code
== BIND_EXPR
)
868 if (data
&& !pointer_set_insert ((struct pointer_set_t
*)data
, t
))
874 /* Stop at types, decls, constants like copy_tree_r. */
875 else if (TREE_CODE_CLASS (code
) == tcc_type
876 || TREE_CODE_CLASS (code
) == tcc_declaration
877 || TREE_CODE_CLASS (code
) == tcc_constant
878 /* We can't do anything sensible with a BLOCK used as an
879 expression, but we also can't just die when we see it
880 because of non-expression uses. So we avert our eyes
881 and cross our fingers. Silly Java. */
885 /* Cope with the statement expression extension. */
886 else if (code
== STATEMENT_LIST
)
889 /* Leave the bulk of the work to copy_tree_r itself. */
891 copy_tree_r (tp
, walk_subtrees
, NULL
);
896 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
897 If *TP has been visited already, then *TP is deeply copied by calling
898 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
901 copy_if_shared_r (tree
*tp
, int *walk_subtrees
, void *data
)
904 enum tree_code code
= TREE_CODE (t
);
906 /* Skip types, decls, and constants. But we do want to look at their
907 types and the bounds of types. Mark them as visited so we properly
908 unmark their subtrees on the unmark pass. If we've already seen them,
909 don't look down further. */
910 if (TREE_CODE_CLASS (code
) == tcc_type
911 || TREE_CODE_CLASS (code
) == tcc_declaration
912 || TREE_CODE_CLASS (code
) == tcc_constant
)
914 if (TREE_VISITED (t
))
917 TREE_VISITED (t
) = 1;
920 /* If this node has been visited already, unshare it and don't look
922 else if (TREE_VISITED (t
))
924 walk_tree (tp
, mostly_copy_tree_r
, data
, NULL
);
928 /* Otherwise, mark the node as visited and keep looking. */
930 TREE_VISITED (t
) = 1;
935 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
936 copy_if_shared_r callback unmodified. */
939 copy_if_shared (tree
*tp
, void *data
)
941 walk_tree (tp
, copy_if_shared_r
, data
, NULL
);
944 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
945 any nested functions. */
948 unshare_body (tree fndecl
)
950 struct cgraph_node
*cgn
= cgraph_get_node (fndecl
);
951 /* If the language requires deep unsharing, we need a pointer set to make
952 sure we don't repeatedly unshare subtrees of unshareable nodes. */
953 struct pointer_set_t
*visited
954 = lang_hooks
.deep_unsharing
? pointer_set_create () : NULL
;
956 copy_if_shared (&DECL_SAVED_TREE (fndecl
), visited
);
957 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl
)), visited
);
958 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)), visited
);
961 pointer_set_destroy (visited
);
964 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
965 unshare_body (cgn
->symbol
.decl
);
968 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
969 Subtrees are walked until the first unvisited node is encountered. */
972 unmark_visited_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
976 /* If this node has been visited, unmark it and keep looking. */
977 if (TREE_VISITED (t
))
978 TREE_VISITED (t
) = 0;
980 /* Otherwise, don't look any deeper. */
987 /* Unmark the visited trees rooted at *TP. */
990 unmark_visited (tree
*tp
)
992 walk_tree (tp
, unmark_visited_r
, NULL
, NULL
);
995 /* Likewise, but mark all trees as not visited. */
998 unvisit_body (tree fndecl
)
1000 struct cgraph_node
*cgn
= cgraph_get_node (fndecl
);
1002 unmark_visited (&DECL_SAVED_TREE (fndecl
));
1003 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl
)));
1004 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl
)));
1007 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
1008 unvisit_body (cgn
->symbol
.decl
);
1011 /* Unconditionally make an unshared copy of EXPR. This is used when using
1012 stored expressions which span multiple functions, such as BINFO_VTABLE,
1013 as the normal unsharing process can't tell that they're shared. */
1016 unshare_expr (tree expr
)
1018 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
1022 /* Worker for unshare_expr_without_location. */
1025 prune_expr_location (tree
*tp
, int *walk_subtrees
, void *)
1028 SET_EXPR_LOCATION (*tp
, UNKNOWN_LOCATION
);
1034 /* Similar to unshare_expr but also prune all expression locations
1038 unshare_expr_without_location (tree expr
)
1040 walk_tree (&expr
, mostly_copy_tree_r
, NULL
, NULL
);
1042 walk_tree (&expr
, prune_expr_location
, NULL
, NULL
);
1046 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1047 contain statements and have a value. Assign its value to a temporary
1048 and give it void_type_node. Return the temporary, or NULL_TREE if
1049 WRAPPER was already void. */
1052 voidify_wrapper_expr (tree wrapper
, tree temp
)
1054 tree type
= TREE_TYPE (wrapper
);
1055 if (type
&& !VOID_TYPE_P (type
))
1059 /* Set p to point to the body of the wrapper. Loop until we find
1060 something that isn't a wrapper. */
1061 for (p
= &wrapper
; p
&& *p
; )
1063 switch (TREE_CODE (*p
))
1066 TREE_SIDE_EFFECTS (*p
) = 1;
1067 TREE_TYPE (*p
) = void_type_node
;
1068 /* For a BIND_EXPR, the body is operand 1. */
1069 p
= &BIND_EXPR_BODY (*p
);
1072 case CLEANUP_POINT_EXPR
:
1073 case TRY_FINALLY_EXPR
:
1074 case TRY_CATCH_EXPR
:
1075 TREE_SIDE_EFFECTS (*p
) = 1;
1076 TREE_TYPE (*p
) = void_type_node
;
1077 p
= &TREE_OPERAND (*p
, 0);
1080 case STATEMENT_LIST
:
1082 tree_stmt_iterator i
= tsi_last (*p
);
1083 TREE_SIDE_EFFECTS (*p
) = 1;
1084 TREE_TYPE (*p
) = void_type_node
;
1085 p
= tsi_end_p (i
) ? NULL
: tsi_stmt_ptr (i
);
1090 /* Advance to the last statement. Set all container types to
1092 for (; TREE_CODE (*p
) == COMPOUND_EXPR
; p
= &TREE_OPERAND (*p
, 1))
1094 TREE_SIDE_EFFECTS (*p
) = 1;
1095 TREE_TYPE (*p
) = void_type_node
;
1099 case TRANSACTION_EXPR
:
1100 TREE_SIDE_EFFECTS (*p
) = 1;
1101 TREE_TYPE (*p
) = void_type_node
;
1102 p
= &TRANSACTION_EXPR_BODY (*p
);
1106 /* Assume that any tree upon which voidify_wrapper_expr is
1107 directly called is a wrapper, and that its body is op0. */
1110 TREE_SIDE_EFFECTS (*p
) = 1;
1111 TREE_TYPE (*p
) = void_type_node
;
1112 p
= &TREE_OPERAND (*p
, 0);
1120 if (p
== NULL
|| IS_EMPTY_STMT (*p
))
1124 /* The wrapper is on the RHS of an assignment that we're pushing
1126 gcc_assert (TREE_CODE (temp
) == INIT_EXPR
1127 || TREE_CODE (temp
) == MODIFY_EXPR
);
1128 TREE_OPERAND (temp
, 1) = *p
;
1133 temp
= create_tmp_var (type
, "retval");
1134 *p
= build2 (INIT_EXPR
, type
, temp
, *p
);
1143 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1144 a temporary through which they communicate. */
1147 build_stack_save_restore (gimple
*save
, gimple
*restore
)
1151 *save
= gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE
), 0);
1152 tmp_var
= create_tmp_var (ptr_type_node
, "saved_stack");
1153 gimple_call_set_lhs (*save
, tmp_var
);
1156 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE
),
1160 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1162 static enum gimplify_status
1163 gimplify_bind_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1165 tree bind_expr
= *expr_p
;
1166 bool old_save_stack
= gimplify_ctxp
->save_stack
;
1169 gimple_seq body
, cleanup
;
1172 tree temp
= voidify_wrapper_expr (bind_expr
, NULL
);
1174 /* Mark variables seen in this bind expr. */
1175 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1177 if (TREE_CODE (t
) == VAR_DECL
)
1179 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
1181 /* Mark variable as local. */
1182 if (ctx
&& !DECL_EXTERNAL (t
)
1183 && (! DECL_SEEN_IN_BIND_EXPR_P (t
)
1184 || splay_tree_lookup (ctx
->variables
,
1185 (splay_tree_key
) t
) == NULL
))
1186 omp_add_variable (gimplify_omp_ctxp
, t
, GOVD_LOCAL
| GOVD_SEEN
);
1188 DECL_SEEN_IN_BIND_EXPR_P (t
) = 1;
1190 if (DECL_HARD_REGISTER (t
) && !is_global_var (t
) && cfun
)
1191 cfun
->has_local_explicit_reg_vars
= true;
1194 /* Preliminarily mark non-addressed complex variables as eligible
1195 for promotion to gimple registers. We'll transform their uses
1197 if ((TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
1198 || TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
1199 && !TREE_THIS_VOLATILE (t
)
1200 && (TREE_CODE (t
) == VAR_DECL
&& !DECL_HARD_REGISTER (t
))
1201 && !needs_to_live_in_memory (t
))
1202 DECL_GIMPLE_REG_P (t
) = 1;
1205 gimple_bind
= gimple_build_bind (BIND_EXPR_VARS (bind_expr
), NULL
,
1206 BIND_EXPR_BLOCK (bind_expr
));
1207 gimple_push_bind_expr (gimple_bind
);
1209 gimplify_ctxp
->save_stack
= false;
1211 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1213 gimplify_stmt (&BIND_EXPR_BODY (bind_expr
), &body
);
1214 gimple_bind_set_body (gimple_bind
, body
);
1218 if (gimplify_ctxp
->save_stack
)
1220 gimple stack_restore
;
1222 /* Save stack on entry and restore it on exit. Add a try_finally
1223 block to achieve this. Note that mudflap depends on the
1224 format of the emitted code: see mx_register_decls(). */
1225 build_stack_save_restore (&stack_save
, &stack_restore
);
1227 gimplify_seq_add_stmt (&cleanup
, stack_restore
);
1230 /* Add clobbers for all variables that go out of scope. */
1231 for (t
= BIND_EXPR_VARS (bind_expr
); t
; t
= DECL_CHAIN (t
))
1233 if (TREE_CODE (t
) == VAR_DECL
1234 && !is_global_var (t
)
1235 && DECL_CONTEXT (t
) == current_function_decl
1236 && !DECL_HARD_REGISTER (t
)
1237 && !TREE_THIS_VOLATILE (t
)
1238 && !DECL_HAS_VALUE_EXPR_P (t
)
1239 /* Only care for variables that have to be in memory. Others
1240 will be rewritten into SSA names, hence moved to the top-level. */
1241 && !is_gimple_reg (t
)
1242 && flag_stack_reuse
!= SR_NONE
)
1244 tree clobber
= build_constructor (TREE_TYPE (t
),
1246 TREE_THIS_VOLATILE (clobber
) = 1;
1247 gimplify_seq_add_stmt (&cleanup
, gimple_build_assign (t
, clobber
));
1254 gimple_seq new_body
;
1257 gs
= gimple_build_try (gimple_bind_body (gimple_bind
), cleanup
,
1258 GIMPLE_TRY_FINALLY
);
1261 gimplify_seq_add_stmt (&new_body
, stack_save
);
1262 gimplify_seq_add_stmt (&new_body
, gs
);
1263 gimple_bind_set_body (gimple_bind
, new_body
);
1266 gimplify_ctxp
->save_stack
= old_save_stack
;
1267 gimple_pop_bind_expr ();
1269 gimplify_seq_add_stmt (pre_p
, gimple_bind
);
1277 *expr_p
= NULL_TREE
;
1281 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1282 GIMPLE value, it is assigned to a new temporary and the statement is
1283 re-written to return the temporary.
1285 PRE_P points to the sequence where side effects that must happen before
1286 STMT should be stored. */
1288 static enum gimplify_status
1289 gimplify_return_expr (tree stmt
, gimple_seq
*pre_p
)
1292 tree ret_expr
= TREE_OPERAND (stmt
, 0);
1293 tree result_decl
, result
;
1295 if (ret_expr
== error_mark_node
)
1299 || TREE_CODE (ret_expr
) == RESULT_DECL
1300 || ret_expr
== error_mark_node
)
1302 gimple ret
= gimple_build_return (ret_expr
);
1303 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1304 gimplify_seq_add_stmt (pre_p
, ret
);
1308 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl
))))
1309 result_decl
= NULL_TREE
;
1312 result_decl
= TREE_OPERAND (ret_expr
, 0);
1314 /* See through a return by reference. */
1315 if (TREE_CODE (result_decl
) == INDIRECT_REF
)
1316 result_decl
= TREE_OPERAND (result_decl
, 0);
1318 gcc_assert ((TREE_CODE (ret_expr
) == MODIFY_EXPR
1319 || TREE_CODE (ret_expr
) == INIT_EXPR
)
1320 && TREE_CODE (result_decl
) == RESULT_DECL
);
1323 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1324 Recall that aggregate_value_p is FALSE for any aggregate type that is
1325 returned in registers. If we're returning values in registers, then
1326 we don't want to extend the lifetime of the RESULT_DECL, particularly
1327 across another call. In addition, for those aggregates for which
1328 hard_function_value generates a PARALLEL, we'll die during normal
1329 expansion of structure assignments; there's special code in expand_return
1330 to handle this case that does not exist in expand_expr. */
1333 else if (aggregate_value_p (result_decl
, TREE_TYPE (current_function_decl
)))
1335 if (TREE_CODE (DECL_SIZE (result_decl
)) != INTEGER_CST
)
1337 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl
)))
1338 gimplify_type_sizes (TREE_TYPE (result_decl
), pre_p
);
1339 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1340 should be effectively allocated by the caller, i.e. all calls to
1341 this function must be subject to the Return Slot Optimization. */
1342 gimplify_one_sizepos (&DECL_SIZE (result_decl
), pre_p
);
1343 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl
), pre_p
);
1345 result
= result_decl
;
1347 else if (gimplify_ctxp
->return_temp
)
1348 result
= gimplify_ctxp
->return_temp
;
1351 result
= create_tmp_reg (TREE_TYPE (result_decl
), NULL
);
1353 /* ??? With complex control flow (usually involving abnormal edges),
1354 we can wind up warning about an uninitialized value for this. Due
1355 to how this variable is constructed and initialized, this is never
1356 true. Give up and never warn. */
1357 TREE_NO_WARNING (result
) = 1;
1359 gimplify_ctxp
->return_temp
= result
;
1362 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1363 Then gimplify the whole thing. */
1364 if (result
!= result_decl
)
1365 TREE_OPERAND (ret_expr
, 0) = result
;
1367 gimplify_and_add (TREE_OPERAND (stmt
, 0), pre_p
);
1369 ret
= gimple_build_return (result
);
1370 gimple_set_no_warning (ret
, TREE_NO_WARNING (stmt
));
1371 gimplify_seq_add_stmt (pre_p
, ret
);
1376 /* Gimplify a variable-length array DECL. */
1379 gimplify_vla_decl (tree decl
, gimple_seq
*seq_p
)
1381 /* This is a variable-sized decl. Simplify its size and mark it
1382 for deferred expansion. Note that mudflap depends on the format
1383 of the emitted code: see mx_register_decls(). */
1384 tree t
, addr
, ptr_type
;
1386 gimplify_one_sizepos (&DECL_SIZE (decl
), seq_p
);
1387 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl
), seq_p
);
1389 /* Don't mess with a DECL_VALUE_EXPR set by the front-end. */
1390 if (DECL_HAS_VALUE_EXPR_P (decl
))
1393 /* All occurrences of this decl in final gimplified code will be
1394 replaced by indirection. Setting DECL_VALUE_EXPR does two
1395 things: First, it lets the rest of the gimplifier know what
1396 replacement to use. Second, it lets the debug info know
1397 where to find the value. */
1398 ptr_type
= build_pointer_type (TREE_TYPE (decl
));
1399 addr
= create_tmp_var (ptr_type
, get_name (decl
));
1400 DECL_IGNORED_P (addr
) = 0;
1401 t
= build_fold_indirect_ref (addr
);
1402 TREE_THIS_NOTRAP (t
) = 1;
1403 SET_DECL_VALUE_EXPR (decl
, t
);
1404 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1406 t
= builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN
);
1407 t
= build_call_expr (t
, 2, DECL_SIZE_UNIT (decl
),
1408 size_int (DECL_ALIGN (decl
)));
1409 /* The call has been built for a variable-sized object. */
1410 CALL_ALLOCA_FOR_VAR_P (t
) = 1;
1411 t
= fold_convert (ptr_type
, t
);
1412 t
= build2 (MODIFY_EXPR
, TREE_TYPE (addr
), addr
, t
);
1414 gimplify_and_add (t
, seq_p
);
1416 /* Indicate that we need to restore the stack level when the
1417 enclosing BIND_EXPR is exited. */
1418 gimplify_ctxp
->save_stack
= true;
1421 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1422 and initialization explicit. */
1424 static enum gimplify_status
1425 gimplify_decl_expr (tree
*stmt_p
, gimple_seq
*seq_p
)
1427 tree stmt
= *stmt_p
;
1428 tree decl
= DECL_EXPR_DECL (stmt
);
1430 *stmt_p
= NULL_TREE
;
1432 if (TREE_TYPE (decl
) == error_mark_node
)
1435 if ((TREE_CODE (decl
) == TYPE_DECL
1436 || TREE_CODE (decl
) == VAR_DECL
)
1437 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl
)))
1438 gimplify_type_sizes (TREE_TYPE (decl
), seq_p
);
1440 /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
1441 in case its size expressions contain problematic nodes like CALL_EXPR. */
1442 if (TREE_CODE (decl
) == TYPE_DECL
1443 && DECL_ORIGINAL_TYPE (decl
)
1444 && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl
)))
1445 gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl
), seq_p
);
1447 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1449 tree init
= DECL_INITIAL (decl
);
1451 if (TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
1452 || (!TREE_STATIC (decl
)
1453 && flag_stack_check
== GENERIC_STACK_CHECK
1454 && compare_tree_int (DECL_SIZE_UNIT (decl
),
1455 STACK_CHECK_MAX_VAR_SIZE
) > 0))
1456 gimplify_vla_decl (decl
, seq_p
);
1458 /* Some front ends do not explicitly declare all anonymous
1459 artificial variables. We compensate here by declaring the
1460 variables, though it would be better if the front ends would
1461 explicitly declare them. */
1462 if (!DECL_SEEN_IN_BIND_EXPR_P (decl
)
1463 && DECL_ARTIFICIAL (decl
) && DECL_NAME (decl
) == NULL_TREE
)
1464 gimple_add_tmp_var (decl
);
1466 if (init
&& init
!= error_mark_node
)
1468 if (!TREE_STATIC (decl
))
1470 DECL_INITIAL (decl
) = NULL_TREE
;
1471 init
= build2 (INIT_EXPR
, void_type_node
, decl
, init
);
1472 gimplify_and_add (init
, seq_p
);
1476 /* We must still examine initializers for static variables
1477 as they may contain a label address. */
1478 walk_tree (&init
, force_labels_r
, NULL
, NULL
);
1485 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1486 and replacing the LOOP_EXPR with goto, but if the loop contains an
1487 EXIT_EXPR, we need to append a label for it to jump to. */
1489 static enum gimplify_status
1490 gimplify_loop_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1492 tree saved_label
= gimplify_ctxp
->exit_label
;
1493 tree start_label
= create_artificial_label (UNKNOWN_LOCATION
);
1495 gimplify_seq_add_stmt (pre_p
, gimple_build_label (start_label
));
1497 gimplify_ctxp
->exit_label
= NULL_TREE
;
1499 gimplify_and_add (LOOP_EXPR_BODY (*expr_p
), pre_p
);
1501 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (start_label
));
1503 if (gimplify_ctxp
->exit_label
)
1504 gimplify_seq_add_stmt (pre_p
,
1505 gimple_build_label (gimplify_ctxp
->exit_label
));
1507 gimplify_ctxp
->exit_label
= saved_label
;
1513 /* Gimplify a statement list onto a sequence. These may be created either
1514 by an enlightened front-end, or by shortcut_cond_expr. */
1516 static enum gimplify_status
1517 gimplify_statement_list (tree
*expr_p
, gimple_seq
*pre_p
)
1519 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
1521 tree_stmt_iterator i
= tsi_start (*expr_p
);
1523 while (!tsi_end_p (i
))
1525 gimplify_stmt (tsi_stmt_ptr (i
), pre_p
);
1538 /* Compare two case labels. Because the front end should already have
1539 made sure that case ranges do not overlap, it is enough to only compare
1540 the CASE_LOW values of each case label. */
1543 compare_case_labels (const void *p1
, const void *p2
)
1545 const_tree
const case1
= *(const_tree
const*)p1
;
1546 const_tree
const case2
= *(const_tree
const*)p2
;
1548 /* The 'default' case label always goes first. */
1549 if (!CASE_LOW (case1
))
1551 else if (!CASE_LOW (case2
))
1554 return tree_int_cst_compare (CASE_LOW (case1
), CASE_LOW (case2
));
1557 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1560 sort_case_labels (vec
<tree
> label_vec
)
1562 label_vec
.qsort (compare_case_labels
);
1565 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
1567 LABELS is a vector that contains all case labels to look at.
1569 INDEX_TYPE is the type of the switch index expression. Case labels
1570 in LABELS are discarded if their values are not in the value range
1571 covered by INDEX_TYPE. The remaining case label values are folded
1574 If a default case exists in LABELS, it is removed from LABELS and
1575 returned in DEFAULT_CASEP. If no default case exists, but the
1576 case labels already cover the whole range of INDEX_TYPE, a default
1577 case is returned pointing to one of the existing case labels.
1578 Otherwise DEFAULT_CASEP is set to NULL_TREE.
1580 DEFAULT_CASEP may be NULL, in which case the above comment doesn't
1581 apply and no action is taken regardless of whether a default case is
1585 preprocess_case_label_vec_for_gimple (vec
<tree
> labels
,
1587 tree
*default_casep
)
1589 tree min_value
, max_value
;
1590 tree default_case
= NULL_TREE
;
1594 min_value
= TYPE_MIN_VALUE (index_type
);
1595 max_value
= TYPE_MAX_VALUE (index_type
);
1596 while (i
< labels
.length ())
1598 tree elt
= labels
[i
];
1599 tree low
= CASE_LOW (elt
);
1600 tree high
= CASE_HIGH (elt
);
1601 bool remove_element
= FALSE
;
1605 gcc_checking_assert (TREE_CODE (low
) == INTEGER_CST
);
1606 gcc_checking_assert (!high
|| TREE_CODE (high
) == INTEGER_CST
);
1608 /* This is a non-default case label, i.e. it has a value.
1610 See if the case label is reachable within the range of
1611 the index type. Remove out-of-range case values. Turn
1612 case ranges into a canonical form (high > low strictly)
1613 and convert the case label values to the index type.
1615 NB: The type of gimple_switch_index() may be the promoted
1616 type, but the case labels retain the original type. */
1620 /* This is a case range. Discard empty ranges.
1621 If the bounds or the range are equal, turn this
1622 into a simple (one-value) case. */
1623 int cmp
= tree_int_cst_compare (high
, low
);
1625 remove_element
= TRUE
;
1632 /* If the simple case value is unreachable, ignore it. */
1633 if ((TREE_CODE (min_value
) == INTEGER_CST
1634 && tree_int_cst_compare (low
, min_value
) < 0)
1635 || (TREE_CODE (max_value
) == INTEGER_CST
1636 && tree_int_cst_compare (low
, max_value
) > 0))
1637 remove_element
= TRUE
;
1639 low
= fold_convert (index_type
, low
);
1643 /* If the entire case range is unreachable, ignore it. */
1644 if ((TREE_CODE (min_value
) == INTEGER_CST
1645 && tree_int_cst_compare (high
, min_value
) < 0)
1646 || (TREE_CODE (max_value
) == INTEGER_CST
1647 && tree_int_cst_compare (low
, max_value
) > 0))
1648 remove_element
= TRUE
;
1651 /* If the lower bound is less than the index type's
1652 minimum value, truncate the range bounds. */
1653 if (TREE_CODE (min_value
) == INTEGER_CST
1654 && tree_int_cst_compare (low
, min_value
) < 0)
1656 low
= fold_convert (index_type
, low
);
1658 /* If the upper bound is greater than the index type's
1659 maximum value, truncate the range bounds. */
1660 if (TREE_CODE (max_value
) == INTEGER_CST
1661 && tree_int_cst_compare (high
, max_value
) > 0)
1663 high
= fold_convert (index_type
, high
);
1665 /* We may have folded a case range to a one-value case. */
1666 if (tree_int_cst_equal (low
, high
))
1671 CASE_LOW (elt
) = low
;
1672 CASE_HIGH (elt
) = high
;
1676 gcc_assert (!default_case
);
1678 /* The default case must be passed separately to the
1679 gimple_build_switch routine. But if DEFAULT_CASEP
1680 is NULL, we do not remove the default case (it would
1681 be completely lost). */
1683 remove_element
= TRUE
;
1687 labels
.ordered_remove (i
);
1693 if (!labels
.is_empty ())
1694 sort_case_labels (labels
);
1696 if (default_casep
&& !default_case
)
1698 /* If the switch has no default label, add one, so that we jump
1699 around the switch body. If the labels already cover the whole
1700 range of the switch index_type, add the default label pointing
1701 to one of the existing labels. */
1703 && TYPE_MIN_VALUE (index_type
)
1704 && TYPE_MAX_VALUE (index_type
)
1705 && tree_int_cst_equal (CASE_LOW (labels
[0]),
1706 TYPE_MIN_VALUE (index_type
)))
1708 tree low
, high
= CASE_HIGH (labels
[len
- 1]);
1710 high
= CASE_LOW (labels
[len
- 1]);
1711 if (tree_int_cst_equal (high
, TYPE_MAX_VALUE (index_type
)))
1713 for (i
= 1; i
< len
; i
++)
1715 high
= CASE_LOW (labels
[i
]);
1716 low
= CASE_HIGH (labels
[i
- 1]);
1718 low
= CASE_LOW (labels
[i
- 1]);
1719 if ((TREE_INT_CST_LOW (low
) + 1
1720 != TREE_INT_CST_LOW (high
))
1721 || (TREE_INT_CST_HIGH (low
)
1722 + (TREE_INT_CST_LOW (high
) == 0)
1723 != TREE_INT_CST_HIGH (high
)))
1728 tree label
= CASE_LABEL (labels
[0]);
1729 default_case
= build_case_label (NULL_TREE
, NULL_TREE
,
1737 *default_casep
= default_case
;
1740 /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
1743 static enum gimplify_status
1744 gimplify_switch_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1746 tree switch_expr
= *expr_p
;
1747 gimple_seq switch_body_seq
= NULL
;
1748 enum gimplify_status ret
;
1749 tree index_type
= TREE_TYPE (switch_expr
);
1750 if (index_type
== NULL_TREE
)
1751 index_type
= TREE_TYPE (SWITCH_COND (switch_expr
));
1753 ret
= gimplify_expr (&SWITCH_COND (switch_expr
), pre_p
, NULL
, is_gimple_val
,
1755 if (ret
== GS_ERROR
|| ret
== GS_UNHANDLED
)
1758 if (SWITCH_BODY (switch_expr
))
1761 vec
<tree
> saved_labels
;
1762 tree default_case
= NULL_TREE
;
1763 gimple gimple_switch
;
1765 /* If someone can be bothered to fill in the labels, they can
1766 be bothered to null out the body too. */
1767 gcc_assert (!SWITCH_LABELS (switch_expr
));
1769 /* Save old labels, get new ones from body, then restore the old
1770 labels. Save all the things from the switch body to append after. */
1771 saved_labels
= gimplify_ctxp
->case_labels
;
1772 gimplify_ctxp
->case_labels
.create (8);
1774 gimplify_stmt (&SWITCH_BODY (switch_expr
), &switch_body_seq
);
1775 labels
= gimplify_ctxp
->case_labels
;
1776 gimplify_ctxp
->case_labels
= saved_labels
;
1778 preprocess_case_label_vec_for_gimple (labels
, index_type
,
1786 = build_case_label (NULL_TREE
, NULL_TREE
,
1787 create_artificial_label (UNKNOWN_LOCATION
));
1788 new_default
= gimple_build_label (CASE_LABEL (default_case
));
1789 gimplify_seq_add_stmt (&switch_body_seq
, new_default
);
1792 gimple_switch
= gimple_build_switch (SWITCH_COND (switch_expr
),
1793 default_case
, labels
);
1794 gimplify_seq_add_stmt (pre_p
, gimple_switch
);
1795 gimplify_seq_add_seq (pre_p
, switch_body_seq
);
1799 gcc_assert (SWITCH_LABELS (switch_expr
));
1804 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
1806 static enum gimplify_status
1807 gimplify_case_label_expr (tree
*expr_p
, gimple_seq
*pre_p
)
1809 struct gimplify_ctx
*ctxp
;
1810 gimple gimple_label
;
1812 /* Invalid OpenMP programs can play Duff's Device type games with
1813 #pragma omp parallel. At least in the C front end, we don't
1814 detect such invalid branches until after gimplification. */
1815 for (ctxp
= gimplify_ctxp
; ; ctxp
= ctxp
->prev_context
)
1816 if (ctxp
->case_labels
.exists ())
1819 gimple_label
= gimple_build_label (CASE_LABEL (*expr_p
));
1820 ctxp
->case_labels
.safe_push (*expr_p
);
1821 gimplify_seq_add_stmt (pre_p
, gimple_label
);
1826 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1830 build_and_jump (tree
*label_p
)
1832 if (label_p
== NULL
)
1833 /* If there's nowhere to jump, just fall through. */
1836 if (*label_p
== NULL_TREE
)
1838 tree label
= create_artificial_label (UNKNOWN_LOCATION
);
1842 return build1 (GOTO_EXPR
, void_type_node
, *label_p
);
1845 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1846 This also involves building a label to jump to and communicating it to
1847 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1849 static enum gimplify_status
1850 gimplify_exit_expr (tree
*expr_p
)
1852 tree cond
= TREE_OPERAND (*expr_p
, 0);
1855 expr
= build_and_jump (&gimplify_ctxp
->exit_label
);
1856 expr
= build3 (COND_EXPR
, void_type_node
, cond
, expr
, NULL_TREE
);
1862 /* A helper function to be called via walk_tree. Mark all labels under *TP
1863 as being forced. To be called for DECL_INITIAL of static variables. */
1866 force_labels_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
1870 if (TREE_CODE (*tp
) == LABEL_DECL
)
1871 FORCED_LABEL (*tp
) = 1;
1876 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1877 different from its canonical type, wrap the whole thing inside a
1878 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1881 The canonical type of a COMPONENT_REF is the type of the field being
1882 referenced--unless the field is a bit-field which can be read directly
1883 in a smaller mode, in which case the canonical type is the
1884 sign-appropriate type corresponding to that mode. */
1887 canonicalize_component_ref (tree
*expr_p
)
1889 tree expr
= *expr_p
;
1892 gcc_assert (TREE_CODE (expr
) == COMPONENT_REF
);
1894 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
1895 type
= TREE_TYPE (get_unwidened (expr
, NULL_TREE
));
1897 type
= TREE_TYPE (TREE_OPERAND (expr
, 1));
1899 /* One could argue that all the stuff below is not necessary for
1900 the non-bitfield case and declare it a FE error if type
1901 adjustment would be needed. */
1902 if (TREE_TYPE (expr
) != type
)
1904 #ifdef ENABLE_TYPES_CHECKING
1905 tree old_type
= TREE_TYPE (expr
);
1909 /* We need to preserve qualifiers and propagate them from
1911 type_quals
= TYPE_QUALS (type
)
1912 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1913 if (TYPE_QUALS (type
) != type_quals
)
1914 type
= build_qualified_type (TYPE_MAIN_VARIANT (type
), type_quals
);
1916 /* Set the type of the COMPONENT_REF to the underlying type. */
1917 TREE_TYPE (expr
) = type
;
1919 #ifdef ENABLE_TYPES_CHECKING
1920 /* It is now a FE error, if the conversion from the canonical
1921 type to the original expression type is not useless. */
1922 gcc_assert (useless_type_conversion_p (old_type
, type
));
1927 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1928 to foo, embed that change in the ADDR_EXPR by converting
1933 where L is the lower bound. For simplicity, only do this for constant
1935 The constraint is that the type of &array[L] is trivially convertible
1939 canonicalize_addr_expr (tree
*expr_p
)
1941 tree expr
= *expr_p
;
1942 tree addr_expr
= TREE_OPERAND (expr
, 0);
1943 tree datype
, ddatype
, pddatype
;
1945 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1946 if (!POINTER_TYPE_P (TREE_TYPE (expr
))
1947 || TREE_CODE (addr_expr
) != ADDR_EXPR
)
1950 /* The addr_expr type should be a pointer to an array. */
1951 datype
= TREE_TYPE (TREE_TYPE (addr_expr
));
1952 if (TREE_CODE (datype
) != ARRAY_TYPE
)
1955 /* The pointer to element type shall be trivially convertible to
1956 the expression pointer type. */
1957 ddatype
= TREE_TYPE (datype
);
1958 pddatype
= build_pointer_type (ddatype
);
1959 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr
)),
1963 /* The lower bound and element sizes must be constant. */
1964 if (!TYPE_SIZE_UNIT (ddatype
)
1965 || TREE_CODE (TYPE_SIZE_UNIT (ddatype
)) != INTEGER_CST
1966 || !TYPE_DOMAIN (datype
) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))
1967 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype
))) != INTEGER_CST
)
1970 /* All checks succeeded. Build a new node to merge the cast. */
1971 *expr_p
= build4 (ARRAY_REF
, ddatype
, TREE_OPERAND (addr_expr
, 0),
1972 TYPE_MIN_VALUE (TYPE_DOMAIN (datype
)),
1973 NULL_TREE
, NULL_TREE
);
1974 *expr_p
= build1 (ADDR_EXPR
, pddatype
, *expr_p
);
1976 /* We can have stripped a required restrict qualifier above. */
1977 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
1978 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
1981 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1982 underneath as appropriate. */
1984 static enum gimplify_status
1985 gimplify_conversion (tree
*expr_p
)
1987 location_t loc
= EXPR_LOCATION (*expr_p
);
1988 gcc_assert (CONVERT_EXPR_P (*expr_p
));
1990 /* Then strip away all but the outermost conversion. */
1991 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p
, 0));
1993 /* And remove the outermost conversion if it's useless. */
1994 if (tree_ssa_useless_type_conversion (*expr_p
))
1995 *expr_p
= TREE_OPERAND (*expr_p
, 0);
1997 /* If we still have a conversion at the toplevel,
1998 then canonicalize some constructs. */
1999 if (CONVERT_EXPR_P (*expr_p
))
2001 tree sub
= TREE_OPERAND (*expr_p
, 0);
2003 /* If a NOP conversion is changing the type of a COMPONENT_REF
2004 expression, then canonicalize its type now in order to expose more
2005 redundant conversions. */
2006 if (TREE_CODE (sub
) == COMPONENT_REF
)
2007 canonicalize_component_ref (&TREE_OPERAND (*expr_p
, 0));
2009 /* If a NOP conversion is changing a pointer to array of foo
2010 to a pointer to foo, embed that change in the ADDR_EXPR. */
2011 else if (TREE_CODE (sub
) == ADDR_EXPR
)
2012 canonicalize_addr_expr (expr_p
);
2015 /* If we have a conversion to a non-register type force the
2016 use of a VIEW_CONVERT_EXPR instead. */
2017 if (CONVERT_EXPR_P (*expr_p
) && !is_gimple_reg_type (TREE_TYPE (*expr_p
)))
2018 *expr_p
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, TREE_TYPE (*expr_p
),
2019 TREE_OPERAND (*expr_p
, 0));
2024 /* Nonlocal VLAs seen in the current function. */
2025 static struct pointer_set_t
*nonlocal_vlas
;
2027 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
2028 DECL_VALUE_EXPR, and it's worth re-examining things. */
2030 static enum gimplify_status
2031 gimplify_var_or_parm_decl (tree
*expr_p
)
2033 tree decl
= *expr_p
;
2035 /* ??? If this is a local variable, and it has not been seen in any
2036 outer BIND_EXPR, then it's probably the result of a duplicate
2037 declaration, for which we've already issued an error. It would
2038 be really nice if the front end wouldn't leak these at all.
2039 Currently the only known culprit is C++ destructors, as seen
2040 in g++.old-deja/g++.jason/binding.C. */
2041 if (TREE_CODE (decl
) == VAR_DECL
2042 && !DECL_SEEN_IN_BIND_EXPR_P (decl
)
2043 && !TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
)
2044 && decl_function_context (decl
) == current_function_decl
)
2046 gcc_assert (seen_error ());
2050 /* When within an OpenMP context, notice uses of variables. */
2051 if (gimplify_omp_ctxp
&& omp_notice_variable (gimplify_omp_ctxp
, decl
, true))
2054 /* If the decl is an alias for another expression, substitute it now. */
2055 if (DECL_HAS_VALUE_EXPR_P (decl
))
2057 tree value_expr
= DECL_VALUE_EXPR (decl
);
2059 /* For referenced nonlocal VLAs add a decl for debugging purposes
2060 to the current function. */
2061 if (TREE_CODE (decl
) == VAR_DECL
2062 && TREE_CODE (DECL_SIZE_UNIT (decl
)) != INTEGER_CST
2063 && nonlocal_vlas
!= NULL
2064 && TREE_CODE (value_expr
) == INDIRECT_REF
2065 && TREE_CODE (TREE_OPERAND (value_expr
, 0)) == VAR_DECL
2066 && decl_function_context (decl
) != current_function_decl
)
2068 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
2070 && (ctx
->region_type
== ORT_WORKSHARE
2071 || ctx
->region_type
== ORT_SIMD
))
2072 ctx
= ctx
->outer_context
;
2073 if (!ctx
&& !pointer_set_insert (nonlocal_vlas
, decl
))
2075 tree copy
= copy_node (decl
), block
;
2077 lang_hooks
.dup_lang_specific_decl (copy
);
2078 SET_DECL_RTL (copy
, 0);
2079 TREE_USED (copy
) = 1;
2080 block
= DECL_INITIAL (current_function_decl
);
2081 DECL_CHAIN (copy
) = BLOCK_VARS (block
);
2082 BLOCK_VARS (block
) = copy
;
2083 SET_DECL_VALUE_EXPR (copy
, unshare_expr (value_expr
));
2084 DECL_HAS_VALUE_EXPR_P (copy
) = 1;
2088 *expr_p
= unshare_expr (value_expr
);
2095 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
2099 : min_lval '[' val ']'
2101 | compound_lval '[' val ']'
2102 | compound_lval '.' ID
2104 This is not part of the original SIMPLE definition, which separates
2105 array and member references, but it seems reasonable to handle them
2106 together. Also, this way we don't run into problems with union
2107 aliasing; gcc requires that for accesses through a union to alias, the
2108 union reference must be explicit, which was not always the case when we
2109 were splitting up array and member refs.
2111 PRE_P points to the sequence where side effects that must happen before
2112 *EXPR_P should be stored.
2114 POST_P points to the sequence where side effects that must happen after
2115 *EXPR_P should be stored. */
2117 static enum gimplify_status
2118 gimplify_compound_lval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2119 fallback_t fallback
)
2122 vec
<tree
> expr_stack
;
2123 enum gimplify_status ret
= GS_ALL_DONE
, tret
;
2125 location_t loc
= EXPR_LOCATION (*expr_p
);
2126 tree expr
= *expr_p
;
2128 /* Create a stack of the subexpressions so later we can walk them in
2129 order from inner to outer. */
2130 expr_stack
.create (10);
2132 /* We can handle anything that get_inner_reference can deal with. */
2133 for (p
= expr_p
; ; p
= &TREE_OPERAND (*p
, 0))
2136 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2137 if (TREE_CODE (*p
) == INDIRECT_REF
)
2138 *p
= fold_indirect_ref_loc (loc
, *p
);
2140 if (handled_component_p (*p
))
2142 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2143 additional COMPONENT_REFs. */
2144 else if ((TREE_CODE (*p
) == VAR_DECL
|| TREE_CODE (*p
) == PARM_DECL
)
2145 && gimplify_var_or_parm_decl (p
) == GS_OK
)
2150 expr_stack
.safe_push (*p
);
2153 gcc_assert (expr_stack
.length ());
2155 /* Now EXPR_STACK is a stack of pointers to all the refs we've
2156 walked through and P points to the innermost expression.
2158 Java requires that we elaborated nodes in source order. That
2159 means we must gimplify the inner expression followed by each of
2160 the indices, in order. But we can't gimplify the inner
2161 expression until we deal with any variable bounds, sizes, or
2162 positions in order to deal with PLACEHOLDER_EXPRs.
2164 So we do this in three steps. First we deal with the annotations
2165 for any variables in the components, then we gimplify the base,
2166 then we gimplify any indices, from left to right. */
2167 for (i
= expr_stack
.length () - 1; i
>= 0; i
--)
2169 tree t
= expr_stack
[i
];
2171 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2173 /* Gimplify the low bound and element type size and put them into
2174 the ARRAY_REF. If these values are set, they have already been
2176 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2178 tree low
= unshare_expr (array_ref_low_bound (t
));
2179 if (!is_gimple_min_invariant (low
))
2181 TREE_OPERAND (t
, 2) = low
;
2182 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2183 post_p
, is_gimple_reg
,
2185 ret
= MIN (ret
, tret
);
2190 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2191 is_gimple_reg
, fb_rvalue
);
2192 ret
= MIN (ret
, tret
);
2195 if (TREE_OPERAND (t
, 3) == NULL_TREE
)
2197 tree elmt_type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (t
, 0)));
2198 tree elmt_size
= unshare_expr (array_ref_element_size (t
));
2199 tree factor
= size_int (TYPE_ALIGN_UNIT (elmt_type
));
2201 /* Divide the element size by the alignment of the element
2204 = size_binop_loc (loc
, EXACT_DIV_EXPR
, elmt_size
, factor
);
2206 if (!is_gimple_min_invariant (elmt_size
))
2208 TREE_OPERAND (t
, 3) = elmt_size
;
2209 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
,
2210 post_p
, is_gimple_reg
,
2212 ret
= MIN (ret
, tret
);
2217 tret
= gimplify_expr (&TREE_OPERAND (t
, 3), pre_p
, post_p
,
2218 is_gimple_reg
, fb_rvalue
);
2219 ret
= MIN (ret
, tret
);
2222 else if (TREE_CODE (t
) == COMPONENT_REF
)
2224 /* Set the field offset into T and gimplify it. */
2225 if (TREE_OPERAND (t
, 2) == NULL_TREE
)
2227 tree offset
= unshare_expr (component_ref_field_offset (t
));
2228 tree field
= TREE_OPERAND (t
, 1);
2230 = size_int (DECL_OFFSET_ALIGN (field
) / BITS_PER_UNIT
);
2232 /* Divide the offset by its alignment. */
2233 offset
= size_binop_loc (loc
, EXACT_DIV_EXPR
, offset
, factor
);
2235 if (!is_gimple_min_invariant (offset
))
2237 TREE_OPERAND (t
, 2) = offset
;
2238 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
,
2239 post_p
, is_gimple_reg
,
2241 ret
= MIN (ret
, tret
);
2246 tret
= gimplify_expr (&TREE_OPERAND (t
, 2), pre_p
, post_p
,
2247 is_gimple_reg
, fb_rvalue
);
2248 ret
= MIN (ret
, tret
);
2253 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2254 so as to match the min_lval predicate. Failure to do so may result
2255 in the creation of large aggregate temporaries. */
2256 tret
= gimplify_expr (p
, pre_p
, post_p
, is_gimple_min_lval
,
2257 fallback
| fb_lvalue
);
2258 ret
= MIN (ret
, tret
);
2260 /* And finally, the indices and operands of ARRAY_REF. During this
2261 loop we also remove any useless conversions. */
2262 for (; expr_stack
.length () > 0; )
2264 tree t
= expr_stack
.pop ();
2266 if (TREE_CODE (t
) == ARRAY_REF
|| TREE_CODE (t
) == ARRAY_RANGE_REF
)
2268 /* Gimplify the dimension. */
2269 if (!is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
2271 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), pre_p
, post_p
,
2272 is_gimple_val
, fb_rvalue
);
2273 ret
= MIN (ret
, tret
);
2277 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t
, 0));
2279 /* The innermost expression P may have originally had
2280 TREE_SIDE_EFFECTS set which would have caused all the outer
2281 expressions in *EXPR_P leading to P to also have had
2282 TREE_SIDE_EFFECTS set. */
2283 recalculate_side_effects (t
);
2286 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2287 if ((fallback
& fb_rvalue
) && TREE_CODE (*expr_p
) == COMPONENT_REF
)
2289 canonicalize_component_ref (expr_p
);
2292 expr_stack
.release ();
2294 gcc_assert (*expr_p
== expr
|| ret
!= GS_ALL_DONE
);
2299 /* Gimplify the self modifying expression pointed to by EXPR_P
2302 PRE_P points to the list where side effects that must happen before
2303 *EXPR_P should be stored.
2305 POST_P points to the list where side effects that must happen after
2306 *EXPR_P should be stored.
2308 WANT_VALUE is nonzero iff we want to use the value of this expression
2309 in another expression.
2311 ARITH_TYPE is the type the computation should be performed in. */
2313 enum gimplify_status
2314 gimplify_self_mod_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
2315 bool want_value
, tree arith_type
)
2317 enum tree_code code
;
2318 tree lhs
, lvalue
, rhs
, t1
;
2319 gimple_seq post
= NULL
, *orig_post_p
= post_p
;
2321 enum tree_code arith_code
;
2322 enum gimplify_status ret
;
2323 location_t loc
= EXPR_LOCATION (*expr_p
);
2325 code
= TREE_CODE (*expr_p
);
2327 gcc_assert (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
2328 || code
== PREINCREMENT_EXPR
|| code
== PREDECREMENT_EXPR
);
2330 /* Prefix or postfix? */
2331 if (code
== POSTINCREMENT_EXPR
|| code
== POSTDECREMENT_EXPR
)
2332 /* Faster to treat as prefix if result is not used. */
2333 postfix
= want_value
;
2337 /* For postfix, make sure the inner expression's post side effects
2338 are executed after side effects from this expression. */
2342 /* Add or subtract? */
2343 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
2344 arith_code
= PLUS_EXPR
;
2346 arith_code
= MINUS_EXPR
;
2348 /* Gimplify the LHS into a GIMPLE lvalue. */
2349 lvalue
= TREE_OPERAND (*expr_p
, 0);
2350 ret
= gimplify_expr (&lvalue
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
2351 if (ret
== GS_ERROR
)
2354 /* Extract the operands to the arithmetic operation. */
2356 rhs
= TREE_OPERAND (*expr_p
, 1);
2358 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2359 that as the result value and in the postqueue operation. */
2362 ret
= gimplify_expr (&lhs
, pre_p
, post_p
, is_gimple_val
, fb_rvalue
);
2363 if (ret
== GS_ERROR
)
2366 lhs
= get_initialized_tmp_var (lhs
, pre_p
, NULL
);
2369 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2370 if (POINTER_TYPE_P (TREE_TYPE (lhs
)))
2372 rhs
= convert_to_ptrofftype_loc (loc
, rhs
);
2373 if (arith_code
== MINUS_EXPR
)
2374 rhs
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (rhs
), rhs
);
2375 t1
= fold_build2 (POINTER_PLUS_EXPR
, TREE_TYPE (*expr_p
), lhs
, rhs
);
2378 t1
= fold_convert (TREE_TYPE (*expr_p
),
2379 fold_build2 (arith_code
, arith_type
,
2380 fold_convert (arith_type
, lhs
),
2381 fold_convert (arith_type
, rhs
)));
2385 gimplify_assign (lvalue
, t1
, pre_p
);
2386 gimplify_seq_add_seq (orig_post_p
, post
);
2392 *expr_p
= build2 (MODIFY_EXPR
, TREE_TYPE (lvalue
), lvalue
, t1
);
2397 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2400 maybe_with_size_expr (tree
*expr_p
)
2402 tree expr
= *expr_p
;
2403 tree type
= TREE_TYPE (expr
);
2406 /* If we've already wrapped this or the type is error_mark_node, we can't do
2408 if (TREE_CODE (expr
) == WITH_SIZE_EXPR
2409 || type
== error_mark_node
)
2412 /* If the size isn't known or is a constant, we have nothing to do. */
2413 size
= TYPE_SIZE_UNIT (type
);
2414 if (!size
|| TREE_CODE (size
) == INTEGER_CST
)
2417 /* Otherwise, make a WITH_SIZE_EXPR. */
2418 size
= unshare_expr (size
);
2419 size
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (size
, expr
);
2420 *expr_p
= build2 (WITH_SIZE_EXPR
, type
, expr
, size
);
2423 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2424 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2427 static enum gimplify_status
2428 gimplify_arg (tree
*arg_p
, gimple_seq
*pre_p
, location_t call_location
)
2430 bool (*test
) (tree
);
2433 /* In general, we allow lvalues for function arguments to avoid
2434 extra overhead of copying large aggregates out of even larger
2435 aggregates into temporaries only to copy the temporaries to
2436 the argument list. Make optimizers happy by pulling out to
2437 temporaries those types that fit in registers. */
2438 if (is_gimple_reg_type (TREE_TYPE (*arg_p
)))
2439 test
= is_gimple_val
, fb
= fb_rvalue
;
2442 test
= is_gimple_lvalue
, fb
= fb_either
;
2443 /* Also strip a TARGET_EXPR that would force an extra copy. */
2444 if (TREE_CODE (*arg_p
) == TARGET_EXPR
)
2446 tree init
= TARGET_EXPR_INITIAL (*arg_p
);
2448 && !VOID_TYPE_P (TREE_TYPE (init
)))
2453 /* If this is a variable sized type, we must remember the size. */
2454 maybe_with_size_expr (arg_p
);
2456 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2457 /* Make sure arguments have the same location as the function call
2459 protected_set_expr_location (*arg_p
, call_location
);
2461 /* There is a sequence point before a function call. Side effects in
2462 the argument list must occur before the actual call. So, when
2463 gimplifying arguments, force gimplify_expr to use an internal
2464 post queue which is then appended to the end of PRE_P. */
2465 return gimplify_expr (arg_p
, pre_p
, NULL
, test
, fb
);
2468 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2469 WANT_VALUE is true if the result of the call is desired. */
2471 static enum gimplify_status
2472 gimplify_call_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
2474 tree fndecl
, parms
, p
, fnptrtype
;
2475 enum gimplify_status ret
;
2478 bool builtin_va_start_p
= FALSE
;
2479 location_t loc
= EXPR_LOCATION (*expr_p
);
2481 gcc_assert (TREE_CODE (*expr_p
) == CALL_EXPR
);
2483 /* For reliable diagnostics during inlining, it is necessary that
2484 every call_expr be annotated with file and line. */
2485 if (! EXPR_HAS_LOCATION (*expr_p
))
2486 SET_EXPR_LOCATION (*expr_p
, input_location
);
2488 /* This may be a call to a builtin function.
2490 Builtin function calls may be transformed into different
2491 (and more efficient) builtin function calls under certain
2492 circumstances. Unfortunately, gimplification can muck things
2493 up enough that the builtin expanders are not aware that certain
2494 transformations are still valid.
2496 So we attempt transformation/gimplification of the call before
2497 we gimplify the CALL_EXPR. At this time we do not manage to
2498 transform all calls in the same manner as the expanders do, but
2499 we do transform most of them. */
2500 fndecl
= get_callee_fndecl (*expr_p
);
2502 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
2503 switch (DECL_FUNCTION_CODE (fndecl
))
2505 case BUILT_IN_VA_START
:
2507 builtin_va_start_p
= TRUE
;
2508 if (call_expr_nargs (*expr_p
) < 2)
2510 error ("too few arguments to function %<va_start%>");
2511 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2515 if (fold_builtin_next_arg (*expr_p
, true))
2517 *expr_p
= build_empty_stmt (EXPR_LOCATION (*expr_p
));
2524 expanded_location loc
= expand_location (EXPR_LOCATION (*expr_p
));
2525 *expr_p
= build_int_cst (TREE_TYPE (*expr_p
), loc
.line
);
2530 expanded_location loc
= expand_location (EXPR_LOCATION (*expr_p
));
2531 *expr_p
= build_string_literal (strlen (loc
.file
) + 1, loc
.file
);
2534 case BUILT_IN_FUNCTION
:
2536 const char *function
;
2537 function
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
2538 *expr_p
= build_string_literal (strlen (function
) + 1, function
);
2544 if (fndecl
&& DECL_BUILT_IN (fndecl
))
2546 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2547 if (new_tree
&& new_tree
!= *expr_p
)
2549 /* There was a transformation of this call which computes the
2550 same value, but in a more efficient way. Return and try
2557 /* Remember the original function pointer type. */
2558 fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*expr_p
));
2560 /* There is a sequence point before the call, so any side effects in
2561 the calling expression must occur before the actual call. Force
2562 gimplify_expr to use an internal post queue. */
2563 ret
= gimplify_expr (&CALL_EXPR_FN (*expr_p
), pre_p
, NULL
,
2564 is_gimple_call_addr
, fb_rvalue
);
2566 nargs
= call_expr_nargs (*expr_p
);
2568 /* Get argument types for verification. */
2569 fndecl
= get_callee_fndecl (*expr_p
);
2572 parms
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2573 else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p
))))
2574 parms
= TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p
))));
2576 if (fndecl
&& DECL_ARGUMENTS (fndecl
))
2577 p
= DECL_ARGUMENTS (fndecl
);
2582 for (i
= 0; i
< nargs
&& p
; i
++, p
= TREE_CHAIN (p
))
2585 /* If the last argument is __builtin_va_arg_pack () and it is not
2586 passed as a named argument, decrease the number of CALL_EXPR
2587 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2590 && TREE_CODE (CALL_EXPR_ARG (*expr_p
, nargs
- 1)) == CALL_EXPR
)
2592 tree last_arg
= CALL_EXPR_ARG (*expr_p
, nargs
- 1);
2593 tree last_arg_fndecl
= get_callee_fndecl (last_arg
);
2596 && TREE_CODE (last_arg_fndecl
) == FUNCTION_DECL
2597 && DECL_BUILT_IN_CLASS (last_arg_fndecl
) == BUILT_IN_NORMAL
2598 && DECL_FUNCTION_CODE (last_arg_fndecl
) == BUILT_IN_VA_ARG_PACK
)
2600 tree call
= *expr_p
;
2603 *expr_p
= build_call_array_loc (loc
, TREE_TYPE (call
),
2604 CALL_EXPR_FN (call
),
2605 nargs
, CALL_EXPR_ARGP (call
));
2607 /* Copy all CALL_EXPR flags, location and block, except
2608 CALL_EXPR_VA_ARG_PACK flag. */
2609 CALL_EXPR_STATIC_CHAIN (*expr_p
) = CALL_EXPR_STATIC_CHAIN (call
);
2610 CALL_EXPR_TAILCALL (*expr_p
) = CALL_EXPR_TAILCALL (call
);
2611 CALL_EXPR_RETURN_SLOT_OPT (*expr_p
)
2612 = CALL_EXPR_RETURN_SLOT_OPT (call
);
2613 CALL_FROM_THUNK_P (*expr_p
) = CALL_FROM_THUNK_P (call
);
2614 SET_EXPR_LOCATION (*expr_p
, EXPR_LOCATION (call
));
2616 /* Set CALL_EXPR_VA_ARG_PACK. */
2617 CALL_EXPR_VA_ARG_PACK (*expr_p
) = 1;
2621 /* Finally, gimplify the function arguments. */
2624 for (i
= (PUSH_ARGS_REVERSED
? nargs
- 1 : 0);
2625 PUSH_ARGS_REVERSED
? i
>= 0 : i
< nargs
;
2626 PUSH_ARGS_REVERSED
? i
-- : i
++)
2628 enum gimplify_status t
;
2630 /* Avoid gimplifying the second argument to va_start, which needs to
2631 be the plain PARM_DECL. */
2632 if ((i
!= 1) || !builtin_va_start_p
)
2634 t
= gimplify_arg (&CALL_EXPR_ARG (*expr_p
, i
), pre_p
,
2635 EXPR_LOCATION (*expr_p
));
2643 /* Verify the function result. */
2644 if (want_value
&& fndecl
2645 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype
))))
2647 error_at (loc
, "using result of function returning %<void%>");
2651 /* Try this again in case gimplification exposed something. */
2652 if (ret
!= GS_ERROR
)
2654 tree new_tree
= fold_call_expr (input_location
, *expr_p
, !want_value
);
2656 if (new_tree
&& new_tree
!= *expr_p
)
2658 /* There was a transformation of this call which computes the
2659 same value, but in a more efficient way. Return and try
2667 *expr_p
= error_mark_node
;
2671 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2672 decl. This allows us to eliminate redundant or useless
2673 calls to "const" functions. */
2674 if (TREE_CODE (*expr_p
) == CALL_EXPR
)
2676 int flags
= call_expr_flags (*expr_p
);
2677 if (flags
& (ECF_CONST
| ECF_PURE
)
2678 /* An infinite loop is considered a side effect. */
2679 && !(flags
& (ECF_LOOPING_CONST_OR_PURE
)))
2680 TREE_SIDE_EFFECTS (*expr_p
) = 0;
2683 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2684 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2685 form and delegate the creation of a GIMPLE_CALL to
2686 gimplify_modify_expr. This is always possible because when
2687 WANT_VALUE is true, the caller wants the result of this call into
2688 a temporary, which means that we will emit an INIT_EXPR in
2689 internal_get_tmp_var which will then be handled by
2690 gimplify_modify_expr. */
2693 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2694 have to do is replicate it as a GIMPLE_CALL tuple. */
2695 gimple_stmt_iterator gsi
;
2696 call
= gimple_build_call_from_tree (*expr_p
);
2697 gimple_call_set_fntype (call
, TREE_TYPE (fnptrtype
));
2698 notice_special_calls (call
);
2699 gimplify_seq_add_stmt (pre_p
, call
);
2700 gsi
= gsi_last (*pre_p
);
2702 *expr_p
= NULL_TREE
;
2705 /* Remember the original function type. */
2706 CALL_EXPR_FN (*expr_p
) = build1 (NOP_EXPR
, fnptrtype
,
2707 CALL_EXPR_FN (*expr_p
));
2712 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2713 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2715 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2716 condition is true or false, respectively. If null, we should generate
2717 our own to skip over the evaluation of this specific expression.
2719 LOCUS is the source location of the COND_EXPR.
2721 This function is the tree equivalent of do_jump.
2723 shortcut_cond_r should only be called by shortcut_cond_expr. */
2726 shortcut_cond_r (tree pred
, tree
*true_label_p
, tree
*false_label_p
,
2729 tree local_label
= NULL_TREE
;
2730 tree t
, expr
= NULL
;
2732 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2733 retain the shortcut semantics. Just insert the gotos here;
2734 shortcut_cond_expr will append the real blocks later. */
2735 if (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2737 location_t new_locus
;
2739 /* Turn if (a && b) into
2741 if (a); else goto no;
2742 if (b) goto yes; else goto no;
2745 if (false_label_p
== NULL
)
2746 false_label_p
= &local_label
;
2748 /* Keep the original source location on the first 'if'. */
2749 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), NULL
, false_label_p
, locus
);
2750 append_to_statement_list (t
, &expr
);
2752 /* Set the source location of the && on the second 'if'. */
2753 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2754 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2756 append_to_statement_list (t
, &expr
);
2758 else if (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2760 location_t new_locus
;
2762 /* Turn if (a || b) into
2765 if (b) goto yes; else goto no;
2768 if (true_label_p
== NULL
)
2769 true_label_p
= &local_label
;
2771 /* Keep the original source location on the first 'if'. */
2772 t
= shortcut_cond_r (TREE_OPERAND (pred
, 0), true_label_p
, NULL
, locus
);
2773 append_to_statement_list (t
, &expr
);
2775 /* Set the source location of the || on the second 'if'. */
2776 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2777 t
= shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
, false_label_p
,
2779 append_to_statement_list (t
, &expr
);
2781 else if (TREE_CODE (pred
) == COND_EXPR
2782 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 1)))
2783 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred
, 2))))
2785 location_t new_locus
;
2787 /* As long as we're messing with gotos, turn if (a ? b : c) into
2789 if (b) goto yes; else goto no;
2791 if (c) goto yes; else goto no;
2793 Don't do this if one of the arms has void type, which can happen
2794 in C++ when the arm is throw. */
2796 /* Keep the original source location on the first 'if'. Set the source
2797 location of the ? on the second 'if'. */
2798 new_locus
= EXPR_HAS_LOCATION (pred
) ? EXPR_LOCATION (pred
) : locus
;
2799 expr
= build3 (COND_EXPR
, void_type_node
, TREE_OPERAND (pred
, 0),
2800 shortcut_cond_r (TREE_OPERAND (pred
, 1), true_label_p
,
2801 false_label_p
, locus
),
2802 shortcut_cond_r (TREE_OPERAND (pred
, 2), true_label_p
,
2803 false_label_p
, new_locus
));
2807 expr
= build3 (COND_EXPR
, void_type_node
, pred
,
2808 build_and_jump (true_label_p
),
2809 build_and_jump (false_label_p
));
2810 SET_EXPR_LOCATION (expr
, locus
);
2815 t
= build1 (LABEL_EXPR
, void_type_node
, local_label
);
2816 append_to_statement_list (t
, &expr
);
2822 /* Given a conditional expression EXPR with short-circuit boolean
2823 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2824 predicate apart into the equivalent sequence of conditionals. */
2827 shortcut_cond_expr (tree expr
)
2829 tree pred
= TREE_OPERAND (expr
, 0);
2830 tree then_
= TREE_OPERAND (expr
, 1);
2831 tree else_
= TREE_OPERAND (expr
, 2);
2832 tree true_label
, false_label
, end_label
, t
;
2834 tree
*false_label_p
;
2835 bool emit_end
, emit_false
, jump_over_else
;
2836 bool then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2837 bool else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2839 /* First do simple transformations. */
2842 /* If there is no 'else', turn
2845 if (a) if (b) then c. */
2846 while (TREE_CODE (pred
) == TRUTH_ANDIF_EXPR
)
2848 /* Keep the original source location on the first 'if'. */
2849 location_t locus
= EXPR_LOC_OR_HERE (expr
);
2850 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2851 /* Set the source location of the && on the second 'if'. */
2852 if (EXPR_HAS_LOCATION (pred
))
2853 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2854 then_
= shortcut_cond_expr (expr
);
2855 then_se
= then_
&& TREE_SIDE_EFFECTS (then_
);
2856 pred
= TREE_OPERAND (pred
, 0);
2857 expr
= build3 (COND_EXPR
, void_type_node
, pred
, then_
, NULL_TREE
);
2858 SET_EXPR_LOCATION (expr
, locus
);
2864 /* If there is no 'then', turn
2867 if (a); else if (b); else d. */
2868 while (TREE_CODE (pred
) == TRUTH_ORIF_EXPR
)
2870 /* Keep the original source location on the first 'if'. */
2871 location_t locus
= EXPR_LOC_OR_HERE (expr
);
2872 TREE_OPERAND (expr
, 0) = TREE_OPERAND (pred
, 1);
2873 /* Set the source location of the || on the second 'if'. */
2874 if (EXPR_HAS_LOCATION (pred
))
2875 SET_EXPR_LOCATION (expr
, EXPR_LOCATION (pred
));
2876 else_
= shortcut_cond_expr (expr
);
2877 else_se
= else_
&& TREE_SIDE_EFFECTS (else_
);
2878 pred
= TREE_OPERAND (pred
, 0);
2879 expr
= build3 (COND_EXPR
, void_type_node
, pred
, NULL_TREE
, else_
);
2880 SET_EXPR_LOCATION (expr
, locus
);
2884 /* If we're done, great. */
2885 if (TREE_CODE (pred
) != TRUTH_ANDIF_EXPR
2886 && TREE_CODE (pred
) != TRUTH_ORIF_EXPR
)
2889 /* Otherwise we need to mess with gotos. Change
2892 if (a); else goto no;
2895 and recursively gimplify the condition. */
2897 true_label
= false_label
= end_label
= NULL_TREE
;
2899 /* If our arms just jump somewhere, hijack those labels so we don't
2900 generate jumps to jumps. */
2903 && TREE_CODE (then_
) == GOTO_EXPR
2904 && TREE_CODE (GOTO_DESTINATION (then_
)) == LABEL_DECL
)
2906 true_label
= GOTO_DESTINATION (then_
);
2912 && TREE_CODE (else_
) == GOTO_EXPR
2913 && TREE_CODE (GOTO_DESTINATION (else_
)) == LABEL_DECL
)
2915 false_label
= GOTO_DESTINATION (else_
);
2920 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2922 true_label_p
= &true_label
;
2924 true_label_p
= NULL
;
2926 /* The 'else' branch also needs a label if it contains interesting code. */
2927 if (false_label
|| else_se
)
2928 false_label_p
= &false_label
;
2930 false_label_p
= NULL
;
2932 /* If there was nothing else in our arms, just forward the label(s). */
2933 if (!then_se
&& !else_se
)
2934 return shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2935 EXPR_LOC_OR_HERE (expr
));
2937 /* If our last subexpression already has a terminal label, reuse it. */
2939 t
= expr_last (else_
);
2941 t
= expr_last (then_
);
2944 if (t
&& TREE_CODE (t
) == LABEL_EXPR
)
2945 end_label
= LABEL_EXPR_LABEL (t
);
2947 /* If we don't care about jumping to the 'else' branch, jump to the end
2948 if the condition is false. */
2950 false_label_p
= &end_label
;
2952 /* We only want to emit these labels if we aren't hijacking them. */
2953 emit_end
= (end_label
== NULL_TREE
);
2954 emit_false
= (false_label
== NULL_TREE
);
2956 /* We only emit the jump over the else clause if we have to--if the
2957 then clause may fall through. Otherwise we can wind up with a
2958 useless jump and a useless label at the end of gimplified code,
2959 which will cause us to think that this conditional as a whole
2960 falls through even if it doesn't. If we then inline a function
2961 which ends with such a condition, that can cause us to issue an
2962 inappropriate warning about control reaching the end of a
2963 non-void function. */
2964 jump_over_else
= block_may_fallthru (then_
);
2966 pred
= shortcut_cond_r (pred
, true_label_p
, false_label_p
,
2967 EXPR_LOC_OR_HERE (expr
));
2970 append_to_statement_list (pred
, &expr
);
2972 append_to_statement_list (then_
, &expr
);
2977 tree last
= expr_last (expr
);
2978 t
= build_and_jump (&end_label
);
2979 if (EXPR_HAS_LOCATION (last
))
2980 SET_EXPR_LOCATION (t
, EXPR_LOCATION (last
));
2981 append_to_statement_list (t
, &expr
);
2985 t
= build1 (LABEL_EXPR
, void_type_node
, false_label
);
2986 append_to_statement_list (t
, &expr
);
2988 append_to_statement_list (else_
, &expr
);
2990 if (emit_end
&& end_label
)
2992 t
= build1 (LABEL_EXPR
, void_type_node
, end_label
);
2993 append_to_statement_list (t
, &expr
);
2999 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
3002 gimple_boolify (tree expr
)
3004 tree type
= TREE_TYPE (expr
);
3005 location_t loc
= EXPR_LOCATION (expr
);
3007 if (TREE_CODE (expr
) == NE_EXPR
3008 && TREE_CODE (TREE_OPERAND (expr
, 0)) == CALL_EXPR
3009 && integer_zerop (TREE_OPERAND (expr
, 1)))
3011 tree call
= TREE_OPERAND (expr
, 0);
3012 tree fn
= get_callee_fndecl (call
);
3014 /* For __builtin_expect ((long) (x), y) recurse into x as well
3015 if x is truth_value_p. */
3017 && DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
3018 && DECL_FUNCTION_CODE (fn
) == BUILT_IN_EXPECT
3019 && call_expr_nargs (call
) == 2)
3021 tree arg
= CALL_EXPR_ARG (call
, 0);
3024 if (TREE_CODE (arg
) == NOP_EXPR
3025 && TREE_TYPE (arg
) == TREE_TYPE (call
))
3026 arg
= TREE_OPERAND (arg
, 0);
3027 if (truth_value_p (TREE_CODE (arg
)))
3029 arg
= gimple_boolify (arg
);
3030 CALL_EXPR_ARG (call
, 0)
3031 = fold_convert_loc (loc
, TREE_TYPE (call
), arg
);
3037 switch (TREE_CODE (expr
))
3039 case TRUTH_AND_EXPR
:
3041 case TRUTH_XOR_EXPR
:
3042 case TRUTH_ANDIF_EXPR
:
3043 case TRUTH_ORIF_EXPR
:
3044 /* Also boolify the arguments of truth exprs. */
3045 TREE_OPERAND (expr
, 1) = gimple_boolify (TREE_OPERAND (expr
, 1));
3048 case TRUTH_NOT_EXPR
:
3049 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3051 /* These expressions always produce boolean results. */
3052 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3053 TREE_TYPE (expr
) = boolean_type_node
;
3057 if (COMPARISON_CLASS_P (expr
))
3059 /* There expressions always prduce boolean results. */
3060 if (TREE_CODE (type
) != BOOLEAN_TYPE
)
3061 TREE_TYPE (expr
) = boolean_type_node
;
3064 /* Other expressions that get here must have boolean values, but
3065 might need to be converted to the appropriate mode. */
3066 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
3068 return fold_convert_loc (loc
, boolean_type_node
, expr
);
3072 /* Given a conditional expression *EXPR_P without side effects, gimplify
3073 its operands. New statements are inserted to PRE_P. */
3075 static enum gimplify_status
3076 gimplify_pure_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
)
3078 tree expr
= *expr_p
, cond
;
3079 enum gimplify_status ret
, tret
;
3080 enum tree_code code
;
3082 cond
= gimple_boolify (COND_EXPR_COND (expr
));
3084 /* We need to handle && and || specially, as their gimplification
3085 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
3086 code
= TREE_CODE (cond
);
3087 if (code
== TRUTH_ANDIF_EXPR
)
3088 TREE_SET_CODE (cond
, TRUTH_AND_EXPR
);
3089 else if (code
== TRUTH_ORIF_EXPR
)
3090 TREE_SET_CODE (cond
, TRUTH_OR_EXPR
);
3091 ret
= gimplify_expr (&cond
, pre_p
, NULL
, is_gimple_condexpr
, fb_rvalue
);
3092 COND_EXPR_COND (*expr_p
) = cond
;
3094 tret
= gimplify_expr (&COND_EXPR_THEN (expr
), pre_p
, NULL
,
3095 is_gimple_val
, fb_rvalue
);
3096 ret
= MIN (ret
, tret
);
3097 tret
= gimplify_expr (&COND_EXPR_ELSE (expr
), pre_p
, NULL
,
3098 is_gimple_val
, fb_rvalue
);
3100 return MIN (ret
, tret
);
3103 /* Return true if evaluating EXPR could trap.
3104 EXPR is GENERIC, while tree_could_trap_p can be called
3108 generic_expr_could_trap_p (tree expr
)
3112 if (!expr
|| is_gimple_val (expr
))
3115 if (!EXPR_P (expr
) || tree_could_trap_p (expr
))
3118 n
= TREE_OPERAND_LENGTH (expr
);
3119 for (i
= 0; i
< n
; i
++)
3120 if (generic_expr_could_trap_p (TREE_OPERAND (expr
, i
)))
3126 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3135 The second form is used when *EXPR_P is of type void.
3137 PRE_P points to the list where side effects that must happen before
3138 *EXPR_P should be stored. */
3140 static enum gimplify_status
3141 gimplify_cond_expr (tree
*expr_p
, gimple_seq
*pre_p
, fallback_t fallback
)
3143 tree expr
= *expr_p
;
3144 tree type
= TREE_TYPE (expr
);
3145 location_t loc
= EXPR_LOCATION (expr
);
3146 tree tmp
, arm1
, arm2
;
3147 enum gimplify_status ret
;
3148 tree label_true
, label_false
, label_cont
;
3149 bool have_then_clause_p
, have_else_clause_p
;
3151 enum tree_code pred_code
;
3152 gimple_seq seq
= NULL
;
3154 /* If this COND_EXPR has a value, copy the values into a temporary within
3156 if (!VOID_TYPE_P (type
))
3158 tree then_
= TREE_OPERAND (expr
, 1), else_
= TREE_OPERAND (expr
, 2);
3161 /* If either an rvalue is ok or we do not require an lvalue, create the
3162 temporary. But we cannot do that if the type is addressable. */
3163 if (((fallback
& fb_rvalue
) || !(fallback
& fb_lvalue
))
3164 && !TREE_ADDRESSABLE (type
))
3166 if (gimplify_ctxp
->allow_rhs_cond_expr
3167 /* If either branch has side effects or could trap, it can't be
3168 evaluated unconditionally. */
3169 && !TREE_SIDE_EFFECTS (then_
)
3170 && !generic_expr_could_trap_p (then_
)
3171 && !TREE_SIDE_EFFECTS (else_
)
3172 && !generic_expr_could_trap_p (else_
))
3173 return gimplify_pure_cond_expr (expr_p
, pre_p
);
3175 tmp
= create_tmp_var (type
, "iftmp");
3179 /* Otherwise, only create and copy references to the values. */
3182 type
= build_pointer_type (type
);
3184 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3185 then_
= build_fold_addr_expr_loc (loc
, then_
);
3187 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3188 else_
= build_fold_addr_expr_loc (loc
, else_
);
3191 = build3 (COND_EXPR
, type
, TREE_OPERAND (expr
, 0), then_
, else_
);
3193 tmp
= create_tmp_var (type
, "iftmp");
3194 result
= build_simple_mem_ref_loc (loc
, tmp
);
3197 /* Build the new then clause, `tmp = then_;'. But don't build the
3198 assignment if the value is void; in C++ it can be if it's a throw. */
3199 if (!VOID_TYPE_P (TREE_TYPE (then_
)))
3200 TREE_OPERAND (expr
, 1) = build2 (MODIFY_EXPR
, type
, tmp
, then_
);
3202 /* Similarly, build the new else clause, `tmp = else_;'. */
3203 if (!VOID_TYPE_P (TREE_TYPE (else_
)))
3204 TREE_OPERAND (expr
, 2) = build2 (MODIFY_EXPR
, type
, tmp
, else_
);
3206 TREE_TYPE (expr
) = void_type_node
;
3207 recalculate_side_effects (expr
);
3209 /* Move the COND_EXPR to the prequeue. */
3210 gimplify_stmt (&expr
, pre_p
);
3216 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
3217 STRIP_TYPE_NOPS (TREE_OPERAND (expr
, 0));
3218 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == COMPOUND_EXPR
)
3219 gimplify_compound_expr (&TREE_OPERAND (expr
, 0), pre_p
, true);
3221 /* Make sure the condition has BOOLEAN_TYPE. */
3222 TREE_OPERAND (expr
, 0) = gimple_boolify (TREE_OPERAND (expr
, 0));
3224 /* Break apart && and || conditions. */
3225 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ANDIF_EXPR
3226 || TREE_CODE (TREE_OPERAND (expr
, 0)) == TRUTH_ORIF_EXPR
)
3228 expr
= shortcut_cond_expr (expr
);
3230 if (expr
!= *expr_p
)
3234 /* We can't rely on gimplify_expr to re-gimplify the expanded
3235 form properly, as cleanups might cause the target labels to be
3236 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3237 set up a conditional context. */
3238 gimple_push_condition ();
3239 gimplify_stmt (expr_p
, &seq
);
3240 gimple_pop_condition (pre_p
);
3241 gimple_seq_add_seq (pre_p
, seq
);
3247 /* Now do the normal gimplification. */
3249 /* Gimplify condition. */
3250 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, NULL
, is_gimple_condexpr
,
3252 if (ret
== GS_ERROR
)
3254 gcc_assert (TREE_OPERAND (expr
, 0) != NULL_TREE
);
3256 gimple_push_condition ();
3258 have_then_clause_p
= have_else_clause_p
= false;
3259 if (TREE_OPERAND (expr
, 1) != NULL
3260 && TREE_CODE (TREE_OPERAND (expr
, 1)) == GOTO_EXPR
3261 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 1))) == LABEL_DECL
3262 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 1)))
3263 == current_function_decl
)
3264 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3265 have different locations, otherwise we end up with incorrect
3266 location information on the branches. */
3268 || !EXPR_HAS_LOCATION (expr
)
3269 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 1))
3270 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 1))))
3272 label_true
= GOTO_DESTINATION (TREE_OPERAND (expr
, 1));
3273 have_then_clause_p
= true;
3276 label_true
= create_artificial_label (UNKNOWN_LOCATION
);
3277 if (TREE_OPERAND (expr
, 2) != NULL
3278 && TREE_CODE (TREE_OPERAND (expr
, 2)) == GOTO_EXPR
3279 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr
, 2))) == LABEL_DECL
3280 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr
, 2)))
3281 == current_function_decl
)
3282 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3283 have different locations, otherwise we end up with incorrect
3284 location information on the branches. */
3286 || !EXPR_HAS_LOCATION (expr
)
3287 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr
, 2))
3288 || EXPR_LOCATION (expr
) == EXPR_LOCATION (TREE_OPERAND (expr
, 2))))
3290 label_false
= GOTO_DESTINATION (TREE_OPERAND (expr
, 2));
3291 have_else_clause_p
= true;
3294 label_false
= create_artificial_label (UNKNOWN_LOCATION
);
3296 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr
), &pred_code
, &arm1
,
3299 gimple_cond
= gimple_build_cond (pred_code
, arm1
, arm2
, label_true
,
3302 gimplify_seq_add_stmt (&seq
, gimple_cond
);
3303 label_cont
= NULL_TREE
;
3304 if (!have_then_clause_p
)
3306 /* For if (...) {} else { code; } put label_true after
3308 if (TREE_OPERAND (expr
, 1) == NULL_TREE
3309 && !have_else_clause_p
3310 && TREE_OPERAND (expr
, 2) != NULL_TREE
)
3311 label_cont
= label_true
;
3314 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_true
));
3315 have_then_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 1), &seq
);
3316 /* For if (...) { code; } else {} or
3317 if (...) { code; } else goto label; or
3318 if (...) { code; return; } else { ... }
3319 label_cont isn't needed. */
3320 if (!have_else_clause_p
3321 && TREE_OPERAND (expr
, 2) != NULL_TREE
3322 && gimple_seq_may_fallthru (seq
))
3325 label_cont
= create_artificial_label (UNKNOWN_LOCATION
);
3327 g
= gimple_build_goto (label_cont
);
3329 /* GIMPLE_COND's are very low level; they have embedded
3330 gotos. This particular embedded goto should not be marked
3331 with the location of the original COND_EXPR, as it would
3332 correspond to the COND_EXPR's condition, not the ELSE or the
3333 THEN arms. To avoid marking it with the wrong location, flag
3334 it as "no location". */
3335 gimple_set_do_not_emit_location (g
);
3337 gimplify_seq_add_stmt (&seq
, g
);
3341 if (!have_else_clause_p
)
3343 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_false
));
3344 have_else_clause_p
= gimplify_stmt (&TREE_OPERAND (expr
, 2), &seq
);
3347 gimplify_seq_add_stmt (&seq
, gimple_build_label (label_cont
));
3349 gimple_pop_condition (pre_p
);
3350 gimple_seq_add_seq (pre_p
, seq
);
3352 if (ret
== GS_ERROR
)
3354 else if (have_then_clause_p
|| have_else_clause_p
)
3358 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3359 expr
= TREE_OPERAND (expr
, 0);
3360 gimplify_stmt (&expr
, pre_p
);
3367 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3368 to be marked addressable.
3370 We cannot rely on such an expression being directly markable if a temporary
3371 has been created by the gimplification. In this case, we create another
3372 temporary and initialize it with a copy, which will become a store after we
3373 mark it addressable. This can happen if the front-end passed us something
3374 that it could not mark addressable yet, like a Fortran pass-by-reference
3375 parameter (int) floatvar. */
3378 prepare_gimple_addressable (tree
*expr_p
, gimple_seq
*seq_p
)
3380 while (handled_component_p (*expr_p
))
3381 expr_p
= &TREE_OPERAND (*expr_p
, 0);
3382 if (is_gimple_reg (*expr_p
))
3383 *expr_p
= get_initialized_tmp_var (*expr_p
, seq_p
, NULL
);
3386 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3387 a call to __builtin_memcpy. */
3389 static enum gimplify_status
3390 gimplify_modify_expr_to_memcpy (tree
*expr_p
, tree size
, bool want_value
,
3393 tree t
, to
, to_ptr
, from
, from_ptr
;
3395 location_t loc
= EXPR_LOCATION (*expr_p
);
3397 to
= TREE_OPERAND (*expr_p
, 0);
3398 from
= TREE_OPERAND (*expr_p
, 1);
3400 /* Mark the RHS addressable. Beware that it may not be possible to do so
3401 directly if a temporary has been created by the gimplification. */
3402 prepare_gimple_addressable (&from
, seq_p
);
3404 mark_addressable (from
);
3405 from_ptr
= build_fold_addr_expr_loc (loc
, from
);
3406 gimplify_arg (&from_ptr
, seq_p
, loc
);
3408 mark_addressable (to
);
3409 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3410 gimplify_arg (&to_ptr
, seq_p
, loc
);
3412 t
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3414 gs
= gimple_build_call (t
, 3, to_ptr
, from_ptr
, size
);
3418 /* tmp = memcpy() */
3419 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3420 gimple_call_set_lhs (gs
, t
);
3421 gimplify_seq_add_stmt (seq_p
, gs
);
3423 *expr_p
= build_simple_mem_ref (t
);
3427 gimplify_seq_add_stmt (seq_p
, gs
);
3432 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3433 a call to __builtin_memset. In this case we know that the RHS is
3434 a CONSTRUCTOR with an empty element list. */
3436 static enum gimplify_status
3437 gimplify_modify_expr_to_memset (tree
*expr_p
, tree size
, bool want_value
,
3440 tree t
, from
, to
, to_ptr
;
3442 location_t loc
= EXPR_LOCATION (*expr_p
);
3444 /* Assert our assumptions, to abort instead of producing wrong code
3445 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3446 not be immediately exposed. */
3447 from
= TREE_OPERAND (*expr_p
, 1);
3448 if (TREE_CODE (from
) == WITH_SIZE_EXPR
)
3449 from
= TREE_OPERAND (from
, 0);
3451 gcc_assert (TREE_CODE (from
) == CONSTRUCTOR
3452 && vec_safe_is_empty (CONSTRUCTOR_ELTS (from
)));
3455 to
= TREE_OPERAND (*expr_p
, 0);
3457 to_ptr
= build_fold_addr_expr_loc (loc
, to
);
3458 gimplify_arg (&to_ptr
, seq_p
, loc
);
3459 t
= builtin_decl_implicit (BUILT_IN_MEMSET
);
3461 gs
= gimple_build_call (t
, 3, to_ptr
, integer_zero_node
, size
);
3465 /* tmp = memset() */
3466 t
= create_tmp_var (TREE_TYPE (to_ptr
), NULL
);
3467 gimple_call_set_lhs (gs
, t
);
3468 gimplify_seq_add_stmt (seq_p
, gs
);
3470 *expr_p
= build1 (INDIRECT_REF
, TREE_TYPE (to
), t
);
3474 gimplify_seq_add_stmt (seq_p
, gs
);
3479 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3480 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3481 assignment. Return non-null if we detect a potential overlap. */
3483 struct gimplify_init_ctor_preeval_data
3485 /* The base decl of the lhs object. May be NULL, in which case we
3486 have to assume the lhs is indirect. */
3489 /* The alias set of the lhs object. */
3490 alias_set_type lhs_alias_set
;
3494 gimplify_init_ctor_preeval_1 (tree
*tp
, int *walk_subtrees
, void *xdata
)
3496 struct gimplify_init_ctor_preeval_data
*data
3497 = (struct gimplify_init_ctor_preeval_data
*) xdata
;
3500 /* If we find the base object, obviously we have overlap. */
3501 if (data
->lhs_base_decl
== t
)
3504 /* If the constructor component is indirect, determine if we have a
3505 potential overlap with the lhs. The only bits of information we
3506 have to go on at this point are addressability and alias sets. */
3507 if ((INDIRECT_REF_P (t
)
3508 || TREE_CODE (t
) == MEM_REF
)
3509 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3510 && alias_sets_conflict_p (data
->lhs_alias_set
, get_alias_set (t
)))
3513 /* If the constructor component is a call, determine if it can hide a
3514 potential overlap with the lhs through an INDIRECT_REF like above.
3515 ??? Ugh - this is completely broken. In fact this whole analysis
3516 doesn't look conservative. */
3517 if (TREE_CODE (t
) == CALL_EXPR
)
3519 tree type
, fntype
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t
)));
3521 for (type
= TYPE_ARG_TYPES (fntype
); type
; type
= TREE_CHAIN (type
))
3522 if (POINTER_TYPE_P (TREE_VALUE (type
))
3523 && (!data
->lhs_base_decl
|| TREE_ADDRESSABLE (data
->lhs_base_decl
))
3524 && alias_sets_conflict_p (data
->lhs_alias_set
,
3526 (TREE_TYPE (TREE_VALUE (type
)))))
3530 if (IS_TYPE_OR_DECL_P (t
))
3535 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3536 force values that overlap with the lhs (as described by *DATA)
3537 into temporaries. */
3540 gimplify_init_ctor_preeval (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3541 struct gimplify_init_ctor_preeval_data
*data
)
3543 enum gimplify_status one
;
3545 /* If the value is constant, then there's nothing to pre-evaluate. */
3546 if (TREE_CONSTANT (*expr_p
))
3548 /* Ensure it does not have side effects, it might contain a reference to
3549 the object we're initializing. */
3550 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p
));
3554 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3555 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p
)))
3558 /* Recurse for nested constructors. */
3559 if (TREE_CODE (*expr_p
) == CONSTRUCTOR
)
3561 unsigned HOST_WIDE_INT ix
;
3562 constructor_elt
*ce
;
3563 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (*expr_p
);
3565 FOR_EACH_VEC_SAFE_ELT (v
, ix
, ce
)
3566 gimplify_init_ctor_preeval (&ce
->value
, pre_p
, post_p
, data
);
3571 /* If this is a variable sized type, we must remember the size. */
3572 maybe_with_size_expr (expr_p
);
3574 /* Gimplify the constructor element to something appropriate for the rhs
3575 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3576 the gimplifier will consider this a store to memory. Doing this
3577 gimplification now means that we won't have to deal with complicated
3578 language-specific trees, nor trees like SAVE_EXPR that can induce
3579 exponential search behavior. */
3580 one
= gimplify_expr (expr_p
, pre_p
, post_p
, is_gimple_mem_rhs
, fb_rvalue
);
3581 if (one
== GS_ERROR
)
3587 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3588 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3589 always be true for all scalars, since is_gimple_mem_rhs insists on a
3590 temporary variable for them. */
3591 if (DECL_P (*expr_p
))
3594 /* If this is of variable size, we have no choice but to assume it doesn't
3595 overlap since we can't make a temporary for it. */
3596 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p
))) != INTEGER_CST
)
3599 /* Otherwise, we must search for overlap ... */
3600 if (!walk_tree (expr_p
, gimplify_init_ctor_preeval_1
, data
, NULL
))
3603 /* ... and if found, force the value into a temporary. */
3604 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
3607 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3608 a RANGE_EXPR in a CONSTRUCTOR for an array.
3612 object[var] = value;
3619 We increment var _after_ the loop exit check because we might otherwise
3620 fail if upper == TYPE_MAX_VALUE (type for upper).
3622 Note that we never have to deal with SAVE_EXPRs here, because this has
3623 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3625 static void gimplify_init_ctor_eval (tree
, vec
<constructor_elt
, va_gc
> *,
3626 gimple_seq
*, bool);
3629 gimplify_init_ctor_eval_range (tree object
, tree lower
, tree upper
,
3630 tree value
, tree array_elt_type
,
3631 gimple_seq
*pre_p
, bool cleared
)
3633 tree loop_entry_label
, loop_exit_label
, fall_thru_label
;
3634 tree var
, var_type
, cref
, tmp
;
3636 loop_entry_label
= create_artificial_label (UNKNOWN_LOCATION
);
3637 loop_exit_label
= create_artificial_label (UNKNOWN_LOCATION
);
3638 fall_thru_label
= create_artificial_label (UNKNOWN_LOCATION
);
3640 /* Create and initialize the index variable. */
3641 var_type
= TREE_TYPE (upper
);
3642 var
= create_tmp_var (var_type
, NULL
);
3643 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, lower
));
3645 /* Add the loop entry label. */
3646 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_entry_label
));
3648 /* Build the reference. */
3649 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3650 var
, NULL_TREE
, NULL_TREE
);
3652 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3653 the store. Otherwise just assign value to the reference. */
3655 if (TREE_CODE (value
) == CONSTRUCTOR
)
3656 /* NB we might have to call ourself recursively through
3657 gimplify_init_ctor_eval if the value is a constructor. */
3658 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3661 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (cref
, value
));
3663 /* We exit the loop when the index var is equal to the upper bound. */
3664 gimplify_seq_add_stmt (pre_p
,
3665 gimple_build_cond (EQ_EXPR
, var
, upper
,
3666 loop_exit_label
, fall_thru_label
));
3668 gimplify_seq_add_stmt (pre_p
, gimple_build_label (fall_thru_label
));
3670 /* Otherwise, increment the index var... */
3671 tmp
= build2 (PLUS_EXPR
, var_type
, var
,
3672 fold_convert (var_type
, integer_one_node
));
3673 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (var
, tmp
));
3675 /* ...and jump back to the loop entry. */
3676 gimplify_seq_add_stmt (pre_p
, gimple_build_goto (loop_entry_label
));
3678 /* Add the loop exit label. */
3679 gimplify_seq_add_stmt (pre_p
, gimple_build_label (loop_exit_label
));
3682 /* Return true if FDECL is accessing a field that is zero sized. */
3685 zero_sized_field_decl (const_tree fdecl
)
3687 if (TREE_CODE (fdecl
) == FIELD_DECL
&& DECL_SIZE (fdecl
)
3688 && integer_zerop (DECL_SIZE (fdecl
)))
3693 /* Return true if TYPE is zero sized. */
3696 zero_sized_type (const_tree type
)
3698 if (AGGREGATE_TYPE_P (type
) && TYPE_SIZE (type
)
3699 && integer_zerop (TYPE_SIZE (type
)))
3704 /* A subroutine of gimplify_init_constructor. Generate individual
3705 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3706 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3707 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3711 gimplify_init_ctor_eval (tree object
, vec
<constructor_elt
, va_gc
> *elts
,
3712 gimple_seq
*pre_p
, bool cleared
)
3714 tree array_elt_type
= NULL
;
3715 unsigned HOST_WIDE_INT ix
;
3716 tree purpose
, value
;
3718 if (TREE_CODE (TREE_TYPE (object
)) == ARRAY_TYPE
)
3719 array_elt_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object
)));
3721 FOR_EACH_CONSTRUCTOR_ELT (elts
, ix
, purpose
, value
)
3725 /* NULL values are created above for gimplification errors. */
3729 if (cleared
&& initializer_zerop (value
))
3732 /* ??? Here's to hoping the front end fills in all of the indices,
3733 so we don't have to figure out what's missing ourselves. */
3734 gcc_assert (purpose
);
3736 /* Skip zero-sized fields, unless value has side-effects. This can
3737 happen with calls to functions returning a zero-sized type, which
3738 we shouldn't discard. As a number of downstream passes don't
3739 expect sets of zero-sized fields, we rely on the gimplification of
3740 the MODIFY_EXPR we make below to drop the assignment statement. */
3741 if (! TREE_SIDE_EFFECTS (value
) && zero_sized_field_decl (purpose
))
3744 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3746 if (TREE_CODE (purpose
) == RANGE_EXPR
)
3748 tree lower
= TREE_OPERAND (purpose
, 0);
3749 tree upper
= TREE_OPERAND (purpose
, 1);
3751 /* If the lower bound is equal to upper, just treat it as if
3752 upper was the index. */
3753 if (simple_cst_equal (lower
, upper
))
3757 gimplify_init_ctor_eval_range (object
, lower
, upper
, value
,
3758 array_elt_type
, pre_p
, cleared
);
3765 /* Do not use bitsizetype for ARRAY_REF indices. */
3766 if (TYPE_DOMAIN (TREE_TYPE (object
)))
3768 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object
))),
3770 cref
= build4 (ARRAY_REF
, array_elt_type
, unshare_expr (object
),
3771 purpose
, NULL_TREE
, NULL_TREE
);
3775 gcc_assert (TREE_CODE (purpose
) == FIELD_DECL
);
3776 cref
= build3 (COMPONENT_REF
, TREE_TYPE (purpose
),
3777 unshare_expr (object
), purpose
, NULL_TREE
);
3780 if (TREE_CODE (value
) == CONSTRUCTOR
3781 && TREE_CODE (TREE_TYPE (value
)) != VECTOR_TYPE
)
3782 gimplify_init_ctor_eval (cref
, CONSTRUCTOR_ELTS (value
),
3786 tree init
= build2 (INIT_EXPR
, TREE_TYPE (cref
), cref
, value
);
3787 gimplify_and_add (init
, pre_p
);
3793 /* Return the appropriate RHS predicate for this LHS. */
3796 rhs_predicate_for (tree lhs
)
3798 if (is_gimple_reg (lhs
))
3799 return is_gimple_reg_rhs_or_call
;
3801 return is_gimple_mem_rhs_or_call
;
3804 /* Gimplify a C99 compound literal expression. This just means adding
3805 the DECL_EXPR before the current statement and using its anonymous
3808 static enum gimplify_status
3809 gimplify_compound_literal_expr (tree
*expr_p
, gimple_seq
*pre_p
,
3810 bool (*gimple_test_f
) (tree
),
3811 fallback_t fallback
)
3813 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p
);
3814 tree decl
= DECL_EXPR_DECL (decl_s
);
3815 tree init
= DECL_INITIAL (decl
);
3816 /* Mark the decl as addressable if the compound literal
3817 expression is addressable now, otherwise it is marked too late
3818 after we gimplify the initialization expression. */
3819 if (TREE_ADDRESSABLE (*expr_p
))
3820 TREE_ADDRESSABLE (decl
) = 1;
3821 /* Otherwise, if we don't need an lvalue and have a literal directly
3822 substitute it. Check if it matches the gimple predicate, as
3823 otherwise we'd generate a new temporary, and we can as well just
3824 use the decl we already have. */
3825 else if (!TREE_ADDRESSABLE (decl
)
3827 && (fallback
& fb_lvalue
) == 0
3828 && gimple_test_f (init
))
3834 /* Preliminarily mark non-addressed complex variables as eligible
3835 for promotion to gimple registers. We'll transform their uses
3837 if ((TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
3838 || TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
)
3839 && !TREE_THIS_VOLATILE (decl
)
3840 && !needs_to_live_in_memory (decl
))
3841 DECL_GIMPLE_REG_P (decl
) = 1;
3843 /* If the decl is not addressable, then it is being used in some
3844 expression or on the right hand side of a statement, and it can
3845 be put into a readonly data section. */
3846 if (!TREE_ADDRESSABLE (decl
) && (fallback
& fb_lvalue
) == 0)
3847 TREE_READONLY (decl
) = 1;
3849 /* This decl isn't mentioned in the enclosing block, so add it to the
3850 list of temps. FIXME it seems a bit of a kludge to say that
3851 anonymous artificial vars aren't pushed, but everything else is. */
3852 if (DECL_NAME (decl
) == NULL_TREE
&& !DECL_SEEN_IN_BIND_EXPR_P (decl
))
3853 gimple_add_tmp_var (decl
);
3855 gimplify_and_add (decl_s
, pre_p
);
3860 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3861 return a new CONSTRUCTOR if something changed. */
3864 optimize_compound_literals_in_ctor (tree orig_ctor
)
3866 tree ctor
= orig_ctor
;
3867 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (ctor
);
3868 unsigned int idx
, num
= vec_safe_length (elts
);
3870 for (idx
= 0; idx
< num
; idx
++)
3872 tree value
= (*elts
)[idx
].value
;
3873 tree newval
= value
;
3874 if (TREE_CODE (value
) == CONSTRUCTOR
)
3875 newval
= optimize_compound_literals_in_ctor (value
);
3876 else if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
3878 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (value
);
3879 tree decl
= DECL_EXPR_DECL (decl_s
);
3880 tree init
= DECL_INITIAL (decl
);
3882 if (!TREE_ADDRESSABLE (value
)
3883 && !TREE_ADDRESSABLE (decl
)
3885 && TREE_CODE (init
) == CONSTRUCTOR
)
3886 newval
= optimize_compound_literals_in_ctor (init
);
3888 if (newval
== value
)
3891 if (ctor
== orig_ctor
)
3893 ctor
= copy_node (orig_ctor
);
3894 CONSTRUCTOR_ELTS (ctor
) = vec_safe_copy (elts
);
3895 elts
= CONSTRUCTOR_ELTS (ctor
);
3897 (*elts
)[idx
].value
= newval
;
3902 /* A subroutine of gimplify_modify_expr. Break out elements of a
3903 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3905 Note that we still need to clear any elements that don't have explicit
3906 initializers, so if not all elements are initialized we keep the
3907 original MODIFY_EXPR, we just remove all of the constructor elements.
3909 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3910 GS_ERROR if we would have to create a temporary when gimplifying
3911 this constructor. Otherwise, return GS_OK.
3913 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3915 static enum gimplify_status
3916 gimplify_init_constructor (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
3917 bool want_value
, bool notify_temp_creation
)
3919 tree object
, ctor
, type
;
3920 enum gimplify_status ret
;
3921 vec
<constructor_elt
, va_gc
> *elts
;
3923 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == CONSTRUCTOR
);
3925 if (!notify_temp_creation
)
3927 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
3928 is_gimple_lvalue
, fb_lvalue
);
3929 if (ret
== GS_ERROR
)
3933 object
= TREE_OPERAND (*expr_p
, 0);
3934 ctor
= TREE_OPERAND (*expr_p
, 1) =
3935 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p
, 1));
3936 type
= TREE_TYPE (ctor
);
3937 elts
= CONSTRUCTOR_ELTS (ctor
);
3940 switch (TREE_CODE (type
))
3944 case QUAL_UNION_TYPE
:
3947 struct gimplify_init_ctor_preeval_data preeval_data
;
3948 HOST_WIDE_INT num_ctor_elements
, num_nonzero_elements
;
3949 bool cleared
, complete_p
, valid_const_initializer
;
3951 /* Aggregate types must lower constructors to initialization of
3952 individual elements. The exception is that a CONSTRUCTOR node
3953 with no elements indicates zero-initialization of the whole. */
3954 if (vec_safe_is_empty (elts
))
3956 if (notify_temp_creation
)
3961 /* Fetch information about the constructor to direct later processing.
3962 We might want to make static versions of it in various cases, and
3963 can only do so if it known to be a valid constant initializer. */
3964 valid_const_initializer
3965 = categorize_ctor_elements (ctor
, &num_nonzero_elements
,
3966 &num_ctor_elements
, &complete_p
);
3968 /* If a const aggregate variable is being initialized, then it
3969 should never be a lose to promote the variable to be static. */
3970 if (valid_const_initializer
3971 && num_nonzero_elements
> 1
3972 && TREE_READONLY (object
)
3973 && TREE_CODE (object
) == VAR_DECL
3974 && (flag_merge_constants
>= 2 || !TREE_ADDRESSABLE (object
)))
3976 if (notify_temp_creation
)
3978 DECL_INITIAL (object
) = ctor
;
3979 TREE_STATIC (object
) = 1;
3980 if (!DECL_NAME (object
))
3981 DECL_NAME (object
) = create_tmp_var_name ("C");
3982 walk_tree (&DECL_INITIAL (object
), force_labels_r
, NULL
, NULL
);
3984 /* ??? C++ doesn't automatically append a .<number> to the
3985 assembler name, and even when it does, it looks at FE private
3986 data structures to figure out what that number should be,
3987 which are not set for this variable. I suppose this is
3988 important for local statics for inline functions, which aren't
3989 "local" in the object file sense. So in order to get a unique
3990 TU-local symbol, we must invoke the lhd version now. */
3991 lhd_set_decl_assembler_name (object
);
3993 *expr_p
= NULL_TREE
;
3997 /* If there are "lots" of initialized elements, even discounting
3998 those that are not address constants (and thus *must* be
3999 computed at runtime), then partition the constructor into
4000 constant and non-constant parts. Block copy the constant
4001 parts in, then generate code for the non-constant parts. */
4002 /* TODO. There's code in cp/typeck.c to do this. */
4004 if (int_size_in_bytes (TREE_TYPE (ctor
)) < 0)
4005 /* store_constructor will ignore the clearing of variable-sized
4006 objects. Initializers for such objects must explicitly set
4007 every field that needs to be set. */
4009 else if (!complete_p
)
4010 /* If the constructor isn't complete, clear the whole object
4013 ??? This ought not to be needed. For any element not present
4014 in the initializer, we should simply set them to zero. Except
4015 we'd need to *find* the elements that are not present, and that
4016 requires trickery to avoid quadratic compile-time behavior in
4017 large cases or excessive memory use in small cases. */
4019 else if (num_ctor_elements
- num_nonzero_elements
4020 > CLEAR_RATIO (optimize_function_for_speed_p (cfun
))
4021 && num_nonzero_elements
< num_ctor_elements
/ 4)
4022 /* If there are "lots" of zeros, it's more efficient to clear
4023 the memory and then set the nonzero elements. */
4028 /* If there are "lots" of initialized elements, and all of them
4029 are valid address constants, then the entire initializer can
4030 be dropped to memory, and then memcpy'd out. Don't do this
4031 for sparse arrays, though, as it's more efficient to follow
4032 the standard CONSTRUCTOR behavior of memset followed by
4033 individual element initialization. Also don't do this for small
4034 all-zero initializers (which aren't big enough to merit
4035 clearing), and don't try to make bitwise copies of
4036 TREE_ADDRESSABLE types. */
4037 if (valid_const_initializer
4038 && !(cleared
|| num_nonzero_elements
== 0)
4039 && !TREE_ADDRESSABLE (type
))
4041 HOST_WIDE_INT size
= int_size_in_bytes (type
);
4044 /* ??? We can still get unbounded array types, at least
4045 from the C++ front end. This seems wrong, but attempt
4046 to work around it for now. */
4049 size
= int_size_in_bytes (TREE_TYPE (object
));
4051 TREE_TYPE (ctor
) = type
= TREE_TYPE (object
);
4054 /* Find the maximum alignment we can assume for the object. */
4055 /* ??? Make use of DECL_OFFSET_ALIGN. */
4056 if (DECL_P (object
))
4057 align
= DECL_ALIGN (object
);
4059 align
= TYPE_ALIGN (type
);
4061 /* Do a block move either if the size is so small as to make
4062 each individual move a sub-unit move on average, or if it
4063 is so large as to make individual moves inefficient. */
4065 && num_nonzero_elements
> 1
4066 && (size
< num_nonzero_elements
4067 || !can_move_by_pieces (size
, align
)))
4069 if (notify_temp_creation
)
4072 walk_tree (&ctor
, force_labels_r
, NULL
, NULL
);
4073 ctor
= tree_output_constant_def (ctor
);
4074 if (!useless_type_conversion_p (type
, TREE_TYPE (ctor
)))
4075 ctor
= build1 (VIEW_CONVERT_EXPR
, type
, ctor
);
4076 TREE_OPERAND (*expr_p
, 1) = ctor
;
4078 /* This is no longer an assignment of a CONSTRUCTOR, but
4079 we still may have processing to do on the LHS. So
4080 pretend we didn't do anything here to let that happen. */
4081 return GS_UNHANDLED
;
4085 /* If the target is volatile, we have non-zero elements and more than
4086 one field to assign, initialize the target from a temporary. */
4087 if (TREE_THIS_VOLATILE (object
)
4088 && !TREE_ADDRESSABLE (type
)
4089 && num_nonzero_elements
> 0
4090 && vec_safe_length (elts
) > 1)
4092 tree temp
= create_tmp_var (TYPE_MAIN_VARIANT (type
), NULL
);
4093 TREE_OPERAND (*expr_p
, 0) = temp
;
4094 *expr_p
= build2 (COMPOUND_EXPR
, TREE_TYPE (*expr_p
),
4096 build2 (MODIFY_EXPR
, void_type_node
,
4101 if (notify_temp_creation
)
4104 /* If there are nonzero elements and if needed, pre-evaluate to capture
4105 elements overlapping with the lhs into temporaries. We must do this
4106 before clearing to fetch the values before they are zeroed-out. */
4107 if (num_nonzero_elements
> 0 && TREE_CODE (*expr_p
) != INIT_EXPR
)
4109 preeval_data
.lhs_base_decl
= get_base_address (object
);
4110 if (!DECL_P (preeval_data
.lhs_base_decl
))
4111 preeval_data
.lhs_base_decl
= NULL
;
4112 preeval_data
.lhs_alias_set
= get_alias_set (object
);
4114 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p
, 1),
4115 pre_p
, post_p
, &preeval_data
);
4120 /* Zap the CONSTRUCTOR element list, which simplifies this case.
4121 Note that we still have to gimplify, in order to handle the
4122 case of variable sized types. Avoid shared tree structures. */
4123 CONSTRUCTOR_ELTS (ctor
) = NULL
;
4124 TREE_SIDE_EFFECTS (ctor
) = 0;
4125 object
= unshare_expr (object
);
4126 gimplify_stmt (expr_p
, pre_p
);
4129 /* If we have not block cleared the object, or if there are nonzero
4130 elements in the constructor, add assignments to the individual
4131 scalar fields of the object. */
4132 if (!cleared
|| num_nonzero_elements
> 0)
4133 gimplify_init_ctor_eval (object
, elts
, pre_p
, cleared
);
4135 *expr_p
= NULL_TREE
;
4143 if (notify_temp_creation
)
4146 /* Extract the real and imaginary parts out of the ctor. */
4147 gcc_assert (elts
->length () == 2);
4148 r
= (*elts
)[0].value
;
4149 i
= (*elts
)[1].value
;
4150 if (r
== NULL
|| i
== NULL
)
4152 tree zero
= build_zero_cst (TREE_TYPE (type
));
4159 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
4160 represent creation of a complex value. */
4161 if (TREE_CONSTANT (r
) && TREE_CONSTANT (i
))
4163 ctor
= build_complex (type
, r
, i
);
4164 TREE_OPERAND (*expr_p
, 1) = ctor
;
4168 ctor
= build2 (COMPLEX_EXPR
, type
, r
, i
);
4169 TREE_OPERAND (*expr_p
, 1) = ctor
;
4170 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1),
4173 rhs_predicate_for (TREE_OPERAND (*expr_p
, 0)),
4181 unsigned HOST_WIDE_INT ix
;
4182 constructor_elt
*ce
;
4184 if (notify_temp_creation
)
4187 /* Go ahead and simplify constant constructors to VECTOR_CST. */
4188 if (TREE_CONSTANT (ctor
))
4190 bool constant_p
= true;
4193 /* Even when ctor is constant, it might contain non-*_CST
4194 elements, such as addresses or trapping values like
4195 1.0/0.0 - 1.0/0.0. Such expressions don't belong
4196 in VECTOR_CST nodes. */
4197 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
4198 if (!CONSTANT_CLASS_P (value
))
4206 TREE_OPERAND (*expr_p
, 1) = build_vector_from_ctor (type
, elts
);
4210 /* Don't reduce an initializer constant even if we can't
4211 make a VECTOR_CST. It won't do anything for us, and it'll
4212 prevent us from representing it as a single constant. */
4213 if (initializer_constant_valid_p (ctor
, type
))
4216 TREE_CONSTANT (ctor
) = 0;
4219 /* Vector types use CONSTRUCTOR all the way through gimple
4220 compilation as a general initializer. */
4221 FOR_EACH_VEC_SAFE_ELT (elts
, ix
, ce
)
4223 enum gimplify_status tret
;
4224 tret
= gimplify_expr (&ce
->value
, pre_p
, post_p
, is_gimple_val
,
4226 if (tret
== GS_ERROR
)
4229 if (!is_gimple_reg (TREE_OPERAND (*expr_p
, 0)))
4230 TREE_OPERAND (*expr_p
, 1) = get_formal_tmp_var (ctor
, pre_p
);
4235 /* So how did we get a CONSTRUCTOR for a scalar type? */
4239 if (ret
== GS_ERROR
)
4241 else if (want_value
)
4248 /* If we have gimplified both sides of the initializer but have
4249 not emitted an assignment, do so now. */
4252 tree lhs
= TREE_OPERAND (*expr_p
, 0);
4253 tree rhs
= TREE_OPERAND (*expr_p
, 1);
4254 gimple init
= gimple_build_assign (lhs
, rhs
);
4255 gimplify_seq_add_stmt (pre_p
, init
);
4263 /* Given a pointer value OP0, return a simplified version of an
4264 indirection through OP0, or NULL_TREE if no simplification is
4265 possible. Note that the resulting type may be different from
4266 the type pointed to in the sense that it is still compatible
4267 from the langhooks point of view. */
4270 gimple_fold_indirect_ref (tree t
)
4272 tree ptype
= TREE_TYPE (t
), type
= TREE_TYPE (ptype
);
4277 subtype
= TREE_TYPE (sub
);
4278 if (!POINTER_TYPE_P (subtype
))
4281 if (TREE_CODE (sub
) == ADDR_EXPR
)
4283 tree op
= TREE_OPERAND (sub
, 0);
4284 tree optype
= TREE_TYPE (op
);
4286 if (useless_type_conversion_p (type
, optype
))
4289 /* *(foo *)&fooarray => fooarray[0] */
4290 if (TREE_CODE (optype
) == ARRAY_TYPE
4291 && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype
))) == INTEGER_CST
4292 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4294 tree type_domain
= TYPE_DOMAIN (optype
);
4295 tree min_val
= size_zero_node
;
4296 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
4297 min_val
= TYPE_MIN_VALUE (type_domain
);
4298 if (TREE_CODE (min_val
) == INTEGER_CST
)
4299 return build4 (ARRAY_REF
, type
, op
, min_val
, NULL_TREE
, NULL_TREE
);
4301 /* *(foo *)&complexfoo => __real__ complexfoo */
4302 else if (TREE_CODE (optype
) == COMPLEX_TYPE
4303 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4304 return fold_build1 (REALPART_EXPR
, type
, op
);
4305 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
4306 else if (TREE_CODE (optype
) == VECTOR_TYPE
4307 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
4309 tree part_width
= TYPE_SIZE (type
);
4310 tree index
= bitsize_int (0);
4311 return fold_build3 (BIT_FIELD_REF
, type
, op
, part_width
, index
);
4315 /* *(p + CST) -> ... */
4316 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
4317 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
4319 tree addr
= TREE_OPERAND (sub
, 0);
4320 tree off
= TREE_OPERAND (sub
, 1);
4324 addrtype
= TREE_TYPE (addr
);
4326 /* ((foo*)&vectorfoo)[1] -> BIT_FIELD_REF<vectorfoo,...> */
4327 if (TREE_CODE (addr
) == ADDR_EXPR
4328 && TREE_CODE (TREE_TYPE (addrtype
)) == VECTOR_TYPE
4329 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
)))
4330 && host_integerp (off
, 1))
4332 unsigned HOST_WIDE_INT offset
= tree_low_cst (off
, 1);
4333 tree part_width
= TYPE_SIZE (type
);
4334 unsigned HOST_WIDE_INT part_widthi
4335 = tree_low_cst (part_width
, 0) / BITS_PER_UNIT
;
4336 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
4337 tree index
= bitsize_int (indexi
);
4338 if (offset
/ part_widthi
4339 <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype
)))
4340 return fold_build3 (BIT_FIELD_REF
, type
, TREE_OPERAND (addr
, 0),
4344 /* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
4345 if (TREE_CODE (addr
) == ADDR_EXPR
4346 && TREE_CODE (TREE_TYPE (addrtype
)) == COMPLEX_TYPE
4347 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
))))
4349 tree size
= TYPE_SIZE_UNIT (type
);
4350 if (tree_int_cst_equal (size
, off
))
4351 return fold_build1 (IMAGPART_EXPR
, type
, TREE_OPERAND (addr
, 0));
4354 /* *(p + CST) -> MEM_REF <p, CST>. */
4355 if (TREE_CODE (addr
) != ADDR_EXPR
4356 || DECL_P (TREE_OPERAND (addr
, 0)))
4357 return fold_build2 (MEM_REF
, type
,
4359 build_int_cst_wide (ptype
,
4360 TREE_INT_CST_LOW (off
),
4361 TREE_INT_CST_HIGH (off
)));
4364 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
4365 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
4366 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (subtype
)))) == INTEGER_CST
4367 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (subtype
))))
4370 tree min_val
= size_zero_node
;
4372 sub
= gimple_fold_indirect_ref (sub
);
4374 sub
= build1 (INDIRECT_REF
, TREE_TYPE (subtype
), osub
);
4375 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
4376 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
4377 min_val
= TYPE_MIN_VALUE (type_domain
);
4378 if (TREE_CODE (min_val
) == INTEGER_CST
)
4379 return build4 (ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
, NULL_TREE
);
4385 /* Given a pointer value OP0, return a simplified version of an
4386 indirection through OP0, or NULL_TREE if no simplification is
4387 possible. This may only be applied to a rhs of an expression.
4388 Note that the resulting type may be different from the type pointed
4389 to in the sense that it is still compatible from the langhooks
4393 gimple_fold_indirect_ref_rhs (tree t
)
4395 return gimple_fold_indirect_ref (t
);
4398 /* Subroutine of gimplify_modify_expr to do simplifications of
4399 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4400 something changes. */
4402 static enum gimplify_status
4403 gimplify_modify_expr_rhs (tree
*expr_p
, tree
*from_p
, tree
*to_p
,
4404 gimple_seq
*pre_p
, gimple_seq
*post_p
,
4407 enum gimplify_status ret
= GS_UNHANDLED
;
4413 switch (TREE_CODE (*from_p
))
4416 /* If we're assigning from a read-only variable initialized with
4417 a constructor, do the direct assignment from the constructor,
4418 but only if neither source nor target are volatile since this
4419 latter assignment might end up being done on a per-field basis. */
4420 if (DECL_INITIAL (*from_p
)
4421 && TREE_READONLY (*from_p
)
4422 && !TREE_THIS_VOLATILE (*from_p
)
4423 && !TREE_THIS_VOLATILE (*to_p
)
4424 && TREE_CODE (DECL_INITIAL (*from_p
)) == CONSTRUCTOR
)
4426 tree old_from
= *from_p
;
4427 enum gimplify_status subret
;
4429 /* Move the constructor into the RHS. */
4430 *from_p
= unshare_expr (DECL_INITIAL (*from_p
));
4432 /* Let's see if gimplify_init_constructor will need to put
4434 subret
= gimplify_init_constructor (expr_p
, NULL
, NULL
,
4436 if (subret
== GS_ERROR
)
4438 /* If so, revert the change. */
4450 /* If we have code like
4454 where the type of "x" is a (possibly cv-qualified variant
4455 of "A"), treat the entire expression as identical to "x".
4456 This kind of code arises in C++ when an object is bound
4457 to a const reference, and if "x" is a TARGET_EXPR we want
4458 to take advantage of the optimization below. */
4459 bool volatile_p
= TREE_THIS_VOLATILE (*from_p
);
4460 tree t
= gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p
, 0));
4463 if (TREE_THIS_VOLATILE (t
) != volatile_p
)
4465 if (TREE_CODE_CLASS (TREE_CODE (t
)) == tcc_declaration
)
4466 t
= build_simple_mem_ref_loc (EXPR_LOCATION (*from_p
),
4467 build_fold_addr_expr (t
));
4468 if (REFERENCE_CLASS_P (t
))
4469 TREE_THIS_VOLATILE (t
) = volatile_p
;
4480 /* If we are initializing something from a TARGET_EXPR, strip the
4481 TARGET_EXPR and initialize it directly, if possible. This can't
4482 be done if the initializer is void, since that implies that the
4483 temporary is set in some non-trivial way.
4485 ??? What about code that pulls out the temp and uses it
4486 elsewhere? I think that such code never uses the TARGET_EXPR as
4487 an initializer. If I'm wrong, we'll die because the temp won't
4488 have any RTL. In that case, I guess we'll need to replace
4489 references somehow. */
4490 tree init
= TARGET_EXPR_INITIAL (*from_p
);
4493 && !VOID_TYPE_P (TREE_TYPE (init
)))
4503 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4505 gimplify_compound_expr (from_p
, pre_p
, true);
4511 /* If we already made some changes, let the front end have a
4512 crack at this before we break it down. */
4513 if (ret
!= GS_UNHANDLED
)
4515 /* If we're initializing from a CONSTRUCTOR, break this into
4516 individual MODIFY_EXPRs. */
4517 return gimplify_init_constructor (expr_p
, pre_p
, post_p
, want_value
,
4521 /* If we're assigning to a non-register type, push the assignment
4522 down into the branches. This is mandatory for ADDRESSABLE types,
4523 since we cannot generate temporaries for such, but it saves a
4524 copy in other cases as well. */
4525 if (!is_gimple_reg_type (TREE_TYPE (*from_p
)))
4527 /* This code should mirror the code in gimplify_cond_expr. */
4528 enum tree_code code
= TREE_CODE (*expr_p
);
4529 tree cond
= *from_p
;
4530 tree result
= *to_p
;
4532 ret
= gimplify_expr (&result
, pre_p
, post_p
,
4533 is_gimple_lvalue
, fb_lvalue
);
4534 if (ret
!= GS_ERROR
)
4537 if (TREE_TYPE (TREE_OPERAND (cond
, 1)) != void_type_node
)
4538 TREE_OPERAND (cond
, 1)
4539 = build2 (code
, void_type_node
, result
,
4540 TREE_OPERAND (cond
, 1));
4541 if (TREE_TYPE (TREE_OPERAND (cond
, 2)) != void_type_node
)
4542 TREE_OPERAND (cond
, 2)
4543 = build2 (code
, void_type_node
, unshare_expr (result
),
4544 TREE_OPERAND (cond
, 2));
4546 TREE_TYPE (cond
) = void_type_node
;
4547 recalculate_side_effects (cond
);
4551 gimplify_and_add (cond
, pre_p
);
4552 *expr_p
= unshare_expr (result
);
4561 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4562 return slot so that we don't generate a temporary. */
4563 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p
)
4564 && aggregate_value_p (*from_p
, *from_p
))
4568 if (!(rhs_predicate_for (*to_p
))(*from_p
))
4569 /* If we need a temporary, *to_p isn't accurate. */
4571 /* It's OK to use the return slot directly unless it's an NRV. */
4572 else if (TREE_CODE (*to_p
) == RESULT_DECL
4573 && DECL_NAME (*to_p
) == NULL_TREE
4574 && needs_to_live_in_memory (*to_p
))
4576 else if (is_gimple_reg_type (TREE_TYPE (*to_p
))
4577 || (DECL_P (*to_p
) && DECL_REGISTER (*to_p
)))
4578 /* Don't force regs into memory. */
4580 else if (TREE_CODE (*expr_p
) == INIT_EXPR
)
4581 /* It's OK to use the target directly if it's being
4584 else if (variably_modified_type_p (TREE_TYPE (*to_p
), NULL_TREE
))
4585 /* Always use the target and thus RSO for variable-sized types.
4586 GIMPLE cannot deal with a variable-sized assignment
4587 embedded in a call statement. */
4589 else if (TREE_CODE (*to_p
) != SSA_NAME
4590 && (!is_gimple_variable (*to_p
)
4591 || needs_to_live_in_memory (*to_p
)))
4592 /* Don't use the original target if it's already addressable;
4593 if its address escapes, and the called function uses the
4594 NRV optimization, a conforming program could see *to_p
4595 change before the called function returns; see c++/19317.
4596 When optimizing, the return_slot pass marks more functions
4597 as safe after we have escape info. */
4604 CALL_EXPR_RETURN_SLOT_OPT (*from_p
) = 1;
4605 mark_addressable (*to_p
);
4610 case WITH_SIZE_EXPR
:
4611 /* Likewise for calls that return an aggregate of non-constant size,
4612 since we would not be able to generate a temporary at all. */
4613 if (TREE_CODE (TREE_OPERAND (*from_p
, 0)) == CALL_EXPR
)
4615 *from_p
= TREE_OPERAND (*from_p
, 0);
4616 /* We don't change ret in this case because the
4617 WITH_SIZE_EXPR might have been added in
4618 gimplify_modify_expr, so returning GS_OK would lead to an
4624 /* If we're initializing from a container, push the initialization
4626 case CLEANUP_POINT_EXPR
:
4628 case STATEMENT_LIST
:
4630 tree wrap
= *from_p
;
4633 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_min_lval
,
4635 if (ret
!= GS_ERROR
)
4638 t
= voidify_wrapper_expr (wrap
, *expr_p
);
4639 gcc_assert (t
== *expr_p
);
4643 gimplify_and_add (wrap
, pre_p
);
4644 *expr_p
= unshare_expr (*to_p
);
4651 case COMPOUND_LITERAL_EXPR
:
4653 tree complit
= TREE_OPERAND (*expr_p
, 1);
4654 tree decl_s
= COMPOUND_LITERAL_EXPR_DECL_EXPR (complit
);
4655 tree decl
= DECL_EXPR_DECL (decl_s
);
4656 tree init
= DECL_INITIAL (decl
);
4658 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4659 into struct T x = { 0, 1, 2 } if the address of the
4660 compound literal has never been taken. */
4661 if (!TREE_ADDRESSABLE (complit
)
4662 && !TREE_ADDRESSABLE (decl
)
4665 *expr_p
= copy_node (*expr_p
);
4666 TREE_OPERAND (*expr_p
, 1) = init
;
4681 /* Return true if T looks like a valid GIMPLE statement. */
4684 is_gimple_stmt (tree t
)
4686 const enum tree_code code
= TREE_CODE (t
);
4691 /* The only valid NOP_EXPR is the empty statement. */
4692 return IS_EMPTY_STMT (t
);
4696 /* These are only valid if they're void. */
4697 return TREE_TYPE (t
) == NULL
|| VOID_TYPE_P (TREE_TYPE (t
));
4703 case CASE_LABEL_EXPR
:
4704 case TRY_CATCH_EXPR
:
4705 case TRY_FINALLY_EXPR
:
4706 case EH_FILTER_EXPR
:
4709 case STATEMENT_LIST
:
4720 /* These are always void. */
4726 /* These are valid regardless of their type. */
4735 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4736 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4737 DECL_GIMPLE_REG_P set.
4739 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4740 other, unmodified part of the complex object just before the total store.
4741 As a consequence, if the object is still uninitialized, an undefined value
4742 will be loaded into a register, which may result in a spurious exception
4743 if the register is floating-point and the value happens to be a signaling
4744 NaN for example. Then the fully-fledged complex operations lowering pass
4745 followed by a DCE pass are necessary in order to fix things up. */
4747 static enum gimplify_status
4748 gimplify_modify_expr_complex_part (tree
*expr_p
, gimple_seq
*pre_p
,
4751 enum tree_code code
, ocode
;
4752 tree lhs
, rhs
, new_rhs
, other
, realpart
, imagpart
;
4754 lhs
= TREE_OPERAND (*expr_p
, 0);
4755 rhs
= TREE_OPERAND (*expr_p
, 1);
4756 code
= TREE_CODE (lhs
);
4757 lhs
= TREE_OPERAND (lhs
, 0);
4759 ocode
= code
== REALPART_EXPR
? IMAGPART_EXPR
: REALPART_EXPR
;
4760 other
= build1 (ocode
, TREE_TYPE (rhs
), lhs
);
4761 TREE_NO_WARNING (other
) = 1;
4762 other
= get_formal_tmp_var (other
, pre_p
);
4764 realpart
= code
== REALPART_EXPR
? rhs
: other
;
4765 imagpart
= code
== REALPART_EXPR
? other
: rhs
;
4767 if (TREE_CONSTANT (realpart
) && TREE_CONSTANT (imagpart
))
4768 new_rhs
= build_complex (TREE_TYPE (lhs
), realpart
, imagpart
);
4770 new_rhs
= build2 (COMPLEX_EXPR
, TREE_TYPE (lhs
), realpart
, imagpart
);
4772 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (lhs
, new_rhs
));
4773 *expr_p
= (want_value
) ? rhs
: NULL_TREE
;
4778 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4784 PRE_P points to the list where side effects that must happen before
4785 *EXPR_P should be stored.
4787 POST_P points to the list where side effects that must happen after
4788 *EXPR_P should be stored.
4790 WANT_VALUE is nonzero iff we want to use the value of this expression
4791 in another expression. */
4793 static enum gimplify_status
4794 gimplify_modify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
4797 tree
*from_p
= &TREE_OPERAND (*expr_p
, 1);
4798 tree
*to_p
= &TREE_OPERAND (*expr_p
, 0);
4799 enum gimplify_status ret
= GS_UNHANDLED
;
4801 location_t loc
= EXPR_LOCATION (*expr_p
);
4802 gimple_stmt_iterator gsi
;
4804 gcc_assert (TREE_CODE (*expr_p
) == MODIFY_EXPR
4805 || TREE_CODE (*expr_p
) == INIT_EXPR
);
4807 /* Trying to simplify a clobber using normal logic doesn't work,
4808 so handle it here. */
4809 if (TREE_CLOBBER_P (*from_p
))
4811 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4812 if (ret
== GS_ERROR
)
4814 gcc_assert (!want_value
4815 && (TREE_CODE (*to_p
) == VAR_DECL
4816 || TREE_CODE (*to_p
) == MEM_REF
));
4817 gimplify_seq_add_stmt (pre_p
, gimple_build_assign (*to_p
, *from_p
));
4822 /* Insert pointer conversions required by the middle-end that are not
4823 required by the frontend. This fixes middle-end type checking for
4824 for example gcc.dg/redecl-6.c. */
4825 if (POINTER_TYPE_P (TREE_TYPE (*to_p
)))
4827 STRIP_USELESS_TYPE_CONVERSION (*from_p
);
4828 if (!useless_type_conversion_p (TREE_TYPE (*to_p
), TREE_TYPE (*from_p
)))
4829 *from_p
= fold_convert_loc (loc
, TREE_TYPE (*to_p
), *from_p
);
4832 /* See if any simplifications can be done based on what the RHS is. */
4833 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4835 if (ret
!= GS_UNHANDLED
)
4838 /* For zero sized types only gimplify the left hand side and right hand
4839 side as statements and throw away the assignment. Do this after
4840 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4842 if (zero_sized_type (TREE_TYPE (*from_p
)) && !want_value
)
4844 gimplify_stmt (from_p
, pre_p
);
4845 gimplify_stmt (to_p
, pre_p
);
4846 *expr_p
= NULL_TREE
;
4850 /* If the value being copied is of variable width, compute the length
4851 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4852 before gimplifying any of the operands so that we can resolve any
4853 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4854 the size of the expression to be copied, not of the destination, so
4855 that is what we must do here. */
4856 maybe_with_size_expr (from_p
);
4858 ret
= gimplify_expr (to_p
, pre_p
, post_p
, is_gimple_lvalue
, fb_lvalue
);
4859 if (ret
== GS_ERROR
)
4862 /* As a special case, we have to temporarily allow for assignments
4863 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4864 a toplevel statement, when gimplifying the GENERIC expression
4865 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4866 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4868 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4869 prevent gimplify_expr from trying to create a new temporary for
4870 foo's LHS, we tell it that it should only gimplify until it
4871 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4872 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4873 and all we need to do here is set 'a' to be its LHS. */
4874 ret
= gimplify_expr (from_p
, pre_p
, post_p
, rhs_predicate_for (*to_p
),
4876 if (ret
== GS_ERROR
)
4879 /* Now see if the above changed *from_p to something we handle specially. */
4880 ret
= gimplify_modify_expr_rhs (expr_p
, from_p
, to_p
, pre_p
, post_p
,
4882 if (ret
!= GS_UNHANDLED
)
4885 /* If we've got a variable sized assignment between two lvalues (i.e. does
4886 not involve a call), then we can make things a bit more straightforward
4887 by converting the assignment to memcpy or memset. */
4888 if (TREE_CODE (*from_p
) == WITH_SIZE_EXPR
)
4890 tree from
= TREE_OPERAND (*from_p
, 0);
4891 tree size
= TREE_OPERAND (*from_p
, 1);
4893 if (TREE_CODE (from
) == CONSTRUCTOR
)
4894 return gimplify_modify_expr_to_memset (expr_p
, size
, want_value
, pre_p
);
4896 if (is_gimple_addressable (from
))
4899 return gimplify_modify_expr_to_memcpy (expr_p
, size
, want_value
,
4904 /* Transform partial stores to non-addressable complex variables into
4905 total stores. This allows us to use real instead of virtual operands
4906 for these variables, which improves optimization. */
4907 if ((TREE_CODE (*to_p
) == REALPART_EXPR
4908 || TREE_CODE (*to_p
) == IMAGPART_EXPR
)
4909 && is_gimple_reg (TREE_OPERAND (*to_p
, 0)))
4910 return gimplify_modify_expr_complex_part (expr_p
, pre_p
, want_value
);
4912 /* Try to alleviate the effects of the gimplification creating artificial
4913 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
4914 if (!gimplify_ctxp
->into_ssa
4915 && TREE_CODE (*from_p
) == VAR_DECL
4916 && DECL_IGNORED_P (*from_p
)
4918 && !DECL_IGNORED_P (*to_p
))
4920 if (!DECL_NAME (*from_p
) && DECL_NAME (*to_p
))
4922 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p
)));
4923 DECL_HAS_DEBUG_EXPR_P (*from_p
) = 1;
4924 SET_DECL_DEBUG_EXPR (*from_p
, *to_p
);
4927 if (want_value
&& TREE_THIS_VOLATILE (*to_p
))
4928 *from_p
= get_initialized_tmp_var (*from_p
, pre_p
, post_p
);
4930 if (TREE_CODE (*from_p
) == CALL_EXPR
)
4932 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4933 instead of a GIMPLE_ASSIGN. */
4934 tree fnptrtype
= TREE_TYPE (CALL_EXPR_FN (*from_p
));
4935 CALL_EXPR_FN (*from_p
) = TREE_OPERAND (CALL_EXPR_FN (*from_p
), 0);
4936 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p
));
4937 assign
= gimple_build_call_from_tree (*from_p
);
4938 gimple_call_set_fntype (assign
, TREE_TYPE (fnptrtype
));
4939 notice_special_calls (assign
);
4940 if (!gimple_call_noreturn_p (assign
))
4941 gimple_call_set_lhs (assign
, *to_p
);
4945 assign
= gimple_build_assign (*to_p
, *from_p
);
4946 gimple_set_location (assign
, EXPR_LOCATION (*expr_p
));
4949 if (gimplify_ctxp
->into_ssa
&& is_gimple_reg (*to_p
))
4951 /* We should have got an SSA name from the start. */
4952 gcc_assert (TREE_CODE (*to_p
) == SSA_NAME
);
4955 gimplify_seq_add_stmt (pre_p
, assign
);
4956 gsi
= gsi_last (*pre_p
);
4961 *expr_p
= TREE_THIS_VOLATILE (*to_p
) ? *from_p
: unshare_expr (*to_p
);
4970 /* Gimplify a comparison between two variable-sized objects. Do this
4971 with a call to BUILT_IN_MEMCMP. */
4973 static enum gimplify_status
4974 gimplify_variable_sized_compare (tree
*expr_p
)
4976 location_t loc
= EXPR_LOCATION (*expr_p
);
4977 tree op0
= TREE_OPERAND (*expr_p
, 0);
4978 tree op1
= TREE_OPERAND (*expr_p
, 1);
4979 tree t
, arg
, dest
, src
, expr
;
4981 arg
= TYPE_SIZE_UNIT (TREE_TYPE (op0
));
4982 arg
= unshare_expr (arg
);
4983 arg
= SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg
, op0
);
4984 src
= build_fold_addr_expr_loc (loc
, op1
);
4985 dest
= build_fold_addr_expr_loc (loc
, op0
);
4986 t
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
4987 t
= build_call_expr_loc (loc
, t
, 3, dest
, src
, arg
);
4990 = build2 (TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), t
, integer_zero_node
);
4991 SET_EXPR_LOCATION (expr
, loc
);
4997 /* Gimplify a comparison between two aggregate objects of integral scalar
4998 mode as a comparison between the bitwise equivalent scalar values. */
5000 static enum gimplify_status
5001 gimplify_scalar_mode_aggregate_compare (tree
*expr_p
)
5003 location_t loc
= EXPR_LOCATION (*expr_p
);
5004 tree op0
= TREE_OPERAND (*expr_p
, 0);
5005 tree op1
= TREE_OPERAND (*expr_p
, 1);
5007 tree type
= TREE_TYPE (op0
);
5008 tree scalar_type
= lang_hooks
.types
.type_for_mode (TYPE_MODE (type
), 1);
5010 op0
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op0
);
5011 op1
= fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, scalar_type
, op1
);
5014 = fold_build2_loc (loc
, TREE_CODE (*expr_p
), TREE_TYPE (*expr_p
), op0
, op1
);
5019 /* Gimplify an expression sequence. This function gimplifies each
5020 expression and rewrites the original expression with the last
5021 expression of the sequence in GIMPLE form.
5023 PRE_P points to the list where the side effects for all the
5024 expressions in the sequence will be emitted.
5026 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
5028 static enum gimplify_status
5029 gimplify_compound_expr (tree
*expr_p
, gimple_seq
*pre_p
, bool want_value
)
5035 tree
*sub_p
= &TREE_OPERAND (t
, 0);
5037 if (TREE_CODE (*sub_p
) == COMPOUND_EXPR
)
5038 gimplify_compound_expr (sub_p
, pre_p
, false);
5040 gimplify_stmt (sub_p
, pre_p
);
5042 t
= TREE_OPERAND (t
, 1);
5044 while (TREE_CODE (t
) == COMPOUND_EXPR
);
5051 gimplify_stmt (expr_p
, pre_p
);
5056 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
5057 gimplify. After gimplification, EXPR_P will point to a new temporary
5058 that holds the original value of the SAVE_EXPR node.
5060 PRE_P points to the list where side effects that must happen before
5061 *EXPR_P should be stored. */
5063 static enum gimplify_status
5064 gimplify_save_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5066 enum gimplify_status ret
= GS_ALL_DONE
;
5069 gcc_assert (TREE_CODE (*expr_p
) == SAVE_EXPR
);
5070 val
= TREE_OPERAND (*expr_p
, 0);
5072 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
5073 if (!SAVE_EXPR_RESOLVED_P (*expr_p
))
5075 /* The operand may be a void-valued expression such as SAVE_EXPRs
5076 generated by the Java frontend for class initialization. It is
5077 being executed only for its side-effects. */
5078 if (TREE_TYPE (val
) == void_type_node
)
5080 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
5081 is_gimple_stmt
, fb_none
);
5085 val
= get_initialized_tmp_var (val
, pre_p
, post_p
);
5087 TREE_OPERAND (*expr_p
, 0) = val
;
5088 SAVE_EXPR_RESOLVED_P (*expr_p
) = 1;
5096 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
5103 PRE_P points to the list where side effects that must happen before
5104 *EXPR_P should be stored.
5106 POST_P points to the list where side effects that must happen after
5107 *EXPR_P should be stored. */
5109 static enum gimplify_status
5110 gimplify_addr_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5112 tree expr
= *expr_p
;
5113 tree op0
= TREE_OPERAND (expr
, 0);
5114 enum gimplify_status ret
;
5115 location_t loc
= EXPR_LOCATION (*expr_p
);
5117 switch (TREE_CODE (op0
))
5121 /* Check if we are dealing with an expression of the form '&*ptr'.
5122 While the front end folds away '&*ptr' into 'ptr', these
5123 expressions may be generated internally by the compiler (e.g.,
5124 builtins like __builtin_va_end). */
5125 /* Caution: the silent array decomposition semantics we allow for
5126 ADDR_EXPR means we can't always discard the pair. */
5127 /* Gimplification of the ADDR_EXPR operand may drop
5128 cv-qualification conversions, so make sure we add them if
5131 tree op00
= TREE_OPERAND (op0
, 0);
5132 tree t_expr
= TREE_TYPE (expr
);
5133 tree t_op00
= TREE_TYPE (op00
);
5135 if (!useless_type_conversion_p (t_expr
, t_op00
))
5136 op00
= fold_convert_loc (loc
, TREE_TYPE (expr
), op00
);
5142 case VIEW_CONVERT_EXPR
:
5143 /* Take the address of our operand and then convert it to the type of
5146 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
5147 all clear. The impact of this transformation is even less clear. */
5149 /* If the operand is a useless conversion, look through it. Doing so
5150 guarantees that the ADDR_EXPR and its operand will remain of the
5152 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0
, 0)))
5153 op0
= TREE_OPERAND (op0
, 0);
5155 *expr_p
= fold_convert_loc (loc
, TREE_TYPE (expr
),
5156 build_fold_addr_expr_loc (loc
,
5157 TREE_OPERAND (op0
, 0)));
5162 /* We use fb_either here because the C frontend sometimes takes
5163 the address of a call that returns a struct; see
5164 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
5165 the implied temporary explicit. */
5167 /* Make the operand addressable. */
5168 ret
= gimplify_expr (&TREE_OPERAND (expr
, 0), pre_p
, post_p
,
5169 is_gimple_addressable
, fb_either
);
5170 if (ret
== GS_ERROR
)
5173 /* Then mark it. Beware that it may not be possible to do so directly
5174 if a temporary has been created by the gimplification. */
5175 prepare_gimple_addressable (&TREE_OPERAND (expr
, 0), pre_p
);
5177 op0
= TREE_OPERAND (expr
, 0);
5179 /* For various reasons, the gimplification of the expression
5180 may have made a new INDIRECT_REF. */
5181 if (TREE_CODE (op0
) == INDIRECT_REF
)
5182 goto do_indirect_ref
;
5184 mark_addressable (TREE_OPERAND (expr
, 0));
5186 /* The FEs may end up building ADDR_EXPRs early on a decl with
5187 an incomplete type. Re-build ADDR_EXPRs in canonical form
5189 if (!types_compatible_p (TREE_TYPE (op0
), TREE_TYPE (TREE_TYPE (expr
))))
5190 *expr_p
= build_fold_addr_expr (op0
);
5192 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
5193 recompute_tree_invariant_for_addr_expr (*expr_p
);
5195 /* If we re-built the ADDR_EXPR add a conversion to the original type
5197 if (!useless_type_conversion_p (TREE_TYPE (expr
), TREE_TYPE (*expr_p
)))
5198 *expr_p
= fold_convert (TREE_TYPE (expr
), *expr_p
);
5206 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
5207 value; output operands should be a gimple lvalue. */
5209 static enum gimplify_status
5210 gimplify_asm_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5214 const char **oconstraints
;
5217 const char *constraint
;
5218 bool allows_mem
, allows_reg
, is_inout
;
5219 enum gimplify_status ret
, tret
;
5221 vec
<tree
, va_gc
> *inputs
;
5222 vec
<tree
, va_gc
> *outputs
;
5223 vec
<tree
, va_gc
> *clobbers
;
5224 vec
<tree
, va_gc
> *labels
;
5228 noutputs
= list_length (ASM_OUTPUTS (expr
));
5229 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
5237 link_next
= NULL_TREE
;
5238 for (i
= 0, link
= ASM_OUTPUTS (expr
); link
; ++i
, link
= link_next
)
5241 size_t constraint_len
;
5243 link_next
= TREE_CHAIN (link
);
5247 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5248 constraint_len
= strlen (constraint
);
5249 if (constraint_len
== 0)
5252 ok
= parse_output_constraint (&constraint
, i
, 0, 0,
5253 &allows_mem
, &allows_reg
, &is_inout
);
5260 if (!allows_reg
&& allows_mem
)
5261 mark_addressable (TREE_VALUE (link
));
5263 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5264 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
5265 fb_lvalue
| fb_mayfail
);
5266 if (tret
== GS_ERROR
)
5268 error ("invalid lvalue in asm output %d", i
);
5272 vec_safe_push (outputs
, link
);
5273 TREE_CHAIN (link
) = NULL_TREE
;
5277 /* An input/output operand. To give the optimizers more
5278 flexibility, split it into separate input and output
5283 /* Turn the in/out constraint into an output constraint. */
5284 char *p
= xstrdup (constraint
);
5286 TREE_VALUE (TREE_PURPOSE (link
)) = build_string (constraint_len
, p
);
5288 /* And add a matching input constraint. */
5291 sprintf (buf
, "%d", i
);
5293 /* If there are multiple alternatives in the constraint,
5294 handle each of them individually. Those that allow register
5295 will be replaced with operand number, the others will stay
5297 if (strchr (p
, ',') != NULL
)
5299 size_t len
= 0, buflen
= strlen (buf
);
5300 char *beg
, *end
, *str
, *dst
;
5304 end
= strchr (beg
, ',');
5306 end
= strchr (beg
, '\0');
5307 if ((size_t) (end
- beg
) < buflen
)
5310 len
+= end
- beg
+ 1;
5317 str
= (char *) alloca (len
);
5318 for (beg
= p
+ 1, dst
= str
;;)
5321 bool mem_p
, reg_p
, inout_p
;
5323 end
= strchr (beg
, ',');
5328 parse_output_constraint (&tem
, i
, 0, 0,
5329 &mem_p
, ®_p
, &inout_p
);
5334 memcpy (dst
, buf
, buflen
);
5343 memcpy (dst
, beg
, len
);
5352 input
= build_string (dst
- str
, str
);
5355 input
= build_string (strlen (buf
), buf
);
5358 input
= build_string (constraint_len
- 1, constraint
+ 1);
5362 input
= build_tree_list (build_tree_list (NULL_TREE
, input
),
5363 unshare_expr (TREE_VALUE (link
)));
5364 ASM_INPUTS (expr
) = chainon (ASM_INPUTS (expr
), input
);
5368 link_next
= NULL_TREE
;
5369 for (link
= ASM_INPUTS (expr
); link
; ++i
, link
= link_next
)
5371 link_next
= TREE_CHAIN (link
);
5372 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
5373 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
5374 oconstraints
, &allows_mem
, &allows_reg
);
5376 /* If we can't make copies, we can only accept memory. */
5377 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link
))))
5383 error ("impossible constraint in %<asm%>");
5384 error ("non-memory input %d must stay in memory", i
);
5389 /* If the operand is a memory input, it should be an lvalue. */
5390 if (!allows_reg
&& allows_mem
)
5392 tree inputv
= TREE_VALUE (link
);
5393 STRIP_NOPS (inputv
);
5394 if (TREE_CODE (inputv
) == PREDECREMENT_EXPR
5395 || TREE_CODE (inputv
) == PREINCREMENT_EXPR
5396 || TREE_CODE (inputv
) == POSTDECREMENT_EXPR
5397 || TREE_CODE (inputv
) == POSTINCREMENT_EXPR
)
5398 TREE_VALUE (link
) = error_mark_node
;
5399 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5400 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
5401 mark_addressable (TREE_VALUE (link
));
5402 if (tret
== GS_ERROR
)
5404 if (EXPR_HAS_LOCATION (TREE_VALUE (link
)))
5405 input_location
= EXPR_LOCATION (TREE_VALUE (link
));
5406 error ("memory input %d is not directly addressable", i
);
5412 tret
= gimplify_expr (&TREE_VALUE (link
), pre_p
, post_p
,
5413 is_gimple_asm_val
, fb_rvalue
);
5414 if (tret
== GS_ERROR
)
5418 TREE_CHAIN (link
) = NULL_TREE
;
5419 vec_safe_push (inputs
, link
);
5422 link_next
= NULL_TREE
;
5423 for (link
= ASM_CLOBBERS (expr
); link
; ++i
, link
= link_next
)
5425 link_next
= TREE_CHAIN (link
);
5426 TREE_CHAIN (link
) = NULL_TREE
;
5427 vec_safe_push (clobbers
, link
);
5430 link_next
= NULL_TREE
;
5431 for (link
= ASM_LABELS (expr
); link
; ++i
, link
= link_next
)
5433 link_next
= TREE_CHAIN (link
);
5434 TREE_CHAIN (link
) = NULL_TREE
;
5435 vec_safe_push (labels
, link
);
5438 /* Do not add ASMs with errors to the gimple IL stream. */
5439 if (ret
!= GS_ERROR
)
5441 stmt
= gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr
)),
5442 inputs
, outputs
, clobbers
, labels
);
5444 gimple_asm_set_volatile (stmt
, ASM_VOLATILE_P (expr
));
5445 gimple_asm_set_input (stmt
, ASM_INPUT_P (expr
));
5447 gimplify_seq_add_stmt (pre_p
, stmt
);
5453 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
5454 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
5455 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
5456 return to this function.
5458 FIXME should we complexify the prequeue handling instead? Or use flags
5459 for all the cleanups and let the optimizer tighten them up? The current
5460 code seems pretty fragile; it will break on a cleanup within any
5461 non-conditional nesting. But any such nesting would be broken, anyway;
5462 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
5463 and continues out of it. We can do that at the RTL level, though, so
5464 having an optimizer to tighten up try/finally regions would be a Good
5467 static enum gimplify_status
5468 gimplify_cleanup_point_expr (tree
*expr_p
, gimple_seq
*pre_p
)
5470 gimple_stmt_iterator iter
;
5471 gimple_seq body_sequence
= NULL
;
5473 tree temp
= voidify_wrapper_expr (*expr_p
, NULL
);
5475 /* We only care about the number of conditions between the innermost
5476 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5477 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5478 int old_conds
= gimplify_ctxp
->conditions
;
5479 gimple_seq old_cleanups
= gimplify_ctxp
->conditional_cleanups
;
5480 bool old_in_cleanup_point_expr
= gimplify_ctxp
->in_cleanup_point_expr
;
5481 gimplify_ctxp
->conditions
= 0;
5482 gimplify_ctxp
->conditional_cleanups
= NULL
;
5483 gimplify_ctxp
->in_cleanup_point_expr
= true;
5485 gimplify_stmt (&TREE_OPERAND (*expr_p
, 0), &body_sequence
);
5487 gimplify_ctxp
->conditions
= old_conds
;
5488 gimplify_ctxp
->conditional_cleanups
= old_cleanups
;
5489 gimplify_ctxp
->in_cleanup_point_expr
= old_in_cleanup_point_expr
;
5491 for (iter
= gsi_start (body_sequence
); !gsi_end_p (iter
); )
5493 gimple wce
= gsi_stmt (iter
);
5495 if (gimple_code (wce
) == GIMPLE_WITH_CLEANUP_EXPR
)
5497 if (gsi_one_before_end_p (iter
))
5499 /* Note that gsi_insert_seq_before and gsi_remove do not
5500 scan operands, unlike some other sequence mutators. */
5501 if (!gimple_wce_cleanup_eh_only (wce
))
5502 gsi_insert_seq_before_without_update (&iter
,
5503 gimple_wce_cleanup (wce
),
5505 gsi_remove (&iter
, true);
5512 enum gimple_try_flags kind
;
5514 if (gimple_wce_cleanup_eh_only (wce
))
5515 kind
= GIMPLE_TRY_CATCH
;
5517 kind
= GIMPLE_TRY_FINALLY
;
5518 seq
= gsi_split_seq_after (iter
);
5520 gtry
= gimple_build_try (seq
, gimple_wce_cleanup (wce
), kind
);
5521 /* Do not use gsi_replace here, as it may scan operands.
5522 We want to do a simple structural modification only. */
5523 gsi_set_stmt (&iter
, gtry
);
5524 iter
= gsi_start (gtry
->gimple_try
.eval
);
5531 gimplify_seq_add_seq (pre_p
, body_sequence
);
5544 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5545 is the cleanup action required. EH_ONLY is true if the cleanup should
5546 only be executed if an exception is thrown, not on normal exit. */
5549 gimple_push_cleanup (tree var
, tree cleanup
, bool eh_only
, gimple_seq
*pre_p
)
5552 gimple_seq cleanup_stmts
= NULL
;
5554 /* Errors can result in improperly nested cleanups. Which results in
5555 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5559 if (gimple_conditional_context ())
5561 /* If we're in a conditional context, this is more complex. We only
5562 want to run the cleanup if we actually ran the initialization that
5563 necessitates it, but we want to run it after the end of the
5564 conditional context. So we wrap the try/finally around the
5565 condition and use a flag to determine whether or not to actually
5566 run the destructor. Thus
5570 becomes (approximately)
5574 if (test) { A::A(temp); flag = 1; val = f(temp); }
5577 if (flag) A::~A(temp);
5581 tree flag
= create_tmp_var (boolean_type_node
, "cleanup");
5582 gimple ffalse
= gimple_build_assign (flag
, boolean_false_node
);
5583 gimple ftrue
= gimple_build_assign (flag
, boolean_true_node
);
5585 cleanup
= build3 (COND_EXPR
, void_type_node
, flag
, cleanup
, NULL
);
5586 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5587 wce
= gimple_build_wce (cleanup_stmts
);
5589 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, ffalse
);
5590 gimplify_seq_add_stmt (&gimplify_ctxp
->conditional_cleanups
, wce
);
5591 gimplify_seq_add_stmt (pre_p
, ftrue
);
5593 /* Because of this manipulation, and the EH edges that jump
5594 threading cannot redirect, the temporary (VAR) will appear
5595 to be used uninitialized. Don't warn. */
5596 TREE_NO_WARNING (var
) = 1;
5600 gimplify_stmt (&cleanup
, &cleanup_stmts
);
5601 wce
= gimple_build_wce (cleanup_stmts
);
5602 gimple_wce_set_cleanup_eh_only (wce
, eh_only
);
5603 gimplify_seq_add_stmt (pre_p
, wce
);
5607 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5609 static enum gimplify_status
5610 gimplify_target_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
5612 tree targ
= *expr_p
;
5613 tree temp
= TARGET_EXPR_SLOT (targ
);
5614 tree init
= TARGET_EXPR_INITIAL (targ
);
5615 enum gimplify_status ret
;
5619 tree cleanup
= NULL_TREE
;
5621 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5622 to the temps list. Handle also variable length TARGET_EXPRs. */
5623 if (TREE_CODE (DECL_SIZE (temp
)) != INTEGER_CST
)
5625 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp
)))
5626 gimplify_type_sizes (TREE_TYPE (temp
), pre_p
);
5627 gimplify_vla_decl (temp
, pre_p
);
5630 gimple_add_tmp_var (temp
);
5632 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5633 expression is supposed to initialize the slot. */
5634 if (VOID_TYPE_P (TREE_TYPE (init
)))
5635 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5638 tree init_expr
= build2 (INIT_EXPR
, void_type_node
, temp
, init
);
5640 ret
= gimplify_expr (&init
, pre_p
, post_p
, is_gimple_stmt
, fb_none
);
5642 ggc_free (init_expr
);
5644 if (ret
== GS_ERROR
)
5646 /* PR c++/28266 Make sure this is expanded only once. */
5647 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5651 gimplify_and_add (init
, pre_p
);
5653 /* If needed, push the cleanup for the temp. */
5654 if (TARGET_EXPR_CLEANUP (targ
))
5656 if (CLEANUP_EH_ONLY (targ
))
5657 gimple_push_cleanup (temp
, TARGET_EXPR_CLEANUP (targ
),
5658 CLEANUP_EH_ONLY (targ
), pre_p
);
5660 cleanup
= TARGET_EXPR_CLEANUP (targ
);
5663 /* Add a clobber for the temporary going out of scope, like
5664 gimplify_bind_expr. */
5665 if (gimplify_ctxp
->in_cleanup_point_expr
5666 && needs_to_live_in_memory (temp
)
5667 && flag_stack_reuse
== SR_ALL
)
5669 tree clobber
= build_constructor (TREE_TYPE (temp
),
5671 TREE_THIS_VOLATILE (clobber
) = true;
5672 clobber
= build2 (MODIFY_EXPR
, TREE_TYPE (temp
), temp
, clobber
);
5674 cleanup
= build2 (COMPOUND_EXPR
, void_type_node
, cleanup
,
5681 gimple_push_cleanup (temp
, cleanup
, false, pre_p
);
5683 /* Only expand this once. */
5684 TREE_OPERAND (targ
, 3) = init
;
5685 TARGET_EXPR_INITIAL (targ
) = NULL_TREE
;
5688 /* We should have expanded this before. */
5689 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp
));
5695 /* Gimplification of expression trees. */
5697 /* Gimplify an expression which appears at statement context. The
5698 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5699 NULL, a new sequence is allocated.
5701 Return true if we actually added a statement to the queue. */
5704 gimplify_stmt (tree
*stmt_p
, gimple_seq
*seq_p
)
5706 gimple_seq_node last
;
5708 last
= gimple_seq_last (*seq_p
);
5709 gimplify_expr (stmt_p
, seq_p
, NULL
, is_gimple_stmt
, fb_none
);
5710 return last
!= gimple_seq_last (*seq_p
);
5713 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5714 to CTX. If entries already exist, force them to be some flavor of private.
5715 If there is no enclosing parallel, do nothing. */
5718 omp_firstprivatize_variable (struct gimplify_omp_ctx
*ctx
, tree decl
)
5722 if (decl
== NULL
|| !DECL_P (decl
))
5727 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5730 if (n
->value
& GOVD_SHARED
)
5731 n
->value
= GOVD_FIRSTPRIVATE
| (n
->value
& GOVD_SEEN
);
5735 else if (ctx
->region_type
!= ORT_WORKSHARE
5736 && ctx
->region_type
!= ORT_SIMD
)
5737 omp_add_variable (ctx
, decl
, GOVD_FIRSTPRIVATE
);
5739 ctx
= ctx
->outer_context
;
5744 /* Similarly for each of the type sizes of TYPE. */
5747 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx
*ctx
, tree type
)
5749 if (type
== NULL
|| type
== error_mark_node
)
5751 type
= TYPE_MAIN_VARIANT (type
);
5753 if (pointer_set_insert (ctx
->privatized_types
, type
))
5756 switch (TREE_CODE (type
))
5762 case FIXED_POINT_TYPE
:
5763 omp_firstprivatize_variable (ctx
, TYPE_MIN_VALUE (type
));
5764 omp_firstprivatize_variable (ctx
, TYPE_MAX_VALUE (type
));
5768 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5769 omp_firstprivatize_type_sizes (ctx
, TYPE_DOMAIN (type
));
5774 case QUAL_UNION_TYPE
:
5777 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
5778 if (TREE_CODE (field
) == FIELD_DECL
)
5780 omp_firstprivatize_variable (ctx
, DECL_FIELD_OFFSET (field
));
5781 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (field
));
5787 case REFERENCE_TYPE
:
5788 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (type
));
5795 omp_firstprivatize_variable (ctx
, TYPE_SIZE (type
));
5796 omp_firstprivatize_variable (ctx
, TYPE_SIZE_UNIT (type
));
5797 lang_hooks
.types
.omp_firstprivatize_type_sizes (ctx
, type
);
5800 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
5803 omp_add_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, unsigned int flags
)
5806 unsigned int nflags
;
5809 if (error_operand_p (decl
))
5812 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5813 there are constructors involved somewhere. */
5814 if (TREE_ADDRESSABLE (TREE_TYPE (decl
))
5815 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
5818 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5821 /* We shouldn't be re-adding the decl with the same data
5823 gcc_assert ((n
->value
& GOVD_DATA_SHARE_CLASS
& flags
) == 0);
5824 /* The only combination of data sharing classes we should see is
5825 FIRSTPRIVATE and LASTPRIVATE. */
5826 nflags
= n
->value
| flags
;
5827 gcc_assert ((nflags
& GOVD_DATA_SHARE_CLASS
)
5828 == (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
)
5829 || (flags
& GOVD_DATA_SHARE_CLASS
) == 0);
5834 /* When adding a variable-sized variable, we have to handle all sorts
5835 of additional bits of data: the pointer replacement variable, and
5836 the parameters of the type. */
5837 if (DECL_SIZE (decl
) && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
5839 /* Add the pointer replacement variable as PRIVATE if the variable
5840 replacement is private, else FIRSTPRIVATE since we'll need the
5841 address of the original variable either for SHARED, or for the
5842 copy into or out of the context. */
5843 if (!(flags
& GOVD_LOCAL
))
5845 nflags
= flags
& GOVD_PRIVATE
? GOVD_PRIVATE
: GOVD_FIRSTPRIVATE
;
5846 nflags
|= flags
& GOVD_SEEN
;
5847 t
= DECL_VALUE_EXPR (decl
);
5848 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
5849 t
= TREE_OPERAND (t
, 0);
5850 gcc_assert (DECL_P (t
));
5851 omp_add_variable (ctx
, t
, nflags
);
5854 /* Add all of the variable and type parameters (which should have
5855 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5856 omp_firstprivatize_variable (ctx
, DECL_SIZE_UNIT (decl
));
5857 omp_firstprivatize_variable (ctx
, DECL_SIZE (decl
));
5858 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5860 /* The variable-sized variable itself is never SHARED, only some form
5861 of PRIVATE. The sharing would take place via the pointer variable
5862 which we remapped above. */
5863 if (flags
& GOVD_SHARED
)
5864 flags
= GOVD_PRIVATE
| GOVD_DEBUG_PRIVATE
5865 | (flags
& (GOVD_SEEN
| GOVD_EXPLICIT
));
5867 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5868 alloca statement we generate for the variable, so make sure it
5869 is available. This isn't automatically needed for the SHARED
5870 case, since we won't be allocating local storage then.
5871 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5872 in this case omp_notice_variable will be called later
5873 on when it is gimplified. */
5874 else if (! (flags
& GOVD_LOCAL
)
5875 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl
))))
5876 omp_notice_variable (ctx
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)), true);
5878 else if (lang_hooks
.decls
.omp_privatize_by_reference (decl
))
5880 gcc_assert ((flags
& GOVD_LOCAL
) == 0);
5881 omp_firstprivatize_type_sizes (ctx
, TREE_TYPE (decl
));
5883 /* Similar to the direct variable sized case above, we'll need the
5884 size of references being privatized. */
5885 if ((flags
& GOVD_SHARED
) == 0)
5887 t
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl
)));
5888 if (TREE_CODE (t
) != INTEGER_CST
)
5889 omp_notice_variable (ctx
, t
, true);
5896 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, flags
);
5899 /* Notice a threadprivate variable DECL used in OpenMP context CTX.
5900 This just prints out diagnostics about threadprivate variable uses
5901 in untied tasks. If DECL2 is non-NULL, prevent this warning
5902 on that variable. */
5905 omp_notice_threadprivate_variable (struct gimplify_omp_ctx
*ctx
, tree decl
,
5910 if (ctx
->region_type
!= ORT_UNTIED_TASK
)
5912 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5915 error ("threadprivate variable %qE used in untied task",
5917 error_at (ctx
->location
, "enclosing task");
5918 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl
, 0);
5921 splay_tree_insert (ctx
->variables
, (splay_tree_key
)decl2
, 0);
5925 /* Record the fact that DECL was used within the OpenMP context CTX.
5926 IN_CODE is true when real code uses DECL, and false when we should
5927 merely emit default(none) errors. Return true if DECL is going to
5928 be remapped and thus DECL shouldn't be gimplified into its
5929 DECL_VALUE_EXPR (if any). */
5932 omp_notice_variable (struct gimplify_omp_ctx
*ctx
, tree decl
, bool in_code
)
5935 unsigned flags
= in_code
? GOVD_SEEN
: 0;
5936 bool ret
= false, shared
;
5938 if (error_operand_p (decl
))
5941 /* Threadprivate variables are predetermined. */
5942 if (is_global_var (decl
))
5944 if (DECL_THREAD_LOCAL_P (decl
))
5945 return omp_notice_threadprivate_variable (ctx
, decl
, NULL_TREE
);
5947 if (DECL_HAS_VALUE_EXPR_P (decl
))
5949 tree value
= get_base_address (DECL_VALUE_EXPR (decl
));
5951 if (value
&& DECL_P (value
) && DECL_THREAD_LOCAL_P (value
))
5952 return omp_notice_threadprivate_variable (ctx
, decl
, value
);
5956 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
5959 enum omp_clause_default_kind default_kind
, kind
;
5960 struct gimplify_omp_ctx
*octx
;
5962 if (ctx
->region_type
== ORT_WORKSHARE
5963 || ctx
->region_type
== ORT_SIMD
)
5966 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
5967 remapped firstprivate instead of shared. To some extent this is
5968 addressed in omp_firstprivatize_type_sizes, but not effectively. */
5969 default_kind
= ctx
->default_kind
;
5970 kind
= lang_hooks
.decls
.omp_predetermined_sharing (decl
);
5971 if (kind
!= OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
5972 default_kind
= kind
;
5974 switch (default_kind
)
5976 case OMP_CLAUSE_DEFAULT_NONE
:
5977 error ("%qE not specified in enclosing parallel",
5978 DECL_NAME (lang_hooks
.decls
.omp_report_decl (decl
)));
5979 if ((ctx
->region_type
& ORT_TASK
) != 0)
5980 error_at (ctx
->location
, "enclosing task");
5982 error_at (ctx
->location
, "enclosing parallel");
5984 case OMP_CLAUSE_DEFAULT_SHARED
:
5985 flags
|= GOVD_SHARED
;
5987 case OMP_CLAUSE_DEFAULT_PRIVATE
:
5988 flags
|= GOVD_PRIVATE
;
5990 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE
:
5991 flags
|= GOVD_FIRSTPRIVATE
;
5993 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
5994 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
5995 gcc_assert ((ctx
->region_type
& ORT_TASK
) != 0);
5996 if (ctx
->outer_context
)
5997 omp_notice_variable (ctx
->outer_context
, decl
, in_code
);
5998 for (octx
= ctx
->outer_context
; octx
; octx
= octx
->outer_context
)
6002 n2
= splay_tree_lookup (octx
->variables
, (splay_tree_key
) decl
);
6003 if (n2
&& (n2
->value
& GOVD_DATA_SHARE_CLASS
) != GOVD_SHARED
)
6005 flags
|= GOVD_FIRSTPRIVATE
;
6008 if ((octx
->region_type
& ORT_PARALLEL
) != 0)
6011 if (flags
& GOVD_FIRSTPRIVATE
)
6014 && (TREE_CODE (decl
) == PARM_DECL
6015 || (!is_global_var (decl
)
6016 && DECL_CONTEXT (decl
) == current_function_decl
)))
6018 flags
|= GOVD_FIRSTPRIVATE
;
6021 flags
|= GOVD_SHARED
;
6027 if ((flags
& GOVD_PRIVATE
)
6028 && lang_hooks
.decls
.omp_private_outer_ref (decl
))
6029 flags
|= GOVD_PRIVATE_OUTER_REF
;
6031 omp_add_variable (ctx
, decl
, flags
);
6033 shared
= (flags
& GOVD_SHARED
) != 0;
6034 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
6038 if ((n
->value
& (GOVD_SEEN
| GOVD_LOCAL
)) == 0
6039 && (flags
& (GOVD_SEEN
| GOVD_LOCAL
)) == GOVD_SEEN
6041 && TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
6044 tree t
= DECL_VALUE_EXPR (decl
);
6045 gcc_assert (TREE_CODE (t
) == INDIRECT_REF
);
6046 t
= TREE_OPERAND (t
, 0);
6047 gcc_assert (DECL_P (t
));
6048 n2
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) t
);
6049 n2
->value
|= GOVD_SEEN
;
6052 shared
= ((flags
| n
->value
) & GOVD_SHARED
) != 0;
6053 ret
= lang_hooks
.decls
.omp_disregard_value_expr (decl
, shared
);
6055 /* If nothing changed, there's nothing left to do. */
6056 if ((n
->value
& flags
) == flags
)
6062 /* If the variable is private in the current context, then we don't
6063 need to propagate anything to an outer context. */
6064 if ((flags
& GOVD_PRIVATE
) && !(flags
& GOVD_PRIVATE_OUTER_REF
))
6066 if (ctx
->outer_context
6067 && omp_notice_variable (ctx
->outer_context
, decl
, in_code
))
6072 /* Verify that DECL is private within CTX. If there's specific information
6073 to the contrary in the innermost scope, generate an error. */
6076 omp_is_private (struct gimplify_omp_ctx
*ctx
, tree decl
, bool simd
)
6080 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
)decl
);
6083 if (n
->value
& GOVD_SHARED
)
6085 if (ctx
== gimplify_omp_ctxp
)
6088 error ("iteration variable %qE is predetermined linear",
6091 error ("iteration variable %qE should be private",
6093 n
->value
= GOVD_PRIVATE
;
6099 else if ((n
->value
& GOVD_EXPLICIT
) != 0
6100 && (ctx
== gimplify_omp_ctxp
6101 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6102 && gimplify_omp_ctxp
->outer_context
== ctx
)))
6104 if ((n
->value
& GOVD_FIRSTPRIVATE
) != 0)
6105 error ("iteration variable %qE should not be firstprivate",
6107 else if ((n
->value
& GOVD_REDUCTION
) != 0)
6108 error ("iteration variable %qE should not be reduction",
6110 else if (simd
&& (n
->value
& GOVD_LASTPRIVATE
) != 0)
6111 error ("iteration variable %qE should not be lastprivate",
6113 else if (simd
&& (n
->value
& GOVD_PRIVATE
) != 0)
6114 error ("iteration variable %qE should not be private",
6116 else if (simd
&& (n
->value
& GOVD_LINEAR
) != 0)
6117 error ("iteration variable %qE is predetermined linear",
6120 return (ctx
== gimplify_omp_ctxp
6121 || (ctx
->region_type
== ORT_COMBINED_PARALLEL
6122 && gimplify_omp_ctxp
->outer_context
== ctx
));
6125 if (ctx
->region_type
!= ORT_WORKSHARE
6126 && ctx
->region_type
!= ORT_SIMD
)
6128 else if (ctx
->outer_context
)
6129 return omp_is_private (ctx
->outer_context
, decl
, simd
);
6133 /* Return true if DECL is private within a parallel region
6134 that binds to the current construct's context or in parallel
6135 region's REDUCTION clause. */
6138 omp_check_private (struct gimplify_omp_ctx
*ctx
, tree decl
)
6144 ctx
= ctx
->outer_context
;
6146 return !(is_global_var (decl
)
6147 /* References might be private, but might be shared too. */
6148 || lang_hooks
.decls
.omp_privatize_by_reference (decl
));
6150 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6152 return (n
->value
& GOVD_SHARED
) == 0;
6154 while (ctx
->region_type
== ORT_WORKSHARE
6155 || ctx
->region_type
== ORT_SIMD
);
6159 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
6160 and previous omp contexts. */
6163 gimplify_scan_omp_clauses (tree
*list_p
, gimple_seq
*pre_p
,
6164 enum omp_region_type region_type
)
6166 struct gimplify_omp_ctx
*ctx
, *outer_ctx
;
6167 struct gimplify_ctx gctx
;
6170 ctx
= new_omp_context (region_type
);
6171 outer_ctx
= ctx
->outer_context
;
6173 while ((c
= *list_p
) != NULL
)
6175 bool remove
= false;
6176 bool notice_outer
= true;
6177 const char *check_non_private
= NULL
;
6181 switch (OMP_CLAUSE_CODE (c
))
6183 case OMP_CLAUSE_PRIVATE
:
6184 flags
= GOVD_PRIVATE
| GOVD_EXPLICIT
;
6185 if (lang_hooks
.decls
.omp_private_outer_ref (OMP_CLAUSE_DECL (c
)))
6187 flags
|= GOVD_PRIVATE_OUTER_REF
;
6188 OMP_CLAUSE_PRIVATE_OUTER_REF (c
) = 1;
6191 notice_outer
= false;
6193 case OMP_CLAUSE_SHARED
:
6194 flags
= GOVD_SHARED
| GOVD_EXPLICIT
;
6196 case OMP_CLAUSE_FIRSTPRIVATE
:
6197 flags
= GOVD_FIRSTPRIVATE
| GOVD_EXPLICIT
;
6198 check_non_private
= "firstprivate";
6200 case OMP_CLAUSE_LASTPRIVATE
:
6201 flags
= GOVD_LASTPRIVATE
| GOVD_SEEN
| GOVD_EXPLICIT
;
6202 check_non_private
= "lastprivate";
6204 case OMP_CLAUSE_REDUCTION
:
6205 flags
= GOVD_REDUCTION
| GOVD_SEEN
| GOVD_EXPLICIT
;
6206 check_non_private
= "reduction";
6208 case OMP_CLAUSE_LINEAR
:
6209 if (gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
), pre_p
, NULL
,
6210 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6215 flags
= GOVD_LINEAR
| GOVD_EXPLICIT
;
6219 decl
= OMP_CLAUSE_DECL (c
);
6220 if (error_operand_p (decl
))
6225 omp_add_variable (ctx
, decl
, flags
);
6226 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
6227 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
6229 omp_add_variable (ctx
, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
),
6230 GOVD_LOCAL
| GOVD_SEEN
);
6231 gimplify_omp_ctxp
= ctx
;
6232 push_gimplify_context (&gctx
);
6234 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
) = NULL
;
6235 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
) = NULL
;
6237 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c
),
6238 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
));
6239 pop_gimplify_context
6240 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c
)));
6241 push_gimplify_context (&gctx
);
6242 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c
),
6243 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
));
6244 pop_gimplify_context
6245 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c
)));
6246 OMP_CLAUSE_REDUCTION_INIT (c
) = NULL_TREE
;
6247 OMP_CLAUSE_REDUCTION_MERGE (c
) = NULL_TREE
;
6249 gimplify_omp_ctxp
= outer_ctx
;
6251 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6252 && OMP_CLAUSE_LASTPRIVATE_STMT (c
))
6254 gimplify_omp_ctxp
= ctx
;
6255 push_gimplify_context (&gctx
);
6256 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c
)) != BIND_EXPR
)
6258 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
,
6260 TREE_SIDE_EFFECTS (bind
) = 1;
6261 BIND_EXPR_BODY (bind
) = OMP_CLAUSE_LASTPRIVATE_STMT (c
);
6262 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = bind
;
6264 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c
),
6265 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6266 pop_gimplify_context
6267 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
)));
6268 OMP_CLAUSE_LASTPRIVATE_STMT (c
) = NULL_TREE
;
6270 gimplify_omp_ctxp
= outer_ctx
;
6276 case OMP_CLAUSE_COPYIN
:
6277 case OMP_CLAUSE_COPYPRIVATE
:
6278 decl
= OMP_CLAUSE_DECL (c
);
6279 if (error_operand_p (decl
))
6286 omp_notice_variable (outer_ctx
, decl
, true);
6287 if (check_non_private
6288 && region_type
== ORT_WORKSHARE
6289 && omp_check_private (ctx
, decl
))
6291 error ("%s variable %qE is private in outer context",
6292 check_non_private
, DECL_NAME (decl
));
6297 case OMP_CLAUSE_FINAL
:
6299 OMP_CLAUSE_OPERAND (c
, 0)
6300 = gimple_boolify (OMP_CLAUSE_OPERAND (c
, 0));
6303 case OMP_CLAUSE_SCHEDULE
:
6304 case OMP_CLAUSE_NUM_THREADS
:
6305 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c
, 0), pre_p
, NULL
,
6306 is_gimple_val
, fb_rvalue
) == GS_ERROR
)
6310 case OMP_CLAUSE_NOWAIT
:
6311 case OMP_CLAUSE_ORDERED
:
6312 case OMP_CLAUSE_UNTIED
:
6313 case OMP_CLAUSE_COLLAPSE
:
6314 case OMP_CLAUSE_MERGEABLE
:
6315 case OMP_CLAUSE_SAFELEN
:
6318 case OMP_CLAUSE_DEFAULT
:
6319 ctx
->default_kind
= OMP_CLAUSE_DEFAULT_KIND (c
);
6327 *list_p
= OMP_CLAUSE_CHAIN (c
);
6329 list_p
= &OMP_CLAUSE_CHAIN (c
);
6332 gimplify_omp_ctxp
= ctx
;
6335 /* For all variables that were not actually used within the context,
6336 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
6339 gimplify_adjust_omp_clauses_1 (splay_tree_node n
, void *data
)
6341 tree
*list_p
= (tree
*) data
;
6342 tree decl
= (tree
) n
->key
;
6343 unsigned flags
= n
->value
;
6344 enum omp_clause_code code
;
6348 if (flags
& (GOVD_EXPLICIT
| GOVD_LOCAL
))
6350 if ((flags
& GOVD_SEEN
) == 0)
6352 if (flags
& GOVD_DEBUG_PRIVATE
)
6354 gcc_assert ((flags
& GOVD_DATA_SHARE_CLASS
) == GOVD_PRIVATE
);
6355 private_debug
= true;
6359 = lang_hooks
.decls
.omp_private_debug_clause (decl
,
6360 !!(flags
& GOVD_SHARED
));
6362 code
= OMP_CLAUSE_PRIVATE
;
6363 else if (flags
& GOVD_SHARED
)
6365 if (is_global_var (decl
))
6367 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
->outer_context
;
6371 = splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6372 if (on
&& (on
->value
& (GOVD_FIRSTPRIVATE
| GOVD_LASTPRIVATE
6373 | GOVD_PRIVATE
| GOVD_REDUCTION
6374 | GOVD_LINEAR
)) != 0)
6376 ctx
= ctx
->outer_context
;
6381 code
= OMP_CLAUSE_SHARED
;
6383 else if (flags
& GOVD_PRIVATE
)
6384 code
= OMP_CLAUSE_PRIVATE
;
6385 else if (flags
& GOVD_FIRSTPRIVATE
)
6386 code
= OMP_CLAUSE_FIRSTPRIVATE
;
6387 else if (flags
& GOVD_LASTPRIVATE
)
6388 code
= OMP_CLAUSE_LASTPRIVATE
;
6392 clause
= build_omp_clause (input_location
, code
);
6393 OMP_CLAUSE_DECL (clause
) = decl
;
6394 OMP_CLAUSE_CHAIN (clause
) = *list_p
;
6396 OMP_CLAUSE_PRIVATE_DEBUG (clause
) = 1;
6397 else if (code
== OMP_CLAUSE_PRIVATE
&& (flags
& GOVD_PRIVATE_OUTER_REF
))
6398 OMP_CLAUSE_PRIVATE_OUTER_REF (clause
) = 1;
6400 lang_hooks
.decls
.omp_finish_clause (clause
);
6406 gimplify_adjust_omp_clauses (tree
*list_p
)
6408 struct gimplify_omp_ctx
*ctx
= gimplify_omp_ctxp
;
6411 while ((c
= *list_p
) != NULL
)
6414 bool remove
= false;
6416 switch (OMP_CLAUSE_CODE (c
))
6418 case OMP_CLAUSE_PRIVATE
:
6419 case OMP_CLAUSE_SHARED
:
6420 case OMP_CLAUSE_FIRSTPRIVATE
:
6421 case OMP_CLAUSE_LINEAR
:
6422 decl
= OMP_CLAUSE_DECL (c
);
6423 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6424 remove
= !(n
->value
& GOVD_SEEN
);
6427 bool shared
= OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
;
6428 if ((n
->value
& GOVD_DEBUG_PRIVATE
)
6429 || lang_hooks
.decls
.omp_private_debug_clause (decl
, shared
))
6431 gcc_assert ((n
->value
& GOVD_DEBUG_PRIVATE
) == 0
6432 || ((n
->value
& GOVD_DATA_SHARE_CLASS
)
6434 OMP_CLAUSE_SET_CODE (c
, OMP_CLAUSE_PRIVATE
);
6435 OMP_CLAUSE_PRIVATE_DEBUG (c
) = 1;
6437 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
6438 && ctx
->outer_context
6439 && !(OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
6440 && OMP_CLAUSE_LINEAR_NO_COPYOUT (c
))
6441 && !is_global_var (decl
))
6443 if (ctx
->outer_context
->region_type
== ORT_COMBINED_PARALLEL
)
6445 n
= splay_tree_lookup (ctx
->outer_context
->variables
,
6446 (splay_tree_key
) decl
);
6448 || (n
->value
& GOVD_DATA_SHARE_CLASS
) == 0)
6450 int flags
= OMP_CLAUSE_LINEAR_NO_COPYIN (c
)
6451 ? GOVD_LASTPRIVATE
: GOVD_SHARED
;
6453 omp_add_variable (ctx
->outer_context
, decl
,
6456 n
->value
|= flags
| GOVD_SEEN
;
6460 omp_notice_variable (ctx
->outer_context
, decl
, true);
6465 case OMP_CLAUSE_LASTPRIVATE
:
6466 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
6467 accurately reflect the presence of a FIRSTPRIVATE clause. */
6468 decl
= OMP_CLAUSE_DECL (c
);
6469 n
= splay_tree_lookup (ctx
->variables
, (splay_tree_key
) decl
);
6470 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c
)
6471 = (n
->value
& GOVD_FIRSTPRIVATE
) != 0;
6474 case OMP_CLAUSE_REDUCTION
:
6475 case OMP_CLAUSE_COPYIN
:
6476 case OMP_CLAUSE_COPYPRIVATE
:
6478 case OMP_CLAUSE_NUM_THREADS
:
6479 case OMP_CLAUSE_SCHEDULE
:
6480 case OMP_CLAUSE_NOWAIT
:
6481 case OMP_CLAUSE_ORDERED
:
6482 case OMP_CLAUSE_DEFAULT
:
6483 case OMP_CLAUSE_UNTIED
:
6484 case OMP_CLAUSE_COLLAPSE
:
6485 case OMP_CLAUSE_FINAL
:
6486 case OMP_CLAUSE_MERGEABLE
:
6487 case OMP_CLAUSE_SAFELEN
:
6495 *list_p
= OMP_CLAUSE_CHAIN (c
);
6497 list_p
= &OMP_CLAUSE_CHAIN (c
);
6500 /* Add in any implicit data sharing. */
6501 splay_tree_foreach (ctx
->variables
, gimplify_adjust_omp_clauses_1
, list_p
);
6503 gimplify_omp_ctxp
= ctx
->outer_context
;
6504 delete_omp_context (ctx
);
6507 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
6508 gimplification of the body, as well as scanning the body for used
6509 variables. We need to do this scan now, because variable-sized
6510 decls will be decomposed during gimplification. */
6513 gimplify_omp_parallel (tree
*expr_p
, gimple_seq
*pre_p
)
6515 tree expr
= *expr_p
;
6517 gimple_seq body
= NULL
;
6518 struct gimplify_ctx gctx
;
6520 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
), pre_p
,
6521 OMP_PARALLEL_COMBINED (expr
)
6522 ? ORT_COMBINED_PARALLEL
6525 push_gimplify_context (&gctx
);
6527 g
= gimplify_and_return_first (OMP_PARALLEL_BODY (expr
), &body
);
6528 if (gimple_code (g
) == GIMPLE_BIND
)
6529 pop_gimplify_context (g
);
6531 pop_gimplify_context (NULL
);
6533 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr
));
6535 g
= gimple_build_omp_parallel (body
,
6536 OMP_PARALLEL_CLAUSES (expr
),
6537 NULL_TREE
, NULL_TREE
);
6538 if (OMP_PARALLEL_COMBINED (expr
))
6539 gimple_omp_set_subcode (g
, GF_OMP_PARALLEL_COMBINED
);
6540 gimplify_seq_add_stmt (pre_p
, g
);
6541 *expr_p
= NULL_TREE
;
6544 /* Gimplify the contents of an OMP_TASK statement. This involves
6545 gimplification of the body, as well as scanning the body for used
6546 variables. We need to do this scan now, because variable-sized
6547 decls will be decomposed during gimplification. */
6550 gimplify_omp_task (tree
*expr_p
, gimple_seq
*pre_p
)
6552 tree expr
= *expr_p
;
6554 gimple_seq body
= NULL
;
6555 struct gimplify_ctx gctx
;
6557 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr
), pre_p
,
6558 find_omp_clause (OMP_TASK_CLAUSES (expr
),
6560 ? ORT_UNTIED_TASK
: ORT_TASK
);
6562 push_gimplify_context (&gctx
);
6564 g
= gimplify_and_return_first (OMP_TASK_BODY (expr
), &body
);
6565 if (gimple_code (g
) == GIMPLE_BIND
)
6566 pop_gimplify_context (g
);
6568 pop_gimplify_context (NULL
);
6570 gimplify_adjust_omp_clauses (&OMP_TASK_CLAUSES (expr
));
6572 g
= gimple_build_omp_task (body
,
6573 OMP_TASK_CLAUSES (expr
),
6574 NULL_TREE
, NULL_TREE
,
6575 NULL_TREE
, NULL_TREE
, NULL_TREE
);
6576 gimplify_seq_add_stmt (pre_p
, g
);
6577 *expr_p
= NULL_TREE
;
6580 /* Gimplify the gross structure of an OMP_FOR statement. */
6582 static enum gimplify_status
6583 gimplify_omp_for (tree
*expr_p
, gimple_seq
*pre_p
)
6585 tree for_stmt
, decl
, var
, t
;
6586 enum gimplify_status ret
= GS_ALL_DONE
;
6587 enum gimplify_status tret
;
6589 gimple_seq for_body
, for_pre_body
;
6592 bitmap has_decl_expr
= NULL
;
6596 simd
= TREE_CODE (for_stmt
) == OMP_SIMD
;
6597 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
), pre_p
,
6598 simd
? ORT_SIMD
: ORT_WORKSHARE
);
6600 /* Handle OMP_FOR_INIT. */
6601 for_pre_body
= NULL
;
6602 if (simd
&& OMP_FOR_PRE_BODY (for_stmt
))
6604 has_decl_expr
= BITMAP_ALLOC (NULL
);
6605 if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == DECL_EXPR
6606 && TREE_CODE (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt
)))
6609 t
= OMP_FOR_PRE_BODY (for_stmt
);
6610 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
6612 else if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt
)) == STATEMENT_LIST
)
6614 tree_stmt_iterator si
;
6615 for (si
= tsi_start (OMP_FOR_PRE_BODY (for_stmt
)); !tsi_end_p (si
);
6619 if (TREE_CODE (t
) == DECL_EXPR
6620 && TREE_CODE (DECL_EXPR_DECL (t
)) == VAR_DECL
)
6621 bitmap_set_bit (has_decl_expr
, DECL_UID (DECL_EXPR_DECL (t
)));
6625 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt
), &for_pre_body
);
6626 OMP_FOR_PRE_BODY (for_stmt
) = NULL_TREE
;
6629 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6630 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt
)));
6631 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
))
6632 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt
)));
6633 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6635 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6636 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6637 decl
= TREE_OPERAND (t
, 0);
6638 gcc_assert (DECL_P (decl
));
6639 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl
))
6640 || POINTER_TYPE_P (TREE_TYPE (decl
)));
6642 /* Make sure the iteration variable is private. */
6646 splay_tree_node n
= splay_tree_lookup (gimplify_omp_ctxp
->variables
,
6647 (splay_tree_key
)decl
);
6648 omp_is_private (gimplify_omp_ctxp
, decl
, simd
);
6649 if (n
!= NULL
&& (n
->value
& GOVD_DATA_SHARE_CLASS
) != 0)
6650 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
6651 else if (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) == 1)
6653 c
= build_omp_clause (input_location
, OMP_CLAUSE_LINEAR
);
6654 OMP_CLAUSE_LINEAR_NO_COPYIN (c
) = 1;
6656 && bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)))
6657 OMP_CLAUSE_LINEAR_NO_COPYOUT (c
) = 1;
6658 OMP_CLAUSE_DECL (c
) = decl
;
6659 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
6660 OMP_FOR_CLAUSES (for_stmt
) = c
;
6661 omp_add_variable (gimplify_omp_ctxp
, decl
,
6662 GOVD_LINEAR
| GOVD_EXPLICIT
| GOVD_SEEN
);
6668 || !bitmap_bit_p (has_decl_expr
, DECL_UID (decl
)));
6669 c
= build_omp_clause (input_location
,
6670 lastprivate
? OMP_CLAUSE_LASTPRIVATE
6671 : OMP_CLAUSE_PRIVATE
);
6672 OMP_CLAUSE_DECL (c
) = decl
;
6673 OMP_CLAUSE_CHAIN (c
) = OMP_FOR_CLAUSES (for_stmt
);
6674 omp_add_variable (gimplify_omp_ctxp
, decl
,
6675 (lastprivate
? GOVD_LASTPRIVATE
: GOVD_PRIVATE
)
6680 else if (omp_is_private (gimplify_omp_ctxp
, decl
, simd
))
6681 omp_notice_variable (gimplify_omp_ctxp
, decl
, true);
6683 omp_add_variable (gimplify_omp_ctxp
, decl
, GOVD_PRIVATE
| GOVD_SEEN
);
6685 /* If DECL is not a gimple register, create a temporary variable to act
6686 as an iteration counter. This is valid, since DECL cannot be
6687 modified in the body of the loop. */
6688 if (!is_gimple_reg (decl
))
6690 var
= create_tmp_var (TREE_TYPE (decl
), get_name (decl
));
6691 TREE_OPERAND (t
, 0) = var
;
6693 gimplify_seq_add_stmt (&for_body
, gimple_build_assign (decl
, var
));
6695 omp_add_variable (gimplify_omp_ctxp
, var
, GOVD_PRIVATE
| GOVD_SEEN
);
6700 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6701 is_gimple_val
, fb_rvalue
);
6702 ret
= MIN (ret
, tret
);
6703 if (ret
== GS_ERROR
)
6706 /* Handle OMP_FOR_COND. */
6707 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
6708 gcc_assert (COMPARISON_CLASS_P (t
));
6709 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6711 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6712 is_gimple_val
, fb_rvalue
);
6713 ret
= MIN (ret
, tret
);
6715 /* Handle OMP_FOR_INCR. */
6716 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6717 switch (TREE_CODE (t
))
6719 case PREINCREMENT_EXPR
:
6720 case POSTINCREMENT_EXPR
:
6721 t
= build_int_cst (TREE_TYPE (decl
), 1);
6723 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
6724 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6725 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6726 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6729 case PREDECREMENT_EXPR
:
6730 case POSTDECREMENT_EXPR
:
6731 t
= build_int_cst (TREE_TYPE (decl
), -1);
6733 OMP_CLAUSE_LINEAR_STEP (c
) = t
;
6734 t
= build2 (PLUS_EXPR
, TREE_TYPE (decl
), var
, t
);
6735 t
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, t
);
6736 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
) = t
;
6740 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6741 TREE_OPERAND (t
, 0) = var
;
6743 t
= TREE_OPERAND (t
, 1);
6744 switch (TREE_CODE (t
))
6747 if (TREE_OPERAND (t
, 1) == decl
)
6749 TREE_OPERAND (t
, 1) = TREE_OPERAND (t
, 0);
6750 TREE_OPERAND (t
, 0) = var
;
6756 case POINTER_PLUS_EXPR
:
6757 gcc_assert (TREE_OPERAND (t
, 0) == decl
);
6758 TREE_OPERAND (t
, 0) = var
;
6764 tret
= gimplify_expr (&TREE_OPERAND (t
, 1), &for_pre_body
, NULL
,
6765 is_gimple_val
, fb_rvalue
);
6766 ret
= MIN (ret
, tret
);
6769 OMP_CLAUSE_LINEAR_STEP (c
) = TREE_OPERAND (t
, 1);
6770 if (TREE_CODE (t
) == MINUS_EXPR
)
6772 t
= TREE_OPERAND (t
, 1);
6773 OMP_CLAUSE_LINEAR_STEP (c
)
6774 = fold_build1 (NEGATE_EXPR
, TREE_TYPE (t
), t
);
6775 tret
= gimplify_expr (&OMP_CLAUSE_LINEAR_STEP (c
),
6776 &for_pre_body
, NULL
,
6777 is_gimple_val
, fb_rvalue
);
6778 ret
= MIN (ret
, tret
);
6787 if (var
!= decl
|| TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)) > 1)
6790 for (c
= OMP_FOR_CLAUSES (for_stmt
); c
; c
= OMP_CLAUSE_CHAIN (c
))
6791 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LASTPRIVATE
6792 && OMP_CLAUSE_DECL (c
) == decl
6793 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
) == NULL
)
6795 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6796 gcc_assert (TREE_CODE (t
) == MODIFY_EXPR
);
6797 gcc_assert (TREE_OPERAND (t
, 0) == var
);
6798 t
= TREE_OPERAND (t
, 1);
6799 gcc_assert (TREE_CODE (t
) == PLUS_EXPR
6800 || TREE_CODE (t
) == MINUS_EXPR
6801 || TREE_CODE (t
) == POINTER_PLUS_EXPR
);
6802 gcc_assert (TREE_OPERAND (t
, 0) == var
);
6803 t
= build2 (TREE_CODE (t
), TREE_TYPE (decl
), decl
,
6804 TREE_OPERAND (t
, 1));
6805 gimplify_assign (decl
, t
,
6806 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c
));
6811 BITMAP_FREE (has_decl_expr
);
6813 gimplify_and_add (OMP_FOR_BODY (for_stmt
), &for_body
);
6815 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt
));
6818 switch (TREE_CODE (for_stmt
))
6820 case OMP_FOR
: kind
= GF_OMP_FOR_KIND_FOR
; break;
6821 case OMP_SIMD
: kind
= GF_OMP_FOR_KIND_SIMD
; break;
6825 gfor
= gimple_build_omp_for (for_body
, kind
, OMP_FOR_CLAUSES (for_stmt
),
6826 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)),
6829 for (i
= 0; i
< TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt
)); i
++)
6831 t
= TREE_VEC_ELT (OMP_FOR_INIT (for_stmt
), i
);
6832 gimple_omp_for_set_index (gfor
, i
, TREE_OPERAND (t
, 0));
6833 gimple_omp_for_set_initial (gfor
, i
, TREE_OPERAND (t
, 1));
6834 t
= TREE_VEC_ELT (OMP_FOR_COND (for_stmt
), i
);
6835 gimple_omp_for_set_cond (gfor
, i
, TREE_CODE (t
));
6836 gimple_omp_for_set_final (gfor
, i
, TREE_OPERAND (t
, 1));
6837 t
= TREE_VEC_ELT (OMP_FOR_INCR (for_stmt
), i
);
6838 gimple_omp_for_set_incr (gfor
, i
, TREE_OPERAND (t
, 1));
6841 gimplify_seq_add_stmt (pre_p
, gfor
);
6842 if (ret
!= GS_ALL_DONE
)
6844 *expr_p
= NULL_TREE
;
6848 /* Gimplify the gross structure of other OpenMP worksharing constructs.
6849 In particular, OMP_SECTIONS and OMP_SINGLE. */
6852 gimplify_omp_workshare (tree
*expr_p
, gimple_seq
*pre_p
)
6854 tree expr
= *expr_p
;
6856 gimple_seq body
= NULL
;
6858 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr
), pre_p
, ORT_WORKSHARE
);
6859 gimplify_and_add (OMP_BODY (expr
), &body
);
6860 gimplify_adjust_omp_clauses (&OMP_CLAUSES (expr
));
6862 if (TREE_CODE (expr
) == OMP_SECTIONS
)
6863 stmt
= gimple_build_omp_sections (body
, OMP_CLAUSES (expr
));
6864 else if (TREE_CODE (expr
) == OMP_SINGLE
)
6865 stmt
= gimple_build_omp_single (body
, OMP_CLAUSES (expr
));
6869 gimplify_seq_add_stmt (pre_p
, stmt
);
6872 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
6873 stabilized the lhs of the atomic operation as *ADDR. Return true if
6874 EXPR is this stabilized form. */
6877 goa_lhs_expr_p (tree expr
, tree addr
)
6879 /* Also include casts to other type variants. The C front end is fond
6880 of adding these for e.g. volatile variables. This is like
6881 STRIP_TYPE_NOPS but includes the main variant lookup. */
6882 STRIP_USELESS_TYPE_CONVERSION (expr
);
6884 if (TREE_CODE (expr
) == INDIRECT_REF
)
6886 expr
= TREE_OPERAND (expr
, 0);
6888 && (CONVERT_EXPR_P (expr
)
6889 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
6890 && TREE_CODE (expr
) == TREE_CODE (addr
)
6891 && types_compatible_p (TREE_TYPE (expr
), TREE_TYPE (addr
)))
6893 expr
= TREE_OPERAND (expr
, 0);
6894 addr
= TREE_OPERAND (addr
, 0);
6898 return (TREE_CODE (addr
) == ADDR_EXPR
6899 && TREE_CODE (expr
) == ADDR_EXPR
6900 && TREE_OPERAND (addr
, 0) == TREE_OPERAND (expr
, 0));
6902 if (TREE_CODE (addr
) == ADDR_EXPR
&& expr
== TREE_OPERAND (addr
, 0))
6907 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
6908 expression does not involve the lhs, evaluate it into a temporary.
6909 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
6910 or -1 if an error was encountered. */
6913 goa_stabilize_expr (tree
*expr_p
, gimple_seq
*pre_p
, tree lhs_addr
,
6916 tree expr
= *expr_p
;
6919 if (goa_lhs_expr_p (expr
, lhs_addr
))
6924 if (is_gimple_val (expr
))
6928 switch (TREE_CODE_CLASS (TREE_CODE (expr
)))
6931 case tcc_comparison
:
6932 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
, lhs_addr
,
6935 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
, lhs_addr
,
6938 case tcc_expression
:
6939 switch (TREE_CODE (expr
))
6941 case TRUTH_ANDIF_EXPR
:
6942 case TRUTH_ORIF_EXPR
:
6943 case TRUTH_AND_EXPR
:
6945 case TRUTH_XOR_EXPR
:
6946 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 1), pre_p
,
6948 case TRUTH_NOT_EXPR
:
6949 saw_lhs
|= goa_stabilize_expr (&TREE_OPERAND (expr
, 0), pre_p
,
6953 /* Break out any preevaluations from cp_build_modify_expr. */
6954 for (; TREE_CODE (expr
) == COMPOUND_EXPR
;
6955 expr
= TREE_OPERAND (expr
, 1))
6956 gimplify_stmt (&TREE_OPERAND (expr
, 0), pre_p
);
6958 return goa_stabilize_expr (expr_p
, pre_p
, lhs_addr
, lhs_var
);
6969 enum gimplify_status gs
;
6970 gs
= gimplify_expr (expr_p
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
6971 if (gs
!= GS_ALL_DONE
)
6978 /* Gimplify an OMP_ATOMIC statement. */
6980 static enum gimplify_status
6981 gimplify_omp_atomic (tree
*expr_p
, gimple_seq
*pre_p
)
6983 tree addr
= TREE_OPERAND (*expr_p
, 0);
6984 tree rhs
= TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
6985 ? NULL
: TREE_OPERAND (*expr_p
, 1);
6986 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr
)));
6988 gimple loadstmt
, storestmt
;
6990 tmp_load
= create_tmp_reg (type
, NULL
);
6991 if (rhs
&& goa_stabilize_expr (&rhs
, pre_p
, addr
, tmp_load
) < 0)
6994 if (gimplify_expr (&addr
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
6998 loadstmt
= gimple_build_omp_atomic_load (tmp_load
, addr
);
6999 gimplify_seq_add_stmt (pre_p
, loadstmt
);
7000 if (rhs
&& gimplify_expr (&rhs
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
)
7004 if (TREE_CODE (*expr_p
) == OMP_ATOMIC_READ
)
7006 storestmt
= gimple_build_omp_atomic_store (rhs
);
7007 gimplify_seq_add_stmt (pre_p
, storestmt
);
7008 switch (TREE_CODE (*expr_p
))
7010 case OMP_ATOMIC_READ
:
7011 case OMP_ATOMIC_CAPTURE_OLD
:
7013 gimple_omp_atomic_set_need_value (loadstmt
);
7015 case OMP_ATOMIC_CAPTURE_NEW
:
7017 gimple_omp_atomic_set_need_value (storestmt
);
7027 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
7028 body, and adding some EH bits. */
7030 static enum gimplify_status
7031 gimplify_transaction (tree
*expr_p
, gimple_seq
*pre_p
)
7033 tree expr
= *expr_p
, temp
, tbody
= TRANSACTION_EXPR_BODY (expr
);
7035 gimple_seq body
= NULL
;
7036 struct gimplify_ctx gctx
;
7039 /* Wrap the transaction body in a BIND_EXPR so we have a context
7040 where to put decls for OpenMP. */
7041 if (TREE_CODE (tbody
) != BIND_EXPR
)
7043 tree bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, tbody
, NULL
);
7044 TREE_SIDE_EFFECTS (bind
) = 1;
7045 SET_EXPR_LOCATION (bind
, EXPR_LOCATION (tbody
));
7046 TRANSACTION_EXPR_BODY (expr
) = bind
;
7049 push_gimplify_context (&gctx
);
7050 temp
= voidify_wrapper_expr (*expr_p
, NULL
);
7052 g
= gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr
), &body
);
7053 pop_gimplify_context (g
);
7055 g
= gimple_build_transaction (body
, NULL
);
7056 if (TRANSACTION_EXPR_OUTER (expr
))
7057 subcode
= GTMA_IS_OUTER
;
7058 else if (TRANSACTION_EXPR_RELAXED (expr
))
7059 subcode
= GTMA_IS_RELAXED
;
7060 gimple_transaction_set_subcode (g
, subcode
);
7062 gimplify_seq_add_stmt (pre_p
, g
);
7070 *expr_p
= NULL_TREE
;
7074 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
7075 expression produces a value to be used as an operand inside a GIMPLE
7076 statement, the value will be stored back in *EXPR_P. This value will
7077 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
7078 an SSA_NAME. The corresponding sequence of GIMPLE statements is
7079 emitted in PRE_P and POST_P.
7081 Additionally, this process may overwrite parts of the input
7082 expression during gimplification. Ideally, it should be
7083 possible to do non-destructive gimplification.
7085 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
7086 the expression needs to evaluate to a value to be used as
7087 an operand in a GIMPLE statement, this value will be stored in
7088 *EXPR_P on exit. This happens when the caller specifies one
7089 of fb_lvalue or fb_rvalue fallback flags.
7091 PRE_P will contain the sequence of GIMPLE statements corresponding
7092 to the evaluation of EXPR and all the side-effects that must
7093 be executed before the main expression. On exit, the last
7094 statement of PRE_P is the core statement being gimplified. For
7095 instance, when gimplifying 'if (++a)' the last statement in
7096 PRE_P will be 'if (t.1)' where t.1 is the result of
7097 pre-incrementing 'a'.
7099 POST_P will contain the sequence of GIMPLE statements corresponding
7100 to the evaluation of all the side-effects that must be executed
7101 after the main expression. If this is NULL, the post
7102 side-effects are stored at the end of PRE_P.
7104 The reason why the output is split in two is to handle post
7105 side-effects explicitly. In some cases, an expression may have
7106 inner and outer post side-effects which need to be emitted in
7107 an order different from the one given by the recursive
7108 traversal. For instance, for the expression (*p--)++ the post
7109 side-effects of '--' must actually occur *after* the post
7110 side-effects of '++'. However, gimplification will first visit
7111 the inner expression, so if a separate POST sequence was not
7112 used, the resulting sequence would be:
7119 However, the post-decrement operation in line #2 must not be
7120 evaluated until after the store to *p at line #4, so the
7121 correct sequence should be:
7128 So, by specifying a separate post queue, it is possible
7129 to emit the post side-effects in the correct order.
7130 If POST_P is NULL, an internal queue will be used. Before
7131 returning to the caller, the sequence POST_P is appended to
7132 the main output sequence PRE_P.
7134 GIMPLE_TEST_F points to a function that takes a tree T and
7135 returns nonzero if T is in the GIMPLE form requested by the
7136 caller. The GIMPLE predicates are in gimple.c.
7138 FALLBACK tells the function what sort of a temporary we want if
7139 gimplification cannot produce an expression that complies with
7142 fb_none means that no temporary should be generated
7143 fb_rvalue means that an rvalue is OK to generate
7144 fb_lvalue means that an lvalue is OK to generate
7145 fb_either means that either is OK, but an lvalue is preferable.
7146 fb_mayfail means that gimplification may fail (in which case
7147 GS_ERROR will be returned)
7149 The return value is either GS_ERROR or GS_ALL_DONE, since this
7150 function iterates until EXPR is completely gimplified or an error
7153 enum gimplify_status
7154 gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
,
7155 bool (*gimple_test_f
) (tree
), fallback_t fallback
)
7158 gimple_seq internal_pre
= NULL
;
7159 gimple_seq internal_post
= NULL
;
7162 location_t saved_location
;
7163 enum gimplify_status ret
;
7164 gimple_stmt_iterator pre_last_gsi
, post_last_gsi
;
7166 save_expr
= *expr_p
;
7167 if (save_expr
== NULL_TREE
)
7170 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
7171 is_statement
= gimple_test_f
== is_gimple_stmt
;
7175 /* Consistency checks. */
7176 if (gimple_test_f
== is_gimple_reg
)
7177 gcc_assert (fallback
& (fb_rvalue
| fb_lvalue
));
7178 else if (gimple_test_f
== is_gimple_val
7179 || gimple_test_f
== is_gimple_call_addr
7180 || gimple_test_f
== is_gimple_condexpr
7181 || gimple_test_f
== is_gimple_mem_rhs
7182 || gimple_test_f
== is_gimple_mem_rhs_or_call
7183 || gimple_test_f
== is_gimple_reg_rhs
7184 || gimple_test_f
== is_gimple_reg_rhs_or_call
7185 || gimple_test_f
== is_gimple_asm_val
7186 || gimple_test_f
== is_gimple_mem_ref_addr
)
7187 gcc_assert (fallback
& fb_rvalue
);
7188 else if (gimple_test_f
== is_gimple_min_lval
7189 || gimple_test_f
== is_gimple_lvalue
)
7190 gcc_assert (fallback
& fb_lvalue
);
7191 else if (gimple_test_f
== is_gimple_addressable
)
7192 gcc_assert (fallback
& fb_either
);
7193 else if (gimple_test_f
== is_gimple_stmt
)
7194 gcc_assert (fallback
== fb_none
);
7197 /* We should have recognized the GIMPLE_TEST_F predicate to
7198 know what kind of fallback to use in case a temporary is
7199 needed to hold the value or address of *EXPR_P. */
7203 /* We used to check the predicate here and return immediately if it
7204 succeeds. This is wrong; the design is for gimplification to be
7205 idempotent, and for the predicates to only test for valid forms, not
7206 whether they are fully simplified. */
7208 pre_p
= &internal_pre
;
7211 post_p
= &internal_post
;
7213 /* Remember the last statements added to PRE_P and POST_P. Every
7214 new statement added by the gimplification helpers needs to be
7215 annotated with location information. To centralize the
7216 responsibility, we remember the last statement that had been
7217 added to both queues before gimplifying *EXPR_P. If
7218 gimplification produces new statements in PRE_P and POST_P, those
7219 statements will be annotated with the same location information
7221 pre_last_gsi
= gsi_last (*pre_p
);
7222 post_last_gsi
= gsi_last (*post_p
);
7224 saved_location
= input_location
;
7225 if (save_expr
!= error_mark_node
7226 && EXPR_HAS_LOCATION (*expr_p
))
7227 input_location
= EXPR_LOCATION (*expr_p
);
7229 /* Loop over the specific gimplifiers until the toplevel node
7230 remains the same. */
7233 /* Strip away as many useless type conversions as possible
7235 STRIP_USELESS_TYPE_CONVERSION (*expr_p
);
7237 /* Remember the expr. */
7238 save_expr
= *expr_p
;
7240 /* Die, die, die, my darling. */
7241 if (save_expr
== error_mark_node
7242 || (TREE_TYPE (save_expr
)
7243 && TREE_TYPE (save_expr
) == error_mark_node
))
7249 /* Do any language-specific gimplification. */
7250 ret
= ((enum gimplify_status
)
7251 lang_hooks
.gimplify_expr (expr_p
, pre_p
, post_p
));
7254 if (*expr_p
== NULL_TREE
)
7256 if (*expr_p
!= save_expr
)
7259 else if (ret
!= GS_UNHANDLED
)
7262 /* Make sure that all the cases set 'ret' appropriately. */
7264 switch (TREE_CODE (*expr_p
))
7266 /* First deal with the special cases. */
7268 case POSTINCREMENT_EXPR
:
7269 case POSTDECREMENT_EXPR
:
7270 case PREINCREMENT_EXPR
:
7271 case PREDECREMENT_EXPR
:
7272 ret
= gimplify_self_mod_expr (expr_p
, pre_p
, post_p
,
7273 fallback
!= fb_none
,
7274 TREE_TYPE (*expr_p
));
7278 case ARRAY_RANGE_REF
:
7282 case VIEW_CONVERT_EXPR
:
7283 ret
= gimplify_compound_lval (expr_p
, pre_p
, post_p
,
7284 fallback
? fallback
: fb_rvalue
);
7288 ret
= gimplify_cond_expr (expr_p
, pre_p
, fallback
);
7290 /* C99 code may assign to an array in a structure value of a
7291 conditional expression, and this has undefined behavior
7292 only on execution, so create a temporary if an lvalue is
7294 if (fallback
== fb_lvalue
)
7296 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7297 mark_addressable (*expr_p
);
7303 ret
= gimplify_call_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7305 /* C99 code may assign to an array in a structure returned
7306 from a function, and this has undefined behavior only on
7307 execution, so create a temporary if an lvalue is
7309 if (fallback
== fb_lvalue
)
7311 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7312 mark_addressable (*expr_p
);
7321 ret
= gimplify_compound_expr (expr_p
, pre_p
, fallback
!= fb_none
);
7324 case COMPOUND_LITERAL_EXPR
:
7325 ret
= gimplify_compound_literal_expr (expr_p
, pre_p
,
7326 gimple_test_f
, fallback
);
7331 ret
= gimplify_modify_expr (expr_p
, pre_p
, post_p
,
7332 fallback
!= fb_none
);
7335 case TRUTH_ANDIF_EXPR
:
7336 case TRUTH_ORIF_EXPR
:
7338 /* Preserve the original type of the expression and the
7339 source location of the outer expression. */
7340 tree org_type
= TREE_TYPE (*expr_p
);
7341 *expr_p
= gimple_boolify (*expr_p
);
7342 *expr_p
= build3_loc (input_location
, COND_EXPR
,
7346 org_type
, boolean_true_node
),
7349 org_type
, boolean_false_node
));
7354 case TRUTH_NOT_EXPR
:
7356 tree type
= TREE_TYPE (*expr_p
);
7357 /* The parsers are careful to generate TRUTH_NOT_EXPR
7358 only with operands that are always zero or one.
7359 We do not fold here but handle the only interesting case
7360 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
7361 *expr_p
= gimple_boolify (*expr_p
);
7362 if (TYPE_PRECISION (TREE_TYPE (*expr_p
)) == 1)
7363 *expr_p
= build1_loc (input_location
, BIT_NOT_EXPR
,
7364 TREE_TYPE (*expr_p
),
7365 TREE_OPERAND (*expr_p
, 0));
7367 *expr_p
= build2_loc (input_location
, BIT_XOR_EXPR
,
7368 TREE_TYPE (*expr_p
),
7369 TREE_OPERAND (*expr_p
, 0),
7370 build_int_cst (TREE_TYPE (*expr_p
), 1));
7371 if (!useless_type_conversion_p (type
, TREE_TYPE (*expr_p
)))
7372 *expr_p
= fold_convert_loc (input_location
, type
, *expr_p
);
7378 ret
= gimplify_addr_expr (expr_p
, pre_p
, post_p
);
7382 ret
= gimplify_va_arg_expr (expr_p
, pre_p
, post_p
);
7386 if (IS_EMPTY_STMT (*expr_p
))
7392 if (VOID_TYPE_P (TREE_TYPE (*expr_p
))
7393 || fallback
== fb_none
)
7395 /* Just strip a conversion to void (or in void context) and
7397 *expr_p
= TREE_OPERAND (*expr_p
, 0);
7402 ret
= gimplify_conversion (expr_p
);
7403 if (ret
== GS_ERROR
)
7405 if (*expr_p
!= save_expr
)
7409 case FIX_TRUNC_EXPR
:
7410 /* unary_expr: ... | '(' cast ')' val | ... */
7411 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7412 is_gimple_val
, fb_rvalue
);
7413 recalculate_side_effects (*expr_p
);
7418 bool volatilep
= TREE_THIS_VOLATILE (*expr_p
);
7419 bool notrap
= TREE_THIS_NOTRAP (*expr_p
);
7420 tree saved_ptr_type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 0));
7422 *expr_p
= fold_indirect_ref_loc (input_location
, *expr_p
);
7423 if (*expr_p
!= save_expr
)
7429 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7430 is_gimple_reg
, fb_rvalue
);
7431 if (ret
== GS_ERROR
)
7434 recalculate_side_effects (*expr_p
);
7435 *expr_p
= fold_build2_loc (input_location
, MEM_REF
,
7436 TREE_TYPE (*expr_p
),
7437 TREE_OPERAND (*expr_p
, 0),
7438 build_int_cst (saved_ptr_type
, 0));
7439 TREE_THIS_VOLATILE (*expr_p
) = volatilep
;
7440 TREE_THIS_NOTRAP (*expr_p
) = notrap
;
7445 /* We arrive here through the various re-gimplifcation paths. */
7447 /* First try re-folding the whole thing. */
7448 tmp
= fold_binary (MEM_REF
, TREE_TYPE (*expr_p
),
7449 TREE_OPERAND (*expr_p
, 0),
7450 TREE_OPERAND (*expr_p
, 1));
7454 recalculate_side_effects (*expr_p
);
7458 /* Avoid re-gimplifying the address operand if it is already
7459 in suitable form. Re-gimplifying would mark the address
7460 operand addressable. Always gimplify when not in SSA form
7461 as we still may have to gimplify decls with value-exprs. */
7462 if (!gimplify_ctxp
|| !gimplify_ctxp
->into_ssa
7463 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p
, 0)))
7465 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
7466 is_gimple_mem_ref_addr
, fb_rvalue
);
7467 if (ret
== GS_ERROR
)
7470 recalculate_side_effects (*expr_p
);
7474 /* Constants need not be gimplified. */
7485 /* If we require an lvalue, such as for ADDR_EXPR, retain the
7486 CONST_DECL node. Otherwise the decl is replaceable by its
7488 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
7489 if (fallback
& fb_lvalue
)
7493 *expr_p
= DECL_INITIAL (*expr_p
);
7499 ret
= gimplify_decl_expr (expr_p
, pre_p
);
7503 ret
= gimplify_bind_expr (expr_p
, pre_p
);
7507 ret
= gimplify_loop_expr (expr_p
, pre_p
);
7511 ret
= gimplify_switch_expr (expr_p
, pre_p
);
7515 ret
= gimplify_exit_expr (expr_p
);
7519 /* If the target is not LABEL, then it is a computed jump
7520 and the target needs to be gimplified. */
7521 if (TREE_CODE (GOTO_DESTINATION (*expr_p
)) != LABEL_DECL
)
7523 ret
= gimplify_expr (&GOTO_DESTINATION (*expr_p
), pre_p
,
7524 NULL
, is_gimple_val
, fb_rvalue
);
7525 if (ret
== GS_ERROR
)
7528 gimplify_seq_add_stmt (pre_p
,
7529 gimple_build_goto (GOTO_DESTINATION (*expr_p
)));
7534 gimplify_seq_add_stmt (pre_p
,
7535 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p
),
7536 PREDICT_EXPR_OUTCOME (*expr_p
)));
7542 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p
))
7543 == current_function_decl
);
7544 gimplify_seq_add_stmt (pre_p
,
7545 gimple_build_label (LABEL_EXPR_LABEL (*expr_p
)));
7548 case CASE_LABEL_EXPR
:
7549 ret
= gimplify_case_label_expr (expr_p
, pre_p
);
7553 ret
= gimplify_return_expr (*expr_p
, pre_p
);
7557 /* Don't reduce this in place; let gimplify_init_constructor work its
7558 magic. Buf if we're just elaborating this for side effects, just
7559 gimplify any element that has side-effects. */
7560 if (fallback
== fb_none
)
7562 unsigned HOST_WIDE_INT ix
;
7564 tree temp
= NULL_TREE
;
7565 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p
), ix
, val
)
7566 if (TREE_SIDE_EFFECTS (val
))
7567 append_to_statement_list (val
, &temp
);
7570 ret
= temp
? GS_OK
: GS_ALL_DONE
;
7572 /* C99 code may assign to an array in a constructed
7573 structure or union, and this has undefined behavior only
7574 on execution, so create a temporary if an lvalue is
7576 else if (fallback
== fb_lvalue
)
7578 *expr_p
= get_initialized_tmp_var (*expr_p
, pre_p
, post_p
);
7579 mark_addressable (*expr_p
);
7586 /* The following are special cases that are not handled by the
7587 original GIMPLE grammar. */
7589 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
7592 ret
= gimplify_save_expr (expr_p
, pre_p
, post_p
);
7596 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7597 post_p
, is_gimple_lvalue
, fb_either
);
7598 recalculate_side_effects (*expr_p
);
7601 case TARGET_MEM_REF
:
7603 enum gimplify_status r0
= GS_ALL_DONE
, r1
= GS_ALL_DONE
;
7605 if (TMR_BASE (*expr_p
))
7606 r0
= gimplify_expr (&TMR_BASE (*expr_p
), pre_p
,
7607 post_p
, is_gimple_mem_ref_addr
, fb_either
);
7608 if (TMR_INDEX (*expr_p
))
7609 r1
= gimplify_expr (&TMR_INDEX (*expr_p
), pre_p
,
7610 post_p
, is_gimple_val
, fb_rvalue
);
7611 if (TMR_INDEX2 (*expr_p
))
7612 r1
= gimplify_expr (&TMR_INDEX2 (*expr_p
), pre_p
,
7613 post_p
, is_gimple_val
, fb_rvalue
);
7614 /* TMR_STEP and TMR_OFFSET are always integer constants. */
7619 case NON_LVALUE_EXPR
:
7620 /* This should have been stripped above. */
7624 ret
= gimplify_asm_expr (expr_p
, pre_p
, post_p
);
7627 case TRY_FINALLY_EXPR
:
7628 case TRY_CATCH_EXPR
:
7630 gimple_seq eval
, cleanup
;
7633 /* Calls to destructors are generated automatically in FINALLY/CATCH
7634 block. They should have location as UNKNOWN_LOCATION. However,
7635 gimplify_call_expr will reset these call stmts to input_location
7636 if it finds stmt's location is unknown. To prevent resetting for
7637 destructors, we set the input_location to unknown.
7638 Note that this only affects the destructor calls in FINALLY/CATCH
7639 block, and will automatically reset to its original value by the
7640 end of gimplify_expr. */
7641 input_location
= UNKNOWN_LOCATION
;
7642 eval
= cleanup
= NULL
;
7643 gimplify_and_add (TREE_OPERAND (*expr_p
, 0), &eval
);
7644 gimplify_and_add (TREE_OPERAND (*expr_p
, 1), &cleanup
);
7645 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
7646 if (gimple_seq_empty_p (cleanup
))
7648 gimple_seq_add_seq (pre_p
, eval
);
7652 try_
= gimple_build_try (eval
, cleanup
,
7653 TREE_CODE (*expr_p
) == TRY_FINALLY_EXPR
7654 ? GIMPLE_TRY_FINALLY
7655 : GIMPLE_TRY_CATCH
);
7656 if (LOCATION_LOCUS (saved_location
) != UNKNOWN_LOCATION
)
7657 gimple_set_location (try_
, saved_location
);
7659 gimple_set_location (try_
, EXPR_LOCATION (save_expr
));
7660 if (TREE_CODE (*expr_p
) == TRY_CATCH_EXPR
)
7661 gimple_try_set_catch_is_cleanup (try_
,
7662 TRY_CATCH_IS_CLEANUP (*expr_p
));
7663 gimplify_seq_add_stmt (pre_p
, try_
);
7668 case CLEANUP_POINT_EXPR
:
7669 ret
= gimplify_cleanup_point_expr (expr_p
, pre_p
);
7673 ret
= gimplify_target_expr (expr_p
, pre_p
, post_p
);
7679 gimple_seq handler
= NULL
;
7680 gimplify_and_add (CATCH_BODY (*expr_p
), &handler
);
7681 c
= gimple_build_catch (CATCH_TYPES (*expr_p
), handler
);
7682 gimplify_seq_add_stmt (pre_p
, c
);
7687 case EH_FILTER_EXPR
:
7690 gimple_seq failure
= NULL
;
7692 gimplify_and_add (EH_FILTER_FAILURE (*expr_p
), &failure
);
7693 ehf
= gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p
), failure
);
7694 gimple_set_no_warning (ehf
, TREE_NO_WARNING (*expr_p
));
7695 gimplify_seq_add_stmt (pre_p
, ehf
);
7702 enum gimplify_status r0
, r1
;
7703 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
,
7704 post_p
, is_gimple_val
, fb_rvalue
);
7705 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
,
7706 post_p
, is_gimple_val
, fb_rvalue
);
7707 TREE_SIDE_EFFECTS (*expr_p
) = 0;
7713 /* We get here when taking the address of a label. We mark
7714 the label as "forced"; meaning it can never be removed and
7715 it is a potential target for any computed goto. */
7716 FORCED_LABEL (*expr_p
) = 1;
7720 case STATEMENT_LIST
:
7721 ret
= gimplify_statement_list (expr_p
, pre_p
);
7724 case WITH_SIZE_EXPR
:
7726 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7727 post_p
== &internal_post
? NULL
: post_p
,
7728 gimple_test_f
, fallback
);
7729 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
7730 is_gimple_val
, fb_rvalue
);
7737 ret
= gimplify_var_or_parm_decl (expr_p
);
7741 /* When within an OpenMP context, notice uses of variables. */
7742 if (gimplify_omp_ctxp
)
7743 omp_notice_variable (gimplify_omp_ctxp
, *expr_p
, true);
7748 /* Allow callbacks into the gimplifier during optimization. */
7753 gimplify_omp_parallel (expr_p
, pre_p
);
7758 gimplify_omp_task (expr_p
, pre_p
);
7764 ret
= gimplify_omp_for (expr_p
, pre_p
);
7769 gimplify_omp_workshare (expr_p
, pre_p
);
7778 gimple_seq body
= NULL
;
7781 gimplify_and_add (OMP_BODY (*expr_p
), &body
);
7782 switch (TREE_CODE (*expr_p
))
7785 g
= gimple_build_omp_section (body
);
7788 g
= gimple_build_omp_master (body
);
7791 g
= gimple_build_omp_ordered (body
);
7794 g
= gimple_build_omp_critical (body
,
7795 OMP_CRITICAL_NAME (*expr_p
));
7800 gimplify_seq_add_stmt (pre_p
, g
);
7806 case OMP_ATOMIC_READ
:
7807 case OMP_ATOMIC_CAPTURE_OLD
:
7808 case OMP_ATOMIC_CAPTURE_NEW
:
7809 ret
= gimplify_omp_atomic (expr_p
, pre_p
);
7812 case TRANSACTION_EXPR
:
7813 ret
= gimplify_transaction (expr_p
, pre_p
);
7816 case TRUTH_AND_EXPR
:
7818 case TRUTH_XOR_EXPR
:
7820 tree orig_type
= TREE_TYPE (*expr_p
);
7821 tree new_type
, xop0
, xop1
;
7822 *expr_p
= gimple_boolify (*expr_p
);
7823 new_type
= TREE_TYPE (*expr_p
);
7824 if (!useless_type_conversion_p (orig_type
, new_type
))
7826 *expr_p
= fold_convert_loc (input_location
, orig_type
, *expr_p
);
7831 /* Boolified binary truth expressions are semantically equivalent
7832 to bitwise binary expressions. Canonicalize them to the
7834 switch (TREE_CODE (*expr_p
))
7836 case TRUTH_AND_EXPR
:
7837 TREE_SET_CODE (*expr_p
, BIT_AND_EXPR
);
7840 TREE_SET_CODE (*expr_p
, BIT_IOR_EXPR
);
7842 case TRUTH_XOR_EXPR
:
7843 TREE_SET_CODE (*expr_p
, BIT_XOR_EXPR
);
7848 /* Now make sure that operands have compatible type to
7849 expression's new_type. */
7850 xop0
= TREE_OPERAND (*expr_p
, 0);
7851 xop1
= TREE_OPERAND (*expr_p
, 1);
7852 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop0
)))
7853 TREE_OPERAND (*expr_p
, 0) = fold_convert_loc (input_location
,
7856 if (!useless_type_conversion_p (new_type
, TREE_TYPE (xop1
)))
7857 TREE_OPERAND (*expr_p
, 1) = fold_convert_loc (input_location
,
7860 /* Continue classified as tcc_binary. */
7867 /* Classified as tcc_expression. */
7870 case POINTER_PLUS_EXPR
:
7872 enum gimplify_status r0
, r1
;
7873 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7874 post_p
, is_gimple_val
, fb_rvalue
);
7875 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7876 post_p
, is_gimple_val
, fb_rvalue
);
7877 recalculate_side_effects (*expr_p
);
7879 /* Convert &X + CST to invariant &MEM[&X, CST]. Do this
7880 after gimplifying operands - this is similar to how
7881 it would be folding all gimplified stmts on creation
7882 to have them canonicalized, which is what we eventually
7883 should do anyway. */
7884 if (TREE_CODE (TREE_OPERAND (*expr_p
, 1)) == INTEGER_CST
7885 && is_gimple_min_invariant (TREE_OPERAND (*expr_p
, 0)))
7887 *expr_p
= build_fold_addr_expr_with_type_loc
7889 fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (*expr_p
)),
7890 TREE_OPERAND (*expr_p
, 0),
7891 fold_convert (ptr_type_node
,
7892 TREE_OPERAND (*expr_p
, 1))),
7893 TREE_TYPE (*expr_p
));
7894 ret
= MIN (ret
, GS_OK
);
7900 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p
)))
7902 case tcc_comparison
:
7903 /* Handle comparison of objects of non scalar mode aggregates
7904 with a call to memcmp. It would be nice to only have to do
7905 this for variable-sized objects, but then we'd have to allow
7906 the same nest of reference nodes we allow for MODIFY_EXPR and
7909 Compare scalar mode aggregates as scalar mode values. Using
7910 memcmp for them would be very inefficient at best, and is
7911 plain wrong if bitfields are involved. */
7913 tree type
= TREE_TYPE (TREE_OPERAND (*expr_p
, 1));
7915 /* Vector comparisons need no boolification. */
7916 if (TREE_CODE (type
) == VECTOR_TYPE
)
7918 else if (!AGGREGATE_TYPE_P (type
))
7920 tree org_type
= TREE_TYPE (*expr_p
);
7921 *expr_p
= gimple_boolify (*expr_p
);
7922 if (!useless_type_conversion_p (org_type
,
7923 TREE_TYPE (*expr_p
)))
7925 *expr_p
= fold_convert_loc (input_location
,
7932 else if (TYPE_MODE (type
) != BLKmode
)
7933 ret
= gimplify_scalar_mode_aggregate_compare (expr_p
);
7935 ret
= gimplify_variable_sized_compare (expr_p
);
7940 /* If *EXPR_P does not need to be special-cased, handle it
7941 according to its class. */
7943 ret
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7944 post_p
, is_gimple_val
, fb_rvalue
);
7950 enum gimplify_status r0
, r1
;
7952 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7953 post_p
, is_gimple_val
, fb_rvalue
);
7954 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7955 post_p
, is_gimple_val
, fb_rvalue
);
7963 enum gimplify_status r0
, r1
, r2
;
7965 r0
= gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
,
7966 post_p
, is_gimple_val
, fb_rvalue
);
7967 r1
= gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
,
7968 post_p
, is_gimple_val
, fb_rvalue
);
7969 r2
= gimplify_expr (&TREE_OPERAND (*expr_p
, 2), pre_p
,
7970 post_p
, is_gimple_val
, fb_rvalue
);
7972 ret
= MIN (MIN (r0
, r1
), r2
);
7976 case tcc_declaration
:
7979 goto dont_recalculate
;
7985 recalculate_side_effects (*expr_p
);
7991 gcc_assert (*expr_p
|| ret
!= GS_OK
);
7993 while (ret
== GS_OK
);
7995 /* If we encountered an error_mark somewhere nested inside, either
7996 stub out the statement or propagate the error back out. */
7997 if (ret
== GS_ERROR
)
8004 /* This was only valid as a return value from the langhook, which
8005 we handled. Make sure it doesn't escape from any other context. */
8006 gcc_assert (ret
!= GS_UNHANDLED
);
8008 if (fallback
== fb_none
&& *expr_p
&& !is_gimple_stmt (*expr_p
))
8010 /* We aren't looking for a value, and we don't have a valid
8011 statement. If it doesn't have side-effects, throw it away. */
8012 if (!TREE_SIDE_EFFECTS (*expr_p
))
8014 else if (!TREE_THIS_VOLATILE (*expr_p
))
8016 /* This is probably a _REF that contains something nested that
8017 has side effects. Recurse through the operands to find it. */
8018 enum tree_code code
= TREE_CODE (*expr_p
);
8025 case VIEW_CONVERT_EXPR
:
8026 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8027 gimple_test_f
, fallback
);
8031 case ARRAY_RANGE_REF
:
8032 gimplify_expr (&TREE_OPERAND (*expr_p
, 0), pre_p
, post_p
,
8033 gimple_test_f
, fallback
);
8034 gimplify_expr (&TREE_OPERAND (*expr_p
, 1), pre_p
, post_p
,
8035 gimple_test_f
, fallback
);
8039 /* Anything else with side-effects must be converted to
8040 a valid statement before we get here. */
8046 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p
))
8047 && TYPE_MODE (TREE_TYPE (*expr_p
)) != BLKmode
)
8049 /* Historically, the compiler has treated a bare reference
8050 to a non-BLKmode volatile lvalue as forcing a load. */
8051 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p
));
8053 /* Normally, we do not want to create a temporary for a
8054 TREE_ADDRESSABLE type because such a type should not be
8055 copied by bitwise-assignment. However, we make an
8056 exception here, as all we are doing here is ensuring that
8057 we read the bytes that make up the type. We use
8058 create_tmp_var_raw because create_tmp_var will abort when
8059 given a TREE_ADDRESSABLE type. */
8060 tree tmp
= create_tmp_var_raw (type
, "vol");
8061 gimple_add_tmp_var (tmp
);
8062 gimplify_assign (tmp
, *expr_p
, pre_p
);
8066 /* We can't do anything useful with a volatile reference to
8067 an incomplete type, so just throw it away. Likewise for
8068 a BLKmode type, since any implicit inner load should
8069 already have been turned into an explicit one by the
8070 gimplification process. */
8074 /* If we are gimplifying at the statement level, we're done. Tack
8075 everything together and return. */
8076 if (fallback
== fb_none
|| is_statement
)
8078 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
8079 it out for GC to reclaim it. */
8080 *expr_p
= NULL_TREE
;
8082 if (!gimple_seq_empty_p (internal_pre
)
8083 || !gimple_seq_empty_p (internal_post
))
8085 gimplify_seq_add_seq (&internal_pre
, internal_post
);
8086 gimplify_seq_add_seq (pre_p
, internal_pre
);
8089 /* The result of gimplifying *EXPR_P is going to be the last few
8090 statements in *PRE_P and *POST_P. Add location information
8091 to all the statements that were added by the gimplification
8093 if (!gimple_seq_empty_p (*pre_p
))
8094 annotate_all_with_location_after (*pre_p
, pre_last_gsi
, input_location
);
8096 if (!gimple_seq_empty_p (*post_p
))
8097 annotate_all_with_location_after (*post_p
, post_last_gsi
,
8103 #ifdef ENABLE_GIMPLE_CHECKING
8106 enum tree_code code
= TREE_CODE (*expr_p
);
8107 /* These expressions should already be in gimple IR form. */
8108 gcc_assert (code
!= MODIFY_EXPR
8110 && code
!= BIND_EXPR
8111 && code
!= CATCH_EXPR
8112 && (code
!= COND_EXPR
|| gimplify_ctxp
->allow_rhs_cond_expr
)
8113 && code
!= EH_FILTER_EXPR
8114 && code
!= GOTO_EXPR
8115 && code
!= LABEL_EXPR
8116 && code
!= LOOP_EXPR
8117 && code
!= SWITCH_EXPR
8118 && code
!= TRY_FINALLY_EXPR
8119 && code
!= OMP_CRITICAL
8121 && code
!= OMP_MASTER
8122 && code
!= OMP_ORDERED
8123 && code
!= OMP_PARALLEL
8124 && code
!= OMP_SECTIONS
8125 && code
!= OMP_SECTION
8126 && code
!= OMP_SINGLE
);
8130 /* Otherwise we're gimplifying a subexpression, so the resulting
8131 value is interesting. If it's a valid operand that matches
8132 GIMPLE_TEST_F, we're done. Unless we are handling some
8133 post-effects internally; if that's the case, we need to copy into
8134 a temporary before adding the post-effects to POST_P. */
8135 if (gimple_seq_empty_p (internal_post
) && (*gimple_test_f
) (*expr_p
))
8138 /* Otherwise, we need to create a new temporary for the gimplified
8141 /* We can't return an lvalue if we have an internal postqueue. The
8142 object the lvalue refers to would (probably) be modified by the
8143 postqueue; we need to copy the value out first, which means an
8145 if ((fallback
& fb_lvalue
)
8146 && gimple_seq_empty_p (internal_post
)
8147 && is_gimple_addressable (*expr_p
))
8149 /* An lvalue will do. Take the address of the expression, store it
8150 in a temporary, and replace the expression with an INDIRECT_REF of
8152 tmp
= build_fold_addr_expr_loc (input_location
, *expr_p
);
8153 gimplify_expr (&tmp
, pre_p
, post_p
, is_gimple_reg
, fb_rvalue
);
8154 *expr_p
= build_simple_mem_ref (tmp
);
8156 else if ((fallback
& fb_rvalue
) && is_gimple_reg_rhs_or_call (*expr_p
))
8158 /* An rvalue will do. Assign the gimplified expression into a
8159 new temporary TMP and replace the original expression with
8160 TMP. First, make sure that the expression has a type so that
8161 it can be assigned into a temporary. */
8162 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p
)));
8163 *expr_p
= get_formal_tmp_var (*expr_p
, pre_p
);
8167 #ifdef ENABLE_GIMPLE_CHECKING
8168 if (!(fallback
& fb_mayfail
))
8170 fprintf (stderr
, "gimplification failed:\n");
8171 print_generic_expr (stderr
, *expr_p
, 0);
8172 debug_tree (*expr_p
);
8173 internal_error ("gimplification failed");
8176 gcc_assert (fallback
& fb_mayfail
);
8178 /* If this is an asm statement, and the user asked for the
8179 impossible, don't die. Fail and let gimplify_asm_expr
8185 /* Make sure the temporary matches our predicate. */
8186 gcc_assert ((*gimple_test_f
) (*expr_p
));
8188 if (!gimple_seq_empty_p (internal_post
))
8190 annotate_all_with_location (internal_post
, input_location
);
8191 gimplify_seq_add_seq (pre_p
, internal_post
);
8195 input_location
= saved_location
;
8199 /* Look through TYPE for variable-sized objects and gimplify each such
8200 size that we find. Add to LIST_P any statements generated. */
8203 gimplify_type_sizes (tree type
, gimple_seq
*list_p
)
8207 if (type
== NULL
|| type
== error_mark_node
)
8210 /* We first do the main variant, then copy into any other variants. */
8211 type
= TYPE_MAIN_VARIANT (type
);
8213 /* Avoid infinite recursion. */
8214 if (TYPE_SIZES_GIMPLIFIED (type
))
8217 TYPE_SIZES_GIMPLIFIED (type
) = 1;
8219 switch (TREE_CODE (type
))
8225 case FIXED_POINT_TYPE
:
8226 gimplify_one_sizepos (&TYPE_MIN_VALUE (type
), list_p
);
8227 gimplify_one_sizepos (&TYPE_MAX_VALUE (type
), list_p
);
8229 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8231 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (type
);
8232 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (type
);
8237 /* These types may not have declarations, so handle them here. */
8238 gimplify_type_sizes (TREE_TYPE (type
), list_p
);
8239 gimplify_type_sizes (TYPE_DOMAIN (type
), list_p
);
8240 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
8241 with assigned stack slots, for -O1+ -g they should be tracked
8243 if (!(TYPE_NAME (type
)
8244 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
8245 && DECL_IGNORED_P (TYPE_NAME (type
)))
8246 && TYPE_DOMAIN (type
)
8247 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type
)))
8249 t
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
8250 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8251 DECL_IGNORED_P (t
) = 0;
8252 t
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
8253 if (t
&& TREE_CODE (t
) == VAR_DECL
&& DECL_ARTIFICIAL (t
))
8254 DECL_IGNORED_P (t
) = 0;
8260 case QUAL_UNION_TYPE
:
8261 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
8262 if (TREE_CODE (field
) == FIELD_DECL
)
8264 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field
), list_p
);
8265 gimplify_one_sizepos (&DECL_SIZE (field
), list_p
);
8266 gimplify_one_sizepos (&DECL_SIZE_UNIT (field
), list_p
);
8267 gimplify_type_sizes (TREE_TYPE (field
), list_p
);
8272 case REFERENCE_TYPE
:
8273 /* We used to recurse on the pointed-to type here, which turned out to
8274 be incorrect because its definition might refer to variables not
8275 yet initialized at this point if a forward declaration is involved.
8277 It was actually useful for anonymous pointed-to types to ensure
8278 that the sizes evaluation dominates every possible later use of the
8279 values. Restricting to such types here would be safe since there
8280 is no possible forward declaration around, but would introduce an
8281 undesirable middle-end semantic to anonymity. We then defer to
8282 front-ends the responsibility of ensuring that the sizes are
8283 evaluated both early and late enough, e.g. by attaching artificial
8284 type declarations to the tree. */
8291 gimplify_one_sizepos (&TYPE_SIZE (type
), list_p
);
8292 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type
), list_p
);
8294 for (t
= TYPE_NEXT_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8296 TYPE_SIZE (t
) = TYPE_SIZE (type
);
8297 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (type
);
8298 TYPE_SIZES_GIMPLIFIED (t
) = 1;
8302 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
8303 a size or position, has had all of its SAVE_EXPRs evaluated.
8304 We add any required statements to *STMT_P. */
8307 gimplify_one_sizepos (tree
*expr_p
, gimple_seq
*stmt_p
)
8309 tree expr
= *expr_p
;
8311 /* We don't do anything if the value isn't there, is constant, or contains
8312 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
8313 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
8314 will want to replace it with a new variable, but that will cause problems
8315 if this type is from outside the function. It's OK to have that here. */
8316 if (is_gimple_sizepos (expr
))
8319 *expr_p
= unshare_expr (expr
);
8321 gimplify_expr (expr_p
, stmt_p
, NULL
, is_gimple_val
, fb_rvalue
);
8324 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
8325 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
8326 is true, also gimplify the parameters. */
8329 gimplify_body (tree fndecl
, bool do_parms
)
8331 location_t saved_location
= input_location
;
8332 gimple_seq parm_stmts
, seq
;
8334 struct gimplify_ctx gctx
;
8335 struct cgraph_node
*cgn
;
8337 timevar_push (TV_TREE_GIMPLIFY
);
8339 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
8341 default_rtl_profile ();
8343 gcc_assert (gimplify_ctxp
== NULL
);
8344 push_gimplify_context (&gctx
);
8346 /* Unshare most shared trees in the body and in that of any nested functions.
8347 It would seem we don't have to do this for nested functions because
8348 they are supposed to be output and then the outer function gimplified
8349 first, but the g++ front end doesn't always do it that way. */
8350 unshare_body (fndecl
);
8351 unvisit_body (fndecl
);
8353 cgn
= cgraph_get_node (fndecl
);
8354 if (cgn
&& cgn
->origin
)
8355 nonlocal_vlas
= pointer_set_create ();
8357 /* Make sure input_location isn't set to something weird. */
8358 input_location
= DECL_SOURCE_LOCATION (fndecl
);
8360 /* Resolve callee-copies. This has to be done before processing
8361 the body so that DECL_VALUE_EXPR gets processed correctly. */
8362 parm_stmts
= do_parms
? gimplify_parameters () : NULL
;
8364 /* Gimplify the function's body. */
8366 gimplify_stmt (&DECL_SAVED_TREE (fndecl
), &seq
);
8367 outer_bind
= gimple_seq_first_stmt (seq
);
8370 outer_bind
= gimple_build_nop ();
8371 gimplify_seq_add_stmt (&seq
, outer_bind
);
8374 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
8375 not the case, wrap everything in a GIMPLE_BIND to make it so. */
8376 if (gimple_code (outer_bind
) == GIMPLE_BIND
8377 && gimple_seq_first (seq
) == gimple_seq_last (seq
))
8380 outer_bind
= gimple_build_bind (NULL_TREE
, seq
, NULL
);
8382 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
8384 /* If we had callee-copies statements, insert them at the beginning
8385 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
8386 if (!gimple_seq_empty_p (parm_stmts
))
8390 gimplify_seq_add_seq (&parm_stmts
, gimple_bind_body (outer_bind
));
8391 gimple_bind_set_body (outer_bind
, parm_stmts
);
8393 for (parm
= DECL_ARGUMENTS (current_function_decl
);
8394 parm
; parm
= DECL_CHAIN (parm
))
8395 if (DECL_HAS_VALUE_EXPR_P (parm
))
8397 DECL_HAS_VALUE_EXPR_P (parm
) = 0;
8398 DECL_IGNORED_P (parm
) = 0;
8404 pointer_set_destroy (nonlocal_vlas
);
8405 nonlocal_vlas
= NULL
;
8408 pop_gimplify_context (outer_bind
);
8409 gcc_assert (gimplify_ctxp
== NULL
);
8411 #ifdef ENABLE_CHECKING
8413 verify_gimple_in_seq (gimple_bind_body (outer_bind
));
8416 timevar_pop (TV_TREE_GIMPLIFY
);
8417 input_location
= saved_location
;
8422 typedef char *char_p
; /* For DEF_VEC_P. */
8424 /* Return whether we should exclude FNDECL from instrumentation. */
8427 flag_instrument_functions_exclude_p (tree fndecl
)
8431 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_functions
;
8432 if (v
&& v
->length () > 0)
8438 name
= lang_hooks
.decl_printable_name (fndecl
, 0);
8439 FOR_EACH_VEC_ELT (*v
, i
, s
)
8440 if (strstr (name
, s
) != NULL
)
8444 v
= (vec
<char_p
> *) flag_instrument_functions_exclude_files
;
8445 if (v
&& v
->length () > 0)
8451 name
= DECL_SOURCE_FILE (fndecl
);
8452 FOR_EACH_VEC_ELT (*v
, i
, s
)
8453 if (strstr (name
, s
) != NULL
)
8460 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
8461 node for the function we want to gimplify.
8463 Return the sequence of GIMPLE statements corresponding to the body
8467 gimplify_function_tree (tree fndecl
)
8473 gcc_assert (!gimple_body (fndecl
));
8475 if (DECL_STRUCT_FUNCTION (fndecl
))
8476 push_cfun (DECL_STRUCT_FUNCTION (fndecl
));
8478 push_struct_function (fndecl
);
8480 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
8482 /* Preliminarily mark non-addressed complex variables as eligible
8483 for promotion to gimple registers. We'll transform their uses
8485 if ((TREE_CODE (TREE_TYPE (parm
)) == COMPLEX_TYPE
8486 || TREE_CODE (TREE_TYPE (parm
)) == VECTOR_TYPE
)
8487 && !TREE_THIS_VOLATILE (parm
)
8488 && !needs_to_live_in_memory (parm
))
8489 DECL_GIMPLE_REG_P (parm
) = 1;
8492 ret
= DECL_RESULT (fndecl
);
8493 if ((TREE_CODE (TREE_TYPE (ret
)) == COMPLEX_TYPE
8494 || TREE_CODE (TREE_TYPE (ret
)) == VECTOR_TYPE
)
8495 && !needs_to_live_in_memory (ret
))
8496 DECL_GIMPLE_REG_P (ret
) = 1;
8498 bind
= gimplify_body (fndecl
, true);
8500 /* The tree body of the function is no longer needed, replace it
8501 with the new GIMPLE body. */
8503 gimple_seq_add_stmt (&seq
, bind
);
8504 gimple_set_body (fndecl
, seq
);
8506 /* If we're instrumenting function entry/exit, then prepend the call to
8507 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
8508 catch the exit hook. */
8509 /* ??? Add some way to ignore exceptions for this TFE. */
8510 if (flag_instrument_function_entry_exit
8511 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl
)
8512 && !flag_instrument_functions_exclude_p (fndecl
))
8517 gimple_seq cleanup
= NULL
, body
= NULL
;
8521 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
8522 call
= gimple_build_call (x
, 1, integer_zero_node
);
8523 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
8524 gimple_call_set_lhs (call
, tmp_var
);
8525 gimplify_seq_add_stmt (&cleanup
, call
);
8526 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT
);
8527 call
= gimple_build_call (x
, 2,
8528 build_fold_addr_expr (current_function_decl
),
8530 gimplify_seq_add_stmt (&cleanup
, call
);
8531 tf
= gimple_build_try (seq
, cleanup
, GIMPLE_TRY_FINALLY
);
8533 x
= builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS
);
8534 call
= gimple_build_call (x
, 1, integer_zero_node
);
8535 tmp_var
= create_tmp_var (ptr_type_node
, "return_addr");
8536 gimple_call_set_lhs (call
, tmp_var
);
8537 gimplify_seq_add_stmt (&body
, call
);
8538 x
= builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER
);
8539 call
= gimple_build_call (x
, 2,
8540 build_fold_addr_expr (current_function_decl
),
8542 gimplify_seq_add_stmt (&body
, call
);
8543 gimplify_seq_add_stmt (&body
, tf
);
8544 new_bind
= gimple_build_bind (NULL
, body
, gimple_bind_block (bind
));
8545 /* Clear the block for BIND, since it is no longer directly inside
8546 the function, but within a try block. */
8547 gimple_bind_set_block (bind
, NULL
);
8549 /* Replace the current function body with the body
8550 wrapped in the try/finally TF. */
8552 gimple_seq_add_stmt (&seq
, new_bind
);
8553 gimple_set_body (fndecl
, seq
);
8556 DECL_SAVED_TREE (fndecl
) = NULL_TREE
;
8557 cfun
->curr_properties
= PROP_gimple_any
;
8562 /* Some transformations like inlining may invalidate the GIMPLE form
8563 for operands. This function traverses all the operands in STMT and
8564 gimplifies anything that is not a valid gimple operand. Any new
8565 GIMPLE statements are inserted before *GSI_P. */
8568 gimple_regimplify_operands (gimple stmt
, gimple_stmt_iterator
*gsi_p
)
8572 gimple_seq pre
= NULL
;
8573 gimple post_stmt
= NULL
;
8574 struct gimplify_ctx gctx
;
8576 push_gimplify_context (&gctx
);
8577 gimplify_ctxp
->into_ssa
= gimple_in_ssa_p (cfun
);
8579 switch (gimple_code (stmt
))
8582 gimplify_expr (gimple_cond_lhs_ptr (stmt
), &pre
, NULL
,
8583 is_gimple_val
, fb_rvalue
);
8584 gimplify_expr (gimple_cond_rhs_ptr (stmt
), &pre
, NULL
,
8585 is_gimple_val
, fb_rvalue
);
8588 gimplify_expr (gimple_switch_index_ptr (stmt
), &pre
, NULL
,
8589 is_gimple_val
, fb_rvalue
);
8591 case GIMPLE_OMP_ATOMIC_LOAD
:
8592 gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt
), &pre
, NULL
,
8593 is_gimple_val
, fb_rvalue
);
8597 size_t i
, noutputs
= gimple_asm_noutputs (stmt
);
8598 const char *constraint
, **oconstraints
;
8599 bool allows_mem
, allows_reg
, is_inout
;
8602 = (const char **) alloca ((noutputs
) * sizeof (const char *));
8603 for (i
= 0; i
< noutputs
; i
++)
8605 tree op
= gimple_asm_output_op (stmt
, i
);
8606 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op
)));
8607 oconstraints
[i
] = constraint
;
8608 parse_output_constraint (&constraint
, i
, 0, 0, &allows_mem
,
8609 &allows_reg
, &is_inout
);
8610 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8611 is_inout
? is_gimple_min_lval
: is_gimple_lvalue
,
8612 fb_lvalue
| fb_mayfail
);
8614 for (i
= 0; i
< gimple_asm_ninputs (stmt
); i
++)
8616 tree op
= gimple_asm_input_op (stmt
, i
);
8617 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op
)));
8618 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
8619 oconstraints
, &allows_mem
, &allows_reg
);
8620 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op
))) && allows_mem
)
8622 if (!allows_reg
&& allows_mem
)
8623 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8624 is_gimple_lvalue
, fb_lvalue
| fb_mayfail
);
8626 gimplify_expr (&TREE_VALUE (op
), &pre
, NULL
,
8627 is_gimple_asm_val
, fb_rvalue
);
8632 /* NOTE: We start gimplifying operands from last to first to
8633 make sure that side-effects on the RHS of calls, assignments
8634 and ASMs are executed before the LHS. The ordering is not
8635 important for other statements. */
8636 num_ops
= gimple_num_ops (stmt
);
8637 for (i
= num_ops
; i
> 0; i
--)
8639 tree op
= gimple_op (stmt
, i
- 1);
8640 if (op
== NULL_TREE
)
8642 if (i
== 1 && (is_gimple_call (stmt
) || is_gimple_assign (stmt
)))
8643 gimplify_expr (&op
, &pre
, NULL
, is_gimple_lvalue
, fb_lvalue
);
8645 && is_gimple_assign (stmt
)
8647 && get_gimple_rhs_class (gimple_expr_code (stmt
))
8648 == GIMPLE_SINGLE_RHS
)
8649 gimplify_expr (&op
, &pre
, NULL
,
8650 rhs_predicate_for (gimple_assign_lhs (stmt
)),
8652 else if (i
== 2 && is_gimple_call (stmt
))
8654 if (TREE_CODE (op
) == FUNCTION_DECL
)
8656 gimplify_expr (&op
, &pre
, NULL
, is_gimple_call_addr
, fb_rvalue
);
8659 gimplify_expr (&op
, &pre
, NULL
, is_gimple_val
, fb_rvalue
);
8660 gimple_set_op (stmt
, i
- 1, op
);
8663 lhs
= gimple_get_lhs (stmt
);
8664 /* If the LHS changed it in a way that requires a simple RHS,
8665 create temporary. */
8666 if (lhs
&& !is_gimple_reg (lhs
))
8668 bool need_temp
= false;
8670 if (is_gimple_assign (stmt
)
8672 && get_gimple_rhs_class (gimple_expr_code (stmt
))
8673 == GIMPLE_SINGLE_RHS
)
8674 gimplify_expr (gimple_assign_rhs1_ptr (stmt
), &pre
, NULL
,
8675 rhs_predicate_for (gimple_assign_lhs (stmt
)),
8677 else if (is_gimple_reg (lhs
))
8679 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
8681 if (is_gimple_call (stmt
))
8683 i
= gimple_call_flags (stmt
);
8684 if ((i
& ECF_LOOPING_CONST_OR_PURE
)
8685 || !(i
& (ECF_CONST
| ECF_PURE
)))
8688 if (stmt_can_throw_internal (stmt
))
8694 if (is_gimple_reg_type (TREE_TYPE (lhs
)))
8696 else if (TYPE_MODE (TREE_TYPE (lhs
)) != BLKmode
)
8698 if (is_gimple_call (stmt
))
8700 tree fndecl
= gimple_call_fndecl (stmt
);
8702 if (!aggregate_value_p (TREE_TYPE (lhs
), fndecl
)
8703 && !(fndecl
&& DECL_RESULT (fndecl
)
8704 && DECL_BY_REFERENCE (DECL_RESULT (fndecl
))))
8713 tree temp
= create_tmp_reg (TREE_TYPE (lhs
), NULL
);
8714 if (gimple_in_ssa_p (cfun
))
8715 temp
= make_ssa_name (temp
, NULL
);
8716 gimple_set_lhs (stmt
, temp
);
8717 post_stmt
= gimple_build_assign (lhs
, temp
);
8718 if (TREE_CODE (lhs
) == SSA_NAME
)
8719 SSA_NAME_DEF_STMT (lhs
) = post_stmt
;
8725 if (!gimple_seq_empty_p (pre
))
8726 gsi_insert_seq_before (gsi_p
, pre
, GSI_SAME_STMT
);
8728 gsi_insert_after (gsi_p
, post_stmt
, GSI_NEW_STMT
);
8730 pop_gimplify_context (NULL
);
8733 /* Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
8734 the predicate that will hold for the result. If VAR is not NULL, make the
8735 base variable of the final destination be VAR if suitable. */
8738 force_gimple_operand_1 (tree expr
, gimple_seq
*stmts
,
8739 gimple_predicate gimple_test_f
, tree var
)
8741 enum gimplify_status ret
;
8742 struct gimplify_ctx gctx
;
8743 location_t saved_location
;
8747 /* gimple_test_f might be more strict than is_gimple_val, make
8748 sure we pass both. Just checking gimple_test_f doesn't work
8749 because most gimple predicates do not work recursively. */
8750 if (is_gimple_val (expr
)
8751 && (*gimple_test_f
) (expr
))
8754 push_gimplify_context (&gctx
);
8755 gimplify_ctxp
->into_ssa
= gimple_in_ssa_p (cfun
);
8756 gimplify_ctxp
->allow_rhs_cond_expr
= true;
8757 saved_location
= input_location
;
8758 input_location
= UNKNOWN_LOCATION
;
8762 if (gimplify_ctxp
->into_ssa
8763 && is_gimple_reg (var
))
8764 var
= make_ssa_name (var
, NULL
);
8765 expr
= build2 (MODIFY_EXPR
, TREE_TYPE (var
), var
, expr
);
8768 if (TREE_CODE (expr
) != MODIFY_EXPR
8769 && TREE_TYPE (expr
) == void_type_node
)
8771 gimplify_and_add (expr
, stmts
);
8776 ret
= gimplify_expr (&expr
, stmts
, NULL
, gimple_test_f
, fb_rvalue
);
8777 gcc_assert (ret
!= GS_ERROR
);
8780 input_location
= saved_location
;
8781 pop_gimplify_context (NULL
);
8786 /* Expand EXPR to list of gimple statements STMTS. If SIMPLE is true,
8787 force the result to be either ssa_name or an invariant, otherwise
8788 just force it to be a rhs expression. If VAR is not NULL, make the
8789 base variable of the final destination be VAR if suitable. */
8792 force_gimple_operand (tree expr
, gimple_seq
*stmts
, bool simple
, tree var
)
8794 return force_gimple_operand_1 (expr
, stmts
,
8795 simple
? is_gimple_val
: is_gimple_reg_rhs
,
8799 /* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
8800 and VAR. If some statements are produced, emits them at GSI.
8801 If BEFORE is true. the statements are appended before GSI, otherwise
8802 they are appended after it. M specifies the way GSI moves after
8803 insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values). */
8806 force_gimple_operand_gsi_1 (gimple_stmt_iterator
*gsi
, tree expr
,
8807 gimple_predicate gimple_test_f
,
8808 tree var
, bool before
,
8809 enum gsi_iterator_update m
)
8813 expr
= force_gimple_operand_1 (expr
, &stmts
, gimple_test_f
, var
);
8815 if (!gimple_seq_empty_p (stmts
))
8818 gsi_insert_seq_before (gsi
, stmts
, m
);
8820 gsi_insert_seq_after (gsi
, stmts
, m
);
8826 /* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
8827 If SIMPLE is true, force the result to be either ssa_name or an invariant,
8828 otherwise just force it to be a rhs expression. If some statements are
8829 produced, emits them at GSI. If BEFORE is true, the statements are
8830 appended before GSI, otherwise they are appended after it. M specifies
8831 the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
8832 are the usual values). */
8835 force_gimple_operand_gsi (gimple_stmt_iterator
*gsi
, tree expr
,
8836 bool simple_p
, tree var
, bool before
,
8837 enum gsi_iterator_update m
)
8839 return force_gimple_operand_gsi_1 (gsi
, expr
,
8841 ? is_gimple_val
: is_gimple_reg_rhs
,
8846 #include "gt-gimplify.h"